]> 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
install the analogclock package
[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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2958 PyObject* tup = PyTuple_New(2);
2959 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2960 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2961 wxPyEndBlockThreads(blocked);
2962 return tup;
2963 }
2964
2965 SWIGINTERN int
2966 SWIG_AsVal_double (PyObject *obj, double* val)
2967 {
2968 if (PyNumber_Check(obj)) {
2969 if (val) *val = PyFloat_AsDouble(obj);
2970 return SWIG_OK;
2971 }
2972 return SWIG_TypeError;
2973 }
2974
2975
2976 #define SWIG_From_double PyFloat_FromDouble
2977
2978 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
2979 self->x = x;
2980 self->y = y;
2981 }
2982 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 PyObject* tup = PyTuple_New(2);
2985 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
2986 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
2987 wxPyEndBlockThreads(blocked);
2988 return tup;
2989 }
2990 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
2991 self->x = x;
2992 self->y = y;
2993 }
2994 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
2995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2996 PyObject* tup = PyTuple_New(2);
2997 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2998 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2999 wxPyEndBlockThreads(blocked);
3000 return tup;
3001 }
3002 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3003 self->x = x;
3004 self->y = y;
3005 self->width = width;
3006 self->height = height;
3007 }
3008 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3010 PyObject* tup = PyTuple_New(4);
3011 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3012 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3013 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3014 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3015 wxPyEndBlockThreads(blocked);
3016 return tup;
3017 }
3018
3019 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3020 wxRegion reg1(*r1);
3021 wxRegion reg2(*r2);
3022 wxRect dest(0,0,0,0);
3023 PyObject* obj;
3024
3025 reg1.Intersect(reg2);
3026 dest = reg1.GetBox();
3027
3028 if (dest != wxRect(0,0,0,0)) {
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3030 wxRect* newRect = new wxRect(dest);
3031 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3032 wxPyEndBlockThreads(blocked);
3033 return obj;
3034 }
3035 Py_INCREF(Py_None);
3036 return Py_None;
3037 }
3038
3039 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3040 self->m_x = x;
3041 self->m_y = y;
3042 }
3043 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3045 PyObject* tup = PyTuple_New(2);
3046 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3047 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3048 wxPyEndBlockThreads(blocked);
3049 return tup;
3050 }
3051
3052 #include "wx/wxPython/pyistream.h"
3053
3054 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3055 wxInputStream* wxis = wxPyCBInputStream::create(p);
3056 if (wxis)
3057 return new wxPyInputStream(wxis);
3058 else
3059 return NULL;
3060 }
3061
3062 SWIGINTERN swig_type_info*
3063 SWIG_pchar_descriptor()
3064 {
3065 static int init = 0;
3066 static swig_type_info* info = 0;
3067 if (!init) {
3068 info = SWIG_TypeQuery("_p_char");
3069 init = 1;
3070 }
3071 return info;
3072 }
3073
3074
3075 SWIGINTERNINLINE PyObject *
3076 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3077 {
3078 if (carray) {
3079 if (size > INT_MAX) {
3080 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3081 return pchar_descriptor ?
3082 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3083 } else {
3084 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3085 }
3086 } else {
3087 return SWIG_Py_Void();
3088 }
3089 }
3090
3091
3092 SWIGINTERNINLINE PyObject *
3093 SWIG_From_char (char c)
3094 {
3095 return SWIG_FromCharPtrAndSize(&c,1);
3096 }
3097
3098
3099 SWIGINTERNINLINE PyObject*
3100 SWIG_From_unsigned_SS_long (unsigned long value)
3101 {
3102 return (value > LONG_MAX) ?
3103 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3104 }
3105
3106
3107 SWIGINTERNINLINE PyObject *
3108 SWIG_From_size_t (size_t value)
3109 {
3110 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3111 }
3112
3113
3114 SWIGINTERN int
3115 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3116 {
3117 if (PyString_Check(obj)) {
3118 char *cstr; int len;
3119 PyString_AsStringAndSize(obj, &cstr, &len);
3120 if (cptr) {
3121 if (alloc) {
3122 /*
3123 In python the user should not be able to modify the inner
3124 string representation. To warranty that, if you define
3125 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3126 buffer is always returned.
3127
3128 The default behavior is just to return the pointer value,
3129 so, be careful.
3130 */
3131 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3132 if (*alloc != SWIG_OLDOBJ)
3133 #else
3134 if (*alloc == SWIG_NEWOBJ)
3135 #endif
3136 {
3137 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3138 *alloc = SWIG_NEWOBJ;
3139 }
3140 else {
3141 *cptr = cstr;
3142 *alloc = SWIG_OLDOBJ;
3143 }
3144 } else {
3145 *cptr = PyString_AsString(obj);
3146 }
3147 }
3148 if (psize) *psize = len + 1;
3149 return SWIG_OK;
3150 } else {
3151 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3152 if (pchar_descriptor) {
3153 void* vptr = 0;
3154 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3155 if (cptr) *cptr = (char *) vptr;
3156 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3157 if (alloc) *alloc = SWIG_OLDOBJ;
3158 return SWIG_OK;
3159 }
3160 }
3161 }
3162 return SWIG_TypeError;
3163 }
3164
3165
3166 SWIGINTERN int
3167 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3168 {
3169 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3170 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3171 if (SWIG_IsOK(res)) {
3172 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3173 if (csize <= size) {
3174 if (val) {
3175 if (csize) memcpy(val, cptr, csize*sizeof(char));
3176 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3177 }
3178 if (alloc == SWIG_NEWOBJ) {
3179 delete[] cptr;
3180 res = SWIG_DelNewMask(res);
3181 }
3182 return res;
3183 }
3184 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3185 }
3186 return SWIG_TypeError;
3187 }
3188
3189
3190 SWIGINTERN int
3191 SWIG_AsVal_char (PyObject * obj, char *val)
3192 {
3193 int res = SWIG_AsCharArray(obj, val, 1);
3194 if (!SWIG_IsOK(res)) {
3195 long v;
3196 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3197 if (SWIG_IsOK(res)) {
3198 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3199 if (val) *val = static_cast< char >(v);
3200 } else {
3201 res = SWIG_OverflowError;
3202 }
3203 }
3204 }
3205 return res;
3206 }
3207
3208 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3209 // We use only strings for the streams, not unicode
3210 PyObject* str = PyObject_Str(obj);
3211 if (! str) {
3212 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3213 return;
3214 }
3215 self->Write(PyString_AS_STRING(str),
3216 PyString_GET_SIZE(str));
3217 Py_DECREF(str);
3218 }
3219
3220 #include "wx/wxPython/pyistream.h"
3221
3222
3223 class wxPyFileSystemHandler : public wxFileSystemHandler
3224 {
3225 public:
3226 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3227
3228 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3229 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3230 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3231 DEC_PYCALLBACK_STRING__pure(FindNext);
3232
3233 wxString GetProtocol(const wxString& location) {
3234 return wxFileSystemHandler::GetProtocol(location);
3235 }
3236
3237 wxString GetLeftLocation(const wxString& location) {
3238 return wxFileSystemHandler::GetLeftLocation(location);
3239 }
3240
3241 wxString GetAnchor(const wxString& location) {
3242 return wxFileSystemHandler::GetAnchor(location);
3243 }
3244
3245 wxString GetRightLocation(const wxString& location) {
3246 return wxFileSystemHandler::GetRightLocation(location);
3247 }
3248
3249 wxString GetMimeTypeFromExt(const wxString& location) {
3250 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3251 }
3252
3253 PYPRIVATE;
3254 };
3255
3256
3257 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3258 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3259 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3260 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsVal_bool (PyObject *obj, bool *val)
3265 {
3266 if (obj == Py_True) {
3267 if (val) *val = true;
3268 return SWIG_OK;
3269 } else if (obj == Py_False) {
3270 if (val) *val = false;
3271 return SWIG_OK;
3272 } else {
3273 long v = 0;
3274 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3275 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3276 return res;
3277 }
3278 }
3279
3280 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3281 wxFileName fname = wxFileSystem::URLToFileName(url);
3282 return fname.GetFullPath();
3283 }
3284
3285 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3286 wxImage& image,
3287 long type) {
3288 wxMemoryFSHandler::AddFile(filename, image, type);
3289 }
3290
3291 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3292 const wxBitmap& bitmap,
3293 long type) {
3294 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3295 }
3296
3297 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3298 PyObject* data) {
3299 if (! PyString_Check(data)) {
3300 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3301 "Expected string object"));
3302 return;
3303 }
3304
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 void* ptr = (void*)PyString_AsString(data);
3307 size_t size = PyString_Size(data);
3308 wxPyEndBlockThreads(blocked);
3309
3310 wxMemoryFSHandler::AddFile(filename, ptr, size);
3311 }
3312
3313
3314 #include "wx/wxPython/pyistream.h"
3315
3316
3317 SWIGINTERN int
3318 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3319 {
3320 long v = 0;
3321 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3322 return SWIG_TypeError;
3323 }
3324 else if (val)
3325 *val = (unsigned long)v;
3326 return SWIG_OK;
3327 }
3328
3329
3330 SWIGINTERN int
3331 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3332 {
3333 unsigned long v;
3334 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3335 if (SWIG_IsOK(res)) {
3336 if ((v > UCHAR_MAX)) {
3337 return SWIG_OverflowError;
3338 } else {
3339 if (val) *val = static_cast< unsigned char >(v);
3340 }
3341 }
3342 return res;
3343 }
3344
3345
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_From_unsigned_SS_char (unsigned char value)
3348 {
3349 return SWIG_From_unsigned_SS_long (value);
3350 }
3351
3352 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3353 wxImageHistogramEntry e = (*self)[key];
3354 return e.value;
3355 }
3356 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3357 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3358 wxImageHistogramEntry e = (*self)[key];
3359 return e.value;
3360 }
3361 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3362 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3363 colour.Green(),
3364 colour.Blue());
3365 wxImageHistogramEntry e = (*self)[key];
3366 return e.value;
3367 }
3368
3369 typedef unsigned char* buffer;
3370
3371
3372 // Pull the nested class out to the top level for SWIG's sake
3373 #define wxImage_RGBValue wxImage::RGBValue
3374 #define wxImage_HSVValue wxImage::HSVValue
3375
3376 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3377 if (width > 0 && height > 0)
3378 return new wxImage(width, height, clear);
3379 else
3380 return new wxImage;
3381 }
3382 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3383 return new wxImage(bitmap.ConvertToImage());
3384 }
3385 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3386 if (DATASIZE != width*height*3) {
3387 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3388 return NULL;
3389 }
3390
3391 // Copy the source data so the wxImage can clean it up later
3392 buffer copy = (buffer)malloc(DATASIZE);
3393 if (copy == NULL) {
3394 wxPyBLOCK_THREADS(PyErr_NoMemory());
3395 return NULL;
3396 }
3397 memcpy(copy, data, DATASIZE);
3398 return new wxImage(width, height, copy, false);
3399 }
3400 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3401 if (DATASIZE != width*height*3) {
3402 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3403 return NULL;
3404 }
3405 if (ALPHASIZE != width*height) {
3406 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3407 return NULL;
3408 }
3409
3410 // Copy the source data so the wxImage can clean it up later
3411 buffer dcopy = (buffer)malloc(DATASIZE);
3412 if (dcopy == NULL) {
3413 wxPyBLOCK_THREADS(PyErr_NoMemory());
3414 return NULL;
3415 }
3416 memcpy(dcopy, data, DATASIZE);
3417
3418 buffer acopy = (buffer)malloc(ALPHASIZE);
3419 if (acopy == NULL) {
3420 wxPyBLOCK_THREADS(PyErr_NoMemory());
3421 return NULL;
3422 }
3423 memcpy(acopy, alpha, ALPHASIZE);
3424
3425 return new wxImage(width, height, dcopy, acopy, false);
3426 }
3427 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3428 wxSize size(self->GetWidth(), self->GetHeight());
3429 return size;
3430 }
3431 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3432 buffer data = self->GetData();
3433 int len = self->GetWidth() * self->GetHeight() * 3;
3434 PyObject* rv;
3435 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3436 return rv;
3437 }
3438 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3439 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3440 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3441 return;
3442 }
3443 buffer copy = (buffer)malloc(DATASIZE);
3444 if (copy == NULL) {
3445 wxPyBLOCK_THREADS(PyErr_NoMemory());
3446 return;
3447 }
3448 memcpy(copy, data, DATASIZE);
3449 self->SetData(copy, false);
3450 // wxImage takes ownership of copy...
3451 }
3452 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3453 buffer data = self->GetData();
3454 int len = self->GetWidth() * self->GetHeight() * 3;
3455 PyObject* rv;
3456 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3457 return rv;
3458 }
3459 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3460 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3461 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3462 return;
3463 }
3464 self->SetData(data, true);
3465 }
3466 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3467 buffer data = self->GetAlpha();
3468 if (! data) {
3469 RETURN_NONE();
3470 } else {
3471 int len = self->GetWidth() * self->GetHeight();
3472 PyObject* rv;
3473 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3474 return rv;
3475 }
3476 }
3477 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3478 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3480 return;
3481 }
3482 buffer acopy = (buffer)malloc(ALPHASIZE);
3483 if (acopy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return;
3486 }
3487 memcpy(acopy, alpha, ALPHASIZE);
3488 self->SetAlpha(acopy, false);
3489 // wxImage takes ownership of acopy...
3490 }
3491 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3492 buffer data = self->GetAlpha();
3493 int len = self->GetWidth() * self->GetHeight();
3494 PyObject* rv;
3495 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3496 return rv;
3497 }
3498 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3499 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3500 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3501 return;
3502 }
3503 self->SetAlpha(alpha, true);
3504 }
3505 SWIGINTERN PyObject *wxImage_GetHandlers(){
3506 wxList& list = wxImage::GetHandlers();
3507 return wxPy_ConvertList(&list);
3508 }
3509 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3510 wxBitmap bitmap(*self, depth);
3511 return bitmap;
3512 }
3513 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3514 wxImage mono = self->ConvertToMono( red, green, blue );
3515 wxBitmap bitmap( mono, 1 );
3516 return bitmap;
3517 }
3518 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3519 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3520 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3521 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3522 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3523 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3524 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3525 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3526 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3527 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3528 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3529 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3530 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3531 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3532 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3533
3534 #include <wx/quantize.h>
3535
3536 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3537 return wxQuantize::Quantize(src, dest,
3538 //NULL, // palette
3539 desiredNoColours,
3540 NULL, // eightBitData
3541 flags);
3542 }
3543 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3544 if (PyCallable_Check(func)) {
3545 self->Connect(id, lastId, eventType,
3546 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3547 new wxPyCallback(func));
3548 }
3549 else if (func == Py_None) {
3550 self->Disconnect(id, lastId, eventType,
3551 (wxObjectEventFunction)
3552 &wxPyCallback::EventThunker);
3553 }
3554 else {
3555 wxPyBLOCK_THREADS(
3556 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3557 }
3558 }
3559 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3560 return self->Disconnect(id, lastId, eventType,
3561 (wxObjectEventFunction)
3562 &wxPyCallback::EventThunker);
3563 }
3564 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3565 if (_self && _self != Py_None) {
3566 self->SetClientObject(new wxPyOORClientData(_self, incref));
3567 }
3568 else {
3569 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3570 if (data) {
3571 self->SetClientObject(NULL); // This will delete it too
3572 }
3573 }
3574 }
3575
3576 #if ! wxUSE_HOTKEY
3577 #define wxEVT_HOTKEY -9999
3578 #endif
3579
3580 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3581 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3582 if (data) {
3583 Py_INCREF(data->m_obj);
3584 return data->m_obj;
3585 } else {
3586 Py_INCREF(Py_None);
3587 return Py_None;
3588 }
3589 }
3590 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3591 wxPyClientData* data = new wxPyClientData(clientData);
3592 self->SetClientObject(data);
3593 }
3594 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3595 #if wxUSE_UNICODE
3596 return self->GetUnicodeKey();
3597 #else
3598 return 0;
3599 #endif
3600 }
3601
3602 SWIGINTERNINLINE PyObject *
3603 SWIG_From_unsigned_SS_int (unsigned int value)
3604 {
3605 return SWIG_From_unsigned_SS_long (value);
3606 }
3607
3608
3609 SWIGINTERN int
3610 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3611 {
3612 unsigned long v;
3613 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3614 if (SWIG_IsOK(res)) {
3615 if ((v > UINT_MAX)) {
3616 return SWIG_OverflowError;
3617 } else {
3618 if (val) *val = static_cast< unsigned int >(v);
3619 }
3620 }
3621 return res;
3622 }
3623
3624 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3625 self->m_size = size;
3626 }
3627 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3628 int count = self->GetNumberOfFiles();
3629 wxString* files = self->GetFiles();
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* list = PyList_New(count);
3632
3633 if (!list) {
3634 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3635 wxPyEndBlockThreads(blocked);
3636 return NULL;
3637 }
3638
3639 for (int i=0; i<count; i++) {
3640 PyList_SetItem(list, i, wx2PyString(files[i]));
3641 }
3642 wxPyEndBlockThreads(blocked);
3643 return list;
3644 }
3645
3646
3647 SWIGINTERN wxPyApp *new_wxPyApp(){
3648 wxPythonApp = new wxPyApp();
3649 return wxPythonApp;
3650 }
3651 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3652
3653 void wxApp_CleanUp() {
3654 __wxPyCleanup();
3655 }
3656
3657
3658 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3659
3660
3661
3662
3663
3664 SWIGINTERNINLINE PyObject *
3665 SWIG_FromCharPtr(const char *cptr)
3666 {
3667 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3668 }
3669
3670
3671 #if 0 // #ifdef __WXMAC__
3672
3673 // A dummy class that raises an exception if used...
3674 class wxEventLoop
3675 {
3676 public:
3677 wxEventLoop() { wxPyRaiseNotImplemented(); }
3678 int Run() { return 0; }
3679 void Exit(int rc = 0) {}
3680 bool Pending() const { return false; }
3681 bool Dispatch() { return false; }
3682 bool IsRunning() const { return false; }
3683 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3684 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3685 };
3686
3687 #else
3688
3689 #include <wx/evtloop.h>
3690
3691 #endif
3692
3693
3694
3695 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3696 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3697 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3698 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3699 wxWindowList& list = self->GetChildren();
3700 return wxPy_ConvertList(&list);
3701 }
3702 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3703 #if wxUSE_HOTKEY
3704 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3705 #else
3706 return false;
3707 #endif
3708 }
3709 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3710
3711
3712
3713 return false;
3714
3715 }
3716 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3717 return wxPyGetWinHandle(self);
3718 }
3719 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3720 self->AssociateHandle((WXWidget)handle);
3721 }
3722 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3723
3724 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3725 return wxWindow::FindWindowById(id, parent);
3726 }
3727
3728 wxWindow* wxFindWindowByName( const wxString& name,
3729 const wxWindow *parent = NULL ) {
3730 return wxWindow::FindWindowByName(name, parent);
3731 }
3732
3733 wxWindow* wxFindWindowByLabel( const wxString& label,
3734 const wxWindow *parent = NULL ) {
3735 return wxWindow::FindWindowByLabel(label, parent);
3736 }
3737
3738
3739 #ifdef __WXMSW__
3740 #include <wx/msw/private.h> // to get wxGetWindowId
3741 #endif
3742
3743
3744 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3745 #ifdef __WXMSW__
3746 WXHWND hWnd = (WXHWND)_hWnd;
3747 long id = wxGetWindowId(hWnd);
3748 wxWindow* win = new wxWindow;
3749 if (parent)
3750 parent->AddChild(win);
3751 win->SetEventHandler(win);
3752 win->SetHWND(hWnd);
3753 win->SetId(id);
3754 win->SubclassWin(hWnd);
3755 win->AdoptAttributesFromHWND();
3756 win->SetupColours();
3757 return win;
3758 #else
3759 wxPyRaiseNotImplemented();
3760 return NULL;
3761 #endif
3762 }
3763
3764
3765 PyObject* GetTopLevelWindows() {
3766 return wxPy_ConvertList(&wxTopLevelWindows);
3767 }
3768
3769
3770 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3772 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3773
3774 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3775
3776
3777 SWIGINTERNINLINE int
3778 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3779 {
3780 unsigned long v;
3781 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3782 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3783 return res;
3784 }
3785
3786 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3787 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3788 wxMenuItemList& list = self->GetMenuItems();
3789 return wxPy_ConvertList(&list);
3790 }
3791 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3792 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3793 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3794 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3795 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3796 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3797 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3798 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3799 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3800 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3801 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3802 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3803 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3804 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3805 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3806 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3807 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3808 static const wxString wxPyControlNameStr(wxControlNameStr);
3809 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3810 if (clientData) {
3811 wxPyClientData* data = new wxPyClientData(clientData);
3812 return self->Append(item, data);
3813 } else
3814 return self->Append(item);
3815 }
3816 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3817 if (clientData) {
3818 wxPyClientData* data = new wxPyClientData(clientData);
3819 return self->Insert(item, pos, data);
3820 } else
3821 return self->Insert(item, pos);
3822 }
3823 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3824 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3825 if (data) {
3826 Py_INCREF(data->m_obj);
3827 return data->m_obj;
3828 } else {
3829 Py_INCREF(Py_None);
3830 return Py_None;
3831 }
3832 }
3833 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3834 wxPyClientData* data = new wxPyClientData(clientData);
3835 self->SetClientObject(n, data);
3836 }
3837
3838
3839 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3840 wxPyUserData* data = NULL;
3841 if ( userData ) {
3842 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3843 data = new wxPyUserData(userData);
3844 wxPyEndBlockThreads(blocked);
3845 }
3846 return new wxSizerItem(window, proportion, flag, border, data);
3847 }
3848 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3849 wxPyUserData* data = NULL;
3850 if ( userData ) {
3851 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3852 data = new wxPyUserData(userData);
3853 wxPyEndBlockThreads(blocked);
3854 }
3855 return new wxSizerItem(width, height, proportion, flag, border, data);
3856 }
3857 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3858 wxPyUserData* data = NULL;
3859 if ( userData ) {
3860 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3861 data = new wxPyUserData(userData);
3862 wxPyEndBlockThreads(blocked);
3863 }
3864 return new wxSizerItem(sizer, proportion, flag, border, data);
3865 }
3866
3867 #include <float.h>
3868
3869
3870 SWIGINTERN int
3871 SWIG_AsVal_float (PyObject * obj, float *val)
3872 {
3873 double v;
3874 int res = SWIG_AsVal_double (obj, &v);
3875 if (SWIG_IsOK(res)) {
3876 if ((v < -FLT_MAX || v > FLT_MAX)) {
3877 return SWIG_OverflowError;
3878 } else {
3879 if (val) *val = static_cast< float >(v);
3880 }
3881 }
3882 return res;
3883 }
3884
3885
3886 SWIGINTERNINLINE PyObject *
3887 SWIG_From_float (float value)
3888 {
3889 return SWIG_From_double (value);
3890 }
3891
3892 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3893 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3894 if (data) {
3895 Py_INCREF(data->m_obj);
3896 return data->m_obj;
3897 } else {
3898 Py_INCREF(Py_None);
3899 return Py_None;
3900 }
3901 }
3902 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3903 wxPyUserData* data = NULL;
3904 if ( userData ) {
3905 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3906 data = new wxPyUserData(userData);
3907 wxPyEndBlockThreads(blocked);
3908 }
3909 self->SetUserData(data);
3910 }
3911
3912 // Figure out the type of the sizer item
3913
3914 struct wxPySizerItemInfo {
3915 wxPySizerItemInfo()
3916 : window(NULL), sizer(NULL), gotSize(false),
3917 size(wxDefaultSize), gotPos(false), pos(-1)
3918 {}
3919
3920 wxWindow* window;
3921 wxSizer* sizer;
3922 bool gotSize;
3923 wxSize size;
3924 bool gotPos;
3925 int pos;
3926 };
3927
3928 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3929
3930 wxPySizerItemInfo info;
3931 wxSize size;
3932 wxSize* sizePtr = &size;
3933
3934 // Find out what the type of the item is
3935 // try wxWindow
3936 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3937 PyErr_Clear();
3938 info.window = NULL;
3939
3940 // try wxSizer
3941 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3942 PyErr_Clear();
3943 info.sizer = NULL;
3944
3945 // try wxSize or (w,h)
3946 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3947 info.size = *sizePtr;
3948 info.gotSize = true;
3949 }
3950
3951 // or a single int
3952 if (checkIdx && PyInt_Check(item)) {
3953 info.pos = PyInt_AsLong(item);
3954 info.gotPos = true;
3955 }
3956 }
3957 }
3958
3959 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3960 // no expected type, figure out what kind of error message to generate
3961 if ( !checkSize && !checkIdx )
3962 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3963 else if ( checkSize && !checkIdx )
3964 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3965 else if ( !checkSize && checkIdx)
3966 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3967 else
3968 // can this one happen?
3969 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3970 }
3971
3972 return info;
3973 }
3974
3975 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3976 if (!self->GetClientObject())
3977 self->SetClientObject(new wxPyOORClientData(_self));
3978 }
3979 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3980
3981 wxPyUserData* data = NULL;
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3984 if ( userData && (info.window || info.sizer || info.gotSize) )
3985 data = new wxPyUserData(userData);
3986 if ( info.sizer )
3987 PyObject_SetAttrString(item,"thisown",Py_False);
3988 wxPyEndBlockThreads(blocked);
3989
3990 // Now call the real Add method if a valid item type was found
3991 if ( info.window )
3992 return self->Add(info.window, proportion, flag, border, data);
3993 else if ( info.sizer )
3994 return self->Add(info.sizer, proportion, flag, border, data);
3995 else if (info.gotSize)
3996 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3997 proportion, flag, border, data);
3998 else
3999 return NULL;
4000 }
4001 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4002
4003 wxPyUserData* data = NULL;
4004 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4005 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4006 if ( userData && (info.window || info.sizer || info.gotSize) )
4007 data = new wxPyUserData(userData);
4008 if ( info.sizer )
4009 PyObject_SetAttrString(item,"thisown",Py_False);
4010 wxPyEndBlockThreads(blocked);
4011
4012 // Now call the real Insert method if a valid item type was found
4013 if ( info.window )
4014 return self->Insert(before, info.window, proportion, flag, border, data);
4015 else if ( info.sizer )
4016 return self->Insert(before, info.sizer, proportion, flag, border, data);
4017 else if (info.gotSize)
4018 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4019 proportion, flag, border, data);
4020 else
4021 return NULL;
4022 }
4023 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4024
4025 wxPyUserData* data = NULL;
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4028 if ( userData && (info.window || info.sizer || info.gotSize) )
4029 data = new wxPyUserData(userData);
4030 if ( info.sizer )
4031 PyObject_SetAttrString(item,"thisown",Py_False);
4032 wxPyEndBlockThreads(blocked);
4033
4034 // Now call the real Prepend method if a valid item type was found
4035 if ( info.window )
4036 return self->Prepend(info.window, proportion, flag, border, data);
4037 else if ( info.sizer )
4038 return self->Prepend(info.sizer, proportion, flag, border, data);
4039 else if (info.gotSize)
4040 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4041 proportion, flag, border, data);
4042 else
4043 return NULL;
4044 }
4045 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4048 wxPyEndBlockThreads(blocked);
4049 if ( info.window )
4050 return self->Remove(info.window);
4051 else if ( info.sizer )
4052 return self->Remove(info.sizer);
4053 else if ( info.gotPos )
4054 return self->Remove(info.pos);
4055 else
4056 return false;
4057 }
4058 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4059 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4060 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4061 wxPyEndBlockThreads(blocked);
4062 if ( info.window )
4063 return self->Detach(info.window);
4064 else if ( info.sizer )
4065 return self->Detach(info.sizer);
4066 else if ( info.gotPos )
4067 return self->Detach(info.pos);
4068 else
4069 return false;
4070 }
4071 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4072 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4073 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4074 wxPyEndBlockThreads(blocked);
4075 if ( info.window )
4076 return self->GetItem(info.window);
4077 else if ( info.sizer )
4078 return self->GetItem(info.sizer);
4079 else if ( info.gotPos )
4080 return self->GetItem(info.pos);
4081 else
4082 return NULL;
4083 }
4084 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4085 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4087 wxPyEndBlockThreads(blocked);
4088 if ( info.window )
4089 self->SetItemMinSize(info.window, size);
4090 else if ( info.sizer )
4091 self->SetItemMinSize(info.sizer, size);
4092 else if ( info.gotPos )
4093 self->SetItemMinSize(info.pos, size);
4094 }
4095 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4096 wxSizerItemList& list = self->GetChildren();
4097 return wxPy_ConvertList(&list);
4098 }
4099 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4100 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4101 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4102 wxPyEndBlockThreads(blocked);
4103 if ( info.window )
4104 return self->Show(info.window, show, recursive);
4105 else if ( info.sizer )
4106 return self->Show(info.sizer, show, recursive);
4107 else if ( info.gotPos )
4108 return self->Show(info.pos, show);
4109 else
4110 return false;
4111 }
4112 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4114 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4115 wxPyEndBlockThreads(blocked);
4116 if ( info.window )
4117 return self->IsShown(info.window);
4118 else if ( info.sizer )
4119 return self->IsShown(info.sizer);
4120 else if ( info.gotPos )
4121 return self->IsShown(info.pos);
4122 else
4123 return false;
4124 }
4125
4126 // See pyclasses.h
4127 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4128 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4129 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4130
4131
4132
4133
4134 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4135 {
4136 if (source == Py_None) {
4137 **obj = wxGBPosition(-1,-1);
4138 return true;
4139 }
4140 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4141 }
4142
4143 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4144 {
4145 if (source == Py_None) {
4146 **obj = wxGBSpan(-1,-1);
4147 return true;
4148 }
4149 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4150 }
4151
4152
4153 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4154 self->SetRow(row);
4155 self->SetCol(col);
4156 }
4157 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 PyObject* tup = PyTuple_New(2);
4160 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4161 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4162 wxPyEndBlockThreads(blocked);
4163 return tup;
4164 }
4165 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4166 self->SetRowspan(rowspan);
4167 self->SetColspan(colspan);
4168 }
4169 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 PyObject* tup = PyTuple_New(2);
4172 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4173 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4174 wxPyEndBlockThreads(blocked);
4175 return tup;
4176 }
4177 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4178 wxPyUserData* data = NULL;
4179 if ( userData ) {
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 data = new wxPyUserData(userData);
4182 wxPyEndBlockThreads(blocked);
4183 }
4184 return new wxGBSizerItem(window, pos, span, flag, border, data);
4185 }
4186 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4187 wxPyUserData* data = NULL;
4188 if ( userData ) {
4189 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4190 data = new wxPyUserData(userData);
4191 wxPyEndBlockThreads(blocked);
4192 }
4193 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4194 }
4195 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4196 wxPyUserData* data = NULL;
4197 if ( userData ) {
4198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4199 data = new wxPyUserData(userData);
4200 wxPyEndBlockThreads(blocked);
4201 }
4202 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4203 }
4204 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4205 int row, col;
4206 self->GetEndPos(row, col);
4207 return wxGBPosition(row, col);
4208 }
4209 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4210
4211 wxPyUserData* data = NULL;
4212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4213 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4214 if ( userData && (info.window || info.sizer || info.gotSize) )
4215 data = new wxPyUserData(userData);
4216 if ( info.sizer )
4217 PyObject_SetAttrString(item,"thisown",Py_False);
4218 wxPyEndBlockThreads(blocked);
4219
4220 // Now call the real Add method if a valid item type was found
4221 if ( info.window )
4222 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4223 else if ( info.sizer )
4224 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4225 else if (info.gotSize)
4226 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4227 pos, span, flag, border, data);
4228 return NULL;
4229 }
4230
4231
4232 #ifdef __cplusplus
4233 extern "C" {
4234 #endif
4235 SWIGINTERN int EmptyString_set(PyObject *) {
4236 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4237 return 1;
4238 }
4239
4240
4241 SWIGINTERN PyObject *EmptyString_get(void) {
4242 PyObject *pyobj = 0;
4243
4244 {
4245 #if wxUSE_UNICODE
4246 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4247 #else
4248 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4249 #endif
4250 }
4251 return pyobj;
4252 }
4253
4254
4255 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4256 PyObject *resultobj = 0;
4257 wxObject *arg1 = (wxObject *) 0 ;
4258 wxString result;
4259 void *argp1 = 0 ;
4260 int res1 = 0 ;
4261 PyObject *swig_obj[1] ;
4262
4263 if (!args) SWIG_fail;
4264 swig_obj[0] = args;
4265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4266 if (!SWIG_IsOK(res1)) {
4267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4268 }
4269 arg1 = reinterpret_cast< wxObject * >(argp1);
4270 {
4271 PyThreadState* __tstate = wxPyBeginAllowThreads();
4272 result = wxObject_GetClassName(arg1);
4273 wxPyEndAllowThreads(__tstate);
4274 if (PyErr_Occurred()) SWIG_fail;
4275 }
4276 {
4277 #if wxUSE_UNICODE
4278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4279 #else
4280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4281 #endif
4282 }
4283 return resultobj;
4284 fail:
4285 return NULL;
4286 }
4287
4288
4289 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4290 PyObject *resultobj = 0;
4291 wxObject *arg1 = (wxObject *) 0 ;
4292 void *argp1 = 0 ;
4293 int res1 = 0 ;
4294 PyObject *swig_obj[1] ;
4295
4296 if (!args) SWIG_fail;
4297 swig_obj[0] = args;
4298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4299 if (!SWIG_IsOK(res1)) {
4300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4301 }
4302 arg1 = reinterpret_cast< wxObject * >(argp1);
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 wxObject_Destroy(arg1);
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 resultobj = SWIG_Py_Void();
4310 return resultobj;
4311 fail:
4312 return NULL;
4313 }
4314
4315
4316 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4317 PyObject *obj;
4318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4319 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4320 return SWIG_Py_Void();
4321 }
4322
4323 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4324 PyObject *resultobj = 0;
4325 wxSize *arg1 = (wxSize *) 0 ;
4326 int arg2 ;
4327 void *argp1 = 0 ;
4328 int res1 = 0 ;
4329 int val2 ;
4330 int ecode2 = 0 ;
4331 PyObject *swig_obj[2] ;
4332
4333 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4335 if (!SWIG_IsOK(res1)) {
4336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4337 }
4338 arg1 = reinterpret_cast< wxSize * >(argp1);
4339 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4340 if (!SWIG_IsOK(ecode2)) {
4341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4342 }
4343 arg2 = static_cast< int >(val2);
4344 if (arg1) (arg1)->x = arg2;
4345
4346 resultobj = SWIG_Py_Void();
4347 return resultobj;
4348 fail:
4349 return NULL;
4350 }
4351
4352
4353 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4354 PyObject *resultobj = 0;
4355 wxSize *arg1 = (wxSize *) 0 ;
4356 int result;
4357 void *argp1 = 0 ;
4358 int res1 = 0 ;
4359 PyObject *swig_obj[1] ;
4360
4361 if (!args) SWIG_fail;
4362 swig_obj[0] = args;
4363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4364 if (!SWIG_IsOK(res1)) {
4365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4366 }
4367 arg1 = reinterpret_cast< wxSize * >(argp1);
4368 result = (int) ((arg1)->x);
4369 resultobj = SWIG_From_int(static_cast< int >(result));
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4377 PyObject *resultobj = 0;
4378 wxSize *arg1 = (wxSize *) 0 ;
4379 int arg2 ;
4380 void *argp1 = 0 ;
4381 int res1 = 0 ;
4382 int val2 ;
4383 int ecode2 = 0 ;
4384 PyObject *swig_obj[2] ;
4385
4386 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4388 if (!SWIG_IsOK(res1)) {
4389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4390 }
4391 arg1 = reinterpret_cast< wxSize * >(argp1);
4392 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4393 if (!SWIG_IsOK(ecode2)) {
4394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4395 }
4396 arg2 = static_cast< int >(val2);
4397 if (arg1) (arg1)->y = arg2;
4398
4399 resultobj = SWIG_Py_Void();
4400 return resultobj;
4401 fail:
4402 return NULL;
4403 }
4404
4405
4406 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4407 PyObject *resultobj = 0;
4408 wxSize *arg1 = (wxSize *) 0 ;
4409 int result;
4410 void *argp1 = 0 ;
4411 int res1 = 0 ;
4412 PyObject *swig_obj[1] ;
4413
4414 if (!args) SWIG_fail;
4415 swig_obj[0] = args;
4416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4417 if (!SWIG_IsOK(res1)) {
4418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4419 }
4420 arg1 = reinterpret_cast< wxSize * >(argp1);
4421 result = (int) ((arg1)->y);
4422 resultobj = SWIG_From_int(static_cast< int >(result));
4423 return resultobj;
4424 fail:
4425 return NULL;
4426 }
4427
4428
4429 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4430 PyObject *resultobj = 0;
4431 int arg1 = (int) 0 ;
4432 int arg2 = (int) 0 ;
4433 wxSize *result = 0 ;
4434 int val1 ;
4435 int ecode1 = 0 ;
4436 int val2 ;
4437 int ecode2 = 0 ;
4438 PyObject * obj0 = 0 ;
4439 PyObject * obj1 = 0 ;
4440 char * kwnames[] = {
4441 (char *) "w",(char *) "h", NULL
4442 };
4443
4444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4445 if (obj0) {
4446 ecode1 = SWIG_AsVal_int(obj0, &val1);
4447 if (!SWIG_IsOK(ecode1)) {
4448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4449 }
4450 arg1 = static_cast< int >(val1);
4451 }
4452 if (obj1) {
4453 ecode2 = SWIG_AsVal_int(obj1, &val2);
4454 if (!SWIG_IsOK(ecode2)) {
4455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4456 }
4457 arg2 = static_cast< int >(val2);
4458 }
4459 {
4460 PyThreadState* __tstate = wxPyBeginAllowThreads();
4461 result = (wxSize *)new wxSize(arg1,arg2);
4462 wxPyEndAllowThreads(__tstate);
4463 if (PyErr_Occurred()) SWIG_fail;
4464 }
4465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4466 return resultobj;
4467 fail:
4468 return NULL;
4469 }
4470
4471
4472 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4473 PyObject *resultobj = 0;
4474 wxSize *arg1 = (wxSize *) 0 ;
4475 void *argp1 = 0 ;
4476 int res1 = 0 ;
4477 PyObject *swig_obj[1] ;
4478
4479 if (!args) SWIG_fail;
4480 swig_obj[0] = args;
4481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4482 if (!SWIG_IsOK(res1)) {
4483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4484 }
4485 arg1 = reinterpret_cast< wxSize * >(argp1);
4486 {
4487 PyThreadState* __tstate = wxPyBeginAllowThreads();
4488 delete arg1;
4489
4490 wxPyEndAllowThreads(__tstate);
4491 if (PyErr_Occurred()) SWIG_fail;
4492 }
4493 resultobj = SWIG_Py_Void();
4494 return resultobj;
4495 fail:
4496 return NULL;
4497 }
4498
4499
4500 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4501 PyObject *resultobj = 0;
4502 wxSize *arg1 = (wxSize *) 0 ;
4503 wxSize *arg2 = 0 ;
4504 bool result;
4505 void *argp1 = 0 ;
4506 int res1 = 0 ;
4507 wxSize temp2 ;
4508 PyObject * obj0 = 0 ;
4509 PyObject * obj1 = 0 ;
4510 char * kwnames[] = {
4511 (char *) "self",(char *) "sz", NULL
4512 };
4513
4514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4516 if (!SWIG_IsOK(res1)) {
4517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4518 }
4519 arg1 = reinterpret_cast< wxSize * >(argp1);
4520 {
4521 arg2 = &temp2;
4522 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4523 }
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
4527 wxPyEndAllowThreads(__tstate);
4528 if (PyErr_Occurred()) SWIG_fail;
4529 }
4530 {
4531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4532 }
4533 return resultobj;
4534 fail:
4535 return NULL;
4536 }
4537
4538
4539 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4540 PyObject *resultobj = 0;
4541 wxSize *arg1 = (wxSize *) 0 ;
4542 wxSize *arg2 = 0 ;
4543 bool result;
4544 void *argp1 = 0 ;
4545 int res1 = 0 ;
4546 wxSize temp2 ;
4547 PyObject * obj0 = 0 ;
4548 PyObject * obj1 = 0 ;
4549 char * kwnames[] = {
4550 (char *) "self",(char *) "sz", NULL
4551 };
4552
4553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4555 if (!SWIG_IsOK(res1)) {
4556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4557 }
4558 arg1 = reinterpret_cast< wxSize * >(argp1);
4559 {
4560 arg2 = &temp2;
4561 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4562 }
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 {
4570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4571 }
4572 return resultobj;
4573 fail:
4574 return NULL;
4575 }
4576
4577
4578 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4579 PyObject *resultobj = 0;
4580 wxSize *arg1 = (wxSize *) 0 ;
4581 wxSize *arg2 = 0 ;
4582 wxSize result;
4583 void *argp1 = 0 ;
4584 int res1 = 0 ;
4585 wxSize temp2 ;
4586 PyObject * obj0 = 0 ;
4587 PyObject * obj1 = 0 ;
4588 char * kwnames[] = {
4589 (char *) "self",(char *) "sz", NULL
4590 };
4591
4592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4594 if (!SWIG_IsOK(res1)) {
4595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4596 }
4597 arg1 = reinterpret_cast< wxSize * >(argp1);
4598 {
4599 arg2 = &temp2;
4600 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4601 }
4602 {
4603 PyThreadState* __tstate = wxPyBeginAllowThreads();
4604 result = (arg1)->operator +((wxSize const &)*arg2);
4605 wxPyEndAllowThreads(__tstate);
4606 if (PyErr_Occurred()) SWIG_fail;
4607 }
4608 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4609 return resultobj;
4610 fail:
4611 return NULL;
4612 }
4613
4614
4615 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4616 PyObject *resultobj = 0;
4617 wxSize *arg1 = (wxSize *) 0 ;
4618 wxSize *arg2 = 0 ;
4619 wxSize result;
4620 void *argp1 = 0 ;
4621 int res1 = 0 ;
4622 wxSize temp2 ;
4623 PyObject * obj0 = 0 ;
4624 PyObject * obj1 = 0 ;
4625 char * kwnames[] = {
4626 (char *) "self",(char *) "sz", NULL
4627 };
4628
4629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4631 if (!SWIG_IsOK(res1)) {
4632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4633 }
4634 arg1 = reinterpret_cast< wxSize * >(argp1);
4635 {
4636 arg2 = &temp2;
4637 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4638 }
4639 {
4640 PyThreadState* __tstate = wxPyBeginAllowThreads();
4641 result = (arg1)->operator -((wxSize const &)*arg2);
4642 wxPyEndAllowThreads(__tstate);
4643 if (PyErr_Occurred()) SWIG_fail;
4644 }
4645 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4653 PyObject *resultobj = 0;
4654 wxSize *arg1 = (wxSize *) 0 ;
4655 wxSize *arg2 = 0 ;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 wxSize temp2 ;
4659 PyObject * obj0 = 0 ;
4660 PyObject * obj1 = 0 ;
4661 char * kwnames[] = {
4662 (char *) "self",(char *) "sz", NULL
4663 };
4664
4665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4667 if (!SWIG_IsOK(res1)) {
4668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4669 }
4670 arg1 = reinterpret_cast< wxSize * >(argp1);
4671 {
4672 arg2 = &temp2;
4673 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4674 }
4675 {
4676 PyThreadState* __tstate = wxPyBeginAllowThreads();
4677 (arg1)->IncTo((wxSize const &)*arg2);
4678 wxPyEndAllowThreads(__tstate);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 resultobj = SWIG_Py_Void();
4682 return resultobj;
4683 fail:
4684 return NULL;
4685 }
4686
4687
4688 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4689 PyObject *resultobj = 0;
4690 wxSize *arg1 = (wxSize *) 0 ;
4691 wxSize *arg2 = 0 ;
4692 void *argp1 = 0 ;
4693 int res1 = 0 ;
4694 wxSize temp2 ;
4695 PyObject * obj0 = 0 ;
4696 PyObject * obj1 = 0 ;
4697 char * kwnames[] = {
4698 (char *) "self",(char *) "sz", NULL
4699 };
4700
4701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4703 if (!SWIG_IsOK(res1)) {
4704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4705 }
4706 arg1 = reinterpret_cast< wxSize * >(argp1);
4707 {
4708 arg2 = &temp2;
4709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4710 }
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 (arg1)->DecTo((wxSize const &)*arg2);
4714 wxPyEndAllowThreads(__tstate);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 resultobj = SWIG_Py_Void();
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 int arg2 ;
4728 int arg3 ;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 int val2 ;
4732 int ecode2 = 0 ;
4733 int val3 ;
4734 int ecode3 = 0 ;
4735 PyObject * obj0 = 0 ;
4736 PyObject * obj1 = 0 ;
4737 PyObject * obj2 = 0 ;
4738 char * kwnames[] = {
4739 (char *) "self",(char *) "w",(char *) "h", NULL
4740 };
4741
4742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4744 if (!SWIG_IsOK(res1)) {
4745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4746 }
4747 arg1 = reinterpret_cast< wxSize * >(argp1);
4748 ecode2 = SWIG_AsVal_int(obj1, &val2);
4749 if (!SWIG_IsOK(ecode2)) {
4750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4751 }
4752 arg2 = static_cast< int >(val2);
4753 ecode3 = SWIG_AsVal_int(obj2, &val3);
4754 if (!SWIG_IsOK(ecode3)) {
4755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4756 }
4757 arg3 = static_cast< int >(val3);
4758 {
4759 PyThreadState* __tstate = wxPyBeginAllowThreads();
4760 (arg1)->Set(arg2,arg3);
4761 wxPyEndAllowThreads(__tstate);
4762 if (PyErr_Occurred()) SWIG_fail;
4763 }
4764 resultobj = SWIG_Py_Void();
4765 return resultobj;
4766 fail:
4767 return NULL;
4768 }
4769
4770
4771 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4772 PyObject *resultobj = 0;
4773 wxSize *arg1 = (wxSize *) 0 ;
4774 int arg2 ;
4775 void *argp1 = 0 ;
4776 int res1 = 0 ;
4777 int val2 ;
4778 int ecode2 = 0 ;
4779 PyObject * obj0 = 0 ;
4780 PyObject * obj1 = 0 ;
4781 char * kwnames[] = {
4782 (char *) "self",(char *) "w", NULL
4783 };
4784
4785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4787 if (!SWIG_IsOK(res1)) {
4788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4789 }
4790 arg1 = reinterpret_cast< wxSize * >(argp1);
4791 ecode2 = SWIG_AsVal_int(obj1, &val2);
4792 if (!SWIG_IsOK(ecode2)) {
4793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4794 }
4795 arg2 = static_cast< int >(val2);
4796 {
4797 PyThreadState* __tstate = wxPyBeginAllowThreads();
4798 (arg1)->SetWidth(arg2);
4799 wxPyEndAllowThreads(__tstate);
4800 if (PyErr_Occurred()) SWIG_fail;
4801 }
4802 resultobj = SWIG_Py_Void();
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = 0;
4811 wxSize *arg1 = (wxSize *) 0 ;
4812 int arg2 ;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 int val2 ;
4816 int ecode2 = 0 ;
4817 PyObject * obj0 = 0 ;
4818 PyObject * obj1 = 0 ;
4819 char * kwnames[] = {
4820 (char *) "self",(char *) "h", NULL
4821 };
4822
4823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4827 }
4828 arg1 = reinterpret_cast< wxSize * >(argp1);
4829 ecode2 = SWIG_AsVal_int(obj1, &val2);
4830 if (!SWIG_IsOK(ecode2)) {
4831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4832 }
4833 arg2 = static_cast< int >(val2);
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 (arg1)->SetHeight(arg2);
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 resultobj = SWIG_Py_Void();
4841 return resultobj;
4842 fail:
4843 return NULL;
4844 }
4845
4846
4847 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4848 PyObject *resultobj = 0;
4849 wxSize *arg1 = (wxSize *) 0 ;
4850 int result;
4851 void *argp1 = 0 ;
4852 int res1 = 0 ;
4853 PyObject *swig_obj[1] ;
4854
4855 if (!args) SWIG_fail;
4856 swig_obj[0] = args;
4857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4858 if (!SWIG_IsOK(res1)) {
4859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4860 }
4861 arg1 = reinterpret_cast< wxSize * >(argp1);
4862 {
4863 PyThreadState* __tstate = wxPyBeginAllowThreads();
4864 result = (int)((wxSize const *)arg1)->GetWidth();
4865 wxPyEndAllowThreads(__tstate);
4866 if (PyErr_Occurred()) SWIG_fail;
4867 }
4868 resultobj = SWIG_From_int(static_cast< int >(result));
4869 return resultobj;
4870 fail:
4871 return NULL;
4872 }
4873
4874
4875 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4876 PyObject *resultobj = 0;
4877 wxSize *arg1 = (wxSize *) 0 ;
4878 int result;
4879 void *argp1 = 0 ;
4880 int res1 = 0 ;
4881 PyObject *swig_obj[1] ;
4882
4883 if (!args) SWIG_fail;
4884 swig_obj[0] = args;
4885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4886 if (!SWIG_IsOK(res1)) {
4887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4888 }
4889 arg1 = reinterpret_cast< wxSize * >(argp1);
4890 {
4891 PyThreadState* __tstate = wxPyBeginAllowThreads();
4892 result = (int)((wxSize const *)arg1)->GetHeight();
4893 wxPyEndAllowThreads(__tstate);
4894 if (PyErr_Occurred()) SWIG_fail;
4895 }
4896 resultobj = SWIG_From_int(static_cast< int >(result));
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4904 PyObject *resultobj = 0;
4905 wxSize *arg1 = (wxSize *) 0 ;
4906 bool result;
4907 void *argp1 = 0 ;
4908 int res1 = 0 ;
4909 PyObject *swig_obj[1] ;
4910
4911 if (!args) SWIG_fail;
4912 swig_obj[0] = args;
4913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4914 if (!SWIG_IsOK(res1)) {
4915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
4916 }
4917 arg1 = reinterpret_cast< wxSize * >(argp1);
4918 {
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 {
4925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4926 }
4927 return resultobj;
4928 fail:
4929 return NULL;
4930 }
4931
4932
4933 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4934 PyObject *resultobj = 0;
4935 wxSize *arg1 = (wxSize *) 0 ;
4936 wxSize *arg2 = 0 ;
4937 void *argp1 = 0 ;
4938 int res1 = 0 ;
4939 wxSize temp2 ;
4940 PyObject * obj0 = 0 ;
4941 PyObject * obj1 = 0 ;
4942 char * kwnames[] = {
4943 (char *) "self",(char *) "size", NULL
4944 };
4945
4946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
4947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4948 if (!SWIG_IsOK(res1)) {
4949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
4950 }
4951 arg1 = reinterpret_cast< wxSize * >(argp1);
4952 {
4953 arg2 = &temp2;
4954 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4955 }
4956 {
4957 PyThreadState* __tstate = wxPyBeginAllowThreads();
4958 (arg1)->SetDefaults((wxSize const &)*arg2);
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 resultobj = SWIG_Py_Void();
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4970 PyObject *resultobj = 0;
4971 wxSize *arg1 = (wxSize *) 0 ;
4972 PyObject *result = 0 ;
4973 void *argp1 = 0 ;
4974 int res1 = 0 ;
4975 PyObject *swig_obj[1] ;
4976
4977 if (!args) SWIG_fail;
4978 swig_obj[0] = args;
4979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (PyObject *)wxSize_Get(arg1);
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 resultobj = result;
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4998 PyObject *obj;
4999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5000 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5001 return SWIG_Py_Void();
5002 }
5003
5004 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5005 return SWIG_Python_InitShadowInstance(args);
5006 }
5007
5008 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5009 PyObject *resultobj = 0;
5010 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5011 double arg2 ;
5012 void *argp1 = 0 ;
5013 int res1 = 0 ;
5014 double val2 ;
5015 int ecode2 = 0 ;
5016 PyObject *swig_obj[2] ;
5017
5018 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5020 if (!SWIG_IsOK(res1)) {
5021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5022 }
5023 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5024 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5025 if (!SWIG_IsOK(ecode2)) {
5026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5027 }
5028 arg2 = static_cast< double >(val2);
5029 if (arg1) (arg1)->x = arg2;
5030
5031 resultobj = SWIG_Py_Void();
5032 return resultobj;
5033 fail:
5034 return NULL;
5035 }
5036
5037
5038 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5039 PyObject *resultobj = 0;
5040 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5041 double result;
5042 void *argp1 = 0 ;
5043 int res1 = 0 ;
5044 PyObject *swig_obj[1] ;
5045
5046 if (!args) SWIG_fail;
5047 swig_obj[0] = args;
5048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5049 if (!SWIG_IsOK(res1)) {
5050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5051 }
5052 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5053 result = (double) ((arg1)->x);
5054 resultobj = SWIG_From_double(static_cast< double >(result));
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5062 PyObject *resultobj = 0;
5063 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5064 double arg2 ;
5065 void *argp1 = 0 ;
5066 int res1 = 0 ;
5067 double val2 ;
5068 int ecode2 = 0 ;
5069 PyObject *swig_obj[2] ;
5070
5071 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5073 if (!SWIG_IsOK(res1)) {
5074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5075 }
5076 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5077 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5078 if (!SWIG_IsOK(ecode2)) {
5079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5080 }
5081 arg2 = static_cast< double >(val2);
5082 if (arg1) (arg1)->y = arg2;
5083
5084 resultobj = SWIG_Py_Void();
5085 return resultobj;
5086 fail:
5087 return NULL;
5088 }
5089
5090
5091 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5092 PyObject *resultobj = 0;
5093 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5094 double result;
5095 void *argp1 = 0 ;
5096 int res1 = 0 ;
5097 PyObject *swig_obj[1] ;
5098
5099 if (!args) SWIG_fail;
5100 swig_obj[0] = args;
5101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5102 if (!SWIG_IsOK(res1)) {
5103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5104 }
5105 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5106 result = (double) ((arg1)->y);
5107 resultobj = SWIG_From_double(static_cast< double >(result));
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5115 PyObject *resultobj = 0;
5116 double arg1 = (double) 0.0 ;
5117 double arg2 = (double) 0.0 ;
5118 wxRealPoint *result = 0 ;
5119 double val1 ;
5120 int ecode1 = 0 ;
5121 double val2 ;
5122 int ecode2 = 0 ;
5123 PyObject * obj0 = 0 ;
5124 PyObject * obj1 = 0 ;
5125 char * kwnames[] = {
5126 (char *) "x",(char *) "y", NULL
5127 };
5128
5129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5130 if (obj0) {
5131 ecode1 = SWIG_AsVal_double(obj0, &val1);
5132 if (!SWIG_IsOK(ecode1)) {
5133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5134 }
5135 arg1 = static_cast< double >(val1);
5136 }
5137 if (obj1) {
5138 ecode2 = SWIG_AsVal_double(obj1, &val2);
5139 if (!SWIG_IsOK(ecode2)) {
5140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5141 }
5142 arg2 = static_cast< double >(val2);
5143 }
5144 {
5145 PyThreadState* __tstate = wxPyBeginAllowThreads();
5146 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5147 wxPyEndAllowThreads(__tstate);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5151 return resultobj;
5152 fail:
5153 return NULL;
5154 }
5155
5156
5157 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5158 PyObject *resultobj = 0;
5159 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5160 void *argp1 = 0 ;
5161 int res1 = 0 ;
5162 PyObject *swig_obj[1] ;
5163
5164 if (!args) SWIG_fail;
5165 swig_obj[0] = args;
5166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5167 if (!SWIG_IsOK(res1)) {
5168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5169 }
5170 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5171 {
5172 PyThreadState* __tstate = wxPyBeginAllowThreads();
5173 delete arg1;
5174
5175 wxPyEndAllowThreads(__tstate);
5176 if (PyErr_Occurred()) SWIG_fail;
5177 }
5178 resultobj = SWIG_Py_Void();
5179 return resultobj;
5180 fail:
5181 return NULL;
5182 }
5183
5184
5185 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5186 PyObject *resultobj = 0;
5187 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5188 wxRealPoint *arg2 = 0 ;
5189 bool result;
5190 void *argp1 = 0 ;
5191 int res1 = 0 ;
5192 wxRealPoint temp2 ;
5193 PyObject * obj0 = 0 ;
5194 PyObject * obj1 = 0 ;
5195 char * kwnames[] = {
5196 (char *) "self",(char *) "pt", NULL
5197 };
5198
5199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5201 if (!SWIG_IsOK(res1)) {
5202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5203 }
5204 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5205 {
5206 arg2 = &temp2;
5207 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5208 }
5209 {
5210 PyThreadState* __tstate = wxPyBeginAllowThreads();
5211 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 {
5216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5217 }
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj = 0;
5226 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5227 wxRealPoint *arg2 = 0 ;
5228 bool result;
5229 void *argp1 = 0 ;
5230 int res1 = 0 ;
5231 wxRealPoint temp2 ;
5232 PyObject * obj0 = 0 ;
5233 PyObject * obj1 = 0 ;
5234 char * kwnames[] = {
5235 (char *) "self",(char *) "pt", NULL
5236 };
5237
5238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5240 if (!SWIG_IsOK(res1)) {
5241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5242 }
5243 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5244 {
5245 arg2 = &temp2;
5246 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5247 }
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
5251 wxPyEndAllowThreads(__tstate);
5252 if (PyErr_Occurred()) SWIG_fail;
5253 }
5254 {
5255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5256 }
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj = 0;
5265 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5266 wxRealPoint *arg2 = 0 ;
5267 wxRealPoint result;
5268 void *argp1 = 0 ;
5269 int res1 = 0 ;
5270 wxRealPoint temp2 ;
5271 PyObject * obj0 = 0 ;
5272 PyObject * obj1 = 0 ;
5273 char * kwnames[] = {
5274 (char *) "self",(char *) "pt", NULL
5275 };
5276
5277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5281 }
5282 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5283 {
5284 arg2 = &temp2;
5285 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5286 }
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = 0;
5302 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5303 wxRealPoint *arg2 = 0 ;
5304 wxRealPoint result;
5305 void *argp1 = 0 ;
5306 int res1 = 0 ;
5307 wxRealPoint temp2 ;
5308 PyObject * obj0 = 0 ;
5309 PyObject * obj1 = 0 ;
5310 char * kwnames[] = {
5311 (char *) "self",(char *) "pt", NULL
5312 };
5313
5314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5316 if (!SWIG_IsOK(res1)) {
5317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5318 }
5319 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5320 {
5321 arg2 = &temp2;
5322 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5323 }
5324 {
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5338 PyObject *resultobj = 0;
5339 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5340 double arg2 ;
5341 double arg3 ;
5342 void *argp1 = 0 ;
5343 int res1 = 0 ;
5344 double val2 ;
5345 int ecode2 = 0 ;
5346 double val3 ;
5347 int ecode3 = 0 ;
5348 PyObject * obj0 = 0 ;
5349 PyObject * obj1 = 0 ;
5350 PyObject * obj2 = 0 ;
5351 char * kwnames[] = {
5352 (char *) "self",(char *) "x",(char *) "y", NULL
5353 };
5354
5355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5357 if (!SWIG_IsOK(res1)) {
5358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5359 }
5360 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5361 ecode2 = SWIG_AsVal_double(obj1, &val2);
5362 if (!SWIG_IsOK(ecode2)) {
5363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5364 }
5365 arg2 = static_cast< double >(val2);
5366 ecode3 = SWIG_AsVal_double(obj2, &val3);
5367 if (!SWIG_IsOK(ecode3)) {
5368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5369 }
5370 arg3 = static_cast< double >(val3);
5371 {
5372 PyThreadState* __tstate = wxPyBeginAllowThreads();
5373 wxRealPoint_Set(arg1,arg2,arg3);
5374 wxPyEndAllowThreads(__tstate);
5375 if (PyErr_Occurred()) SWIG_fail;
5376 }
5377 resultobj = SWIG_Py_Void();
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5387 PyObject *result = 0 ;
5388 void *argp1 = 0 ;
5389 int res1 = 0 ;
5390 PyObject *swig_obj[1] ;
5391
5392 if (!args) SWIG_fail;
5393 swig_obj[0] = args;
5394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5395 if (!SWIG_IsOK(res1)) {
5396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5397 }
5398 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5399 {
5400 PyThreadState* __tstate = wxPyBeginAllowThreads();
5401 result = (PyObject *)wxRealPoint_Get(arg1);
5402 wxPyEndAllowThreads(__tstate);
5403 if (PyErr_Occurred()) SWIG_fail;
5404 }
5405 resultobj = result;
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5413 PyObject *obj;
5414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5415 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5416 return SWIG_Py_Void();
5417 }
5418
5419 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5420 return SWIG_Python_InitShadowInstance(args);
5421 }
5422
5423 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424 PyObject *resultobj = 0;
5425 wxPoint *arg1 = (wxPoint *) 0 ;
5426 int arg2 ;
5427 void *argp1 = 0 ;
5428 int res1 = 0 ;
5429 int val2 ;
5430 int ecode2 = 0 ;
5431 PyObject *swig_obj[2] ;
5432
5433 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5435 if (!SWIG_IsOK(res1)) {
5436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5437 }
5438 arg1 = reinterpret_cast< wxPoint * >(argp1);
5439 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5440 if (!SWIG_IsOK(ecode2)) {
5441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5442 }
5443 arg2 = static_cast< int >(val2);
5444 if (arg1) (arg1)->x = arg2;
5445
5446 resultobj = SWIG_Py_Void();
5447 return resultobj;
5448 fail:
5449 return NULL;
5450 }
5451
5452
5453 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5454 PyObject *resultobj = 0;
5455 wxPoint *arg1 = (wxPoint *) 0 ;
5456 int result;
5457 void *argp1 = 0 ;
5458 int res1 = 0 ;
5459 PyObject *swig_obj[1] ;
5460
5461 if (!args) SWIG_fail;
5462 swig_obj[0] = args;
5463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5464 if (!SWIG_IsOK(res1)) {
5465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5466 }
5467 arg1 = reinterpret_cast< wxPoint * >(argp1);
5468 result = (int) ((arg1)->x);
5469 resultobj = SWIG_From_int(static_cast< int >(result));
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxPoint *arg1 = (wxPoint *) 0 ;
5479 int arg2 ;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 int val2 ;
5483 int ecode2 = 0 ;
5484 PyObject *swig_obj[2] ;
5485
5486 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5488 if (!SWIG_IsOK(res1)) {
5489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5490 }
5491 arg1 = reinterpret_cast< wxPoint * >(argp1);
5492 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5493 if (!SWIG_IsOK(ecode2)) {
5494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5495 }
5496 arg2 = static_cast< int >(val2);
5497 if (arg1) (arg1)->y = arg2;
5498
5499 resultobj = SWIG_Py_Void();
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 PyObject *resultobj = 0;
5508 wxPoint *arg1 = (wxPoint *) 0 ;
5509 int result;
5510 void *argp1 = 0 ;
5511 int res1 = 0 ;
5512 PyObject *swig_obj[1] ;
5513
5514 if (!args) SWIG_fail;
5515 swig_obj[0] = args;
5516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5517 if (!SWIG_IsOK(res1)) {
5518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5519 }
5520 arg1 = reinterpret_cast< wxPoint * >(argp1);
5521 result = (int) ((arg1)->y);
5522 resultobj = SWIG_From_int(static_cast< int >(result));
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5530 PyObject *resultobj = 0;
5531 int arg1 = (int) 0 ;
5532 int arg2 = (int) 0 ;
5533 wxPoint *result = 0 ;
5534 int val1 ;
5535 int ecode1 = 0 ;
5536 int val2 ;
5537 int ecode2 = 0 ;
5538 PyObject * obj0 = 0 ;
5539 PyObject * obj1 = 0 ;
5540 char * kwnames[] = {
5541 (char *) "x",(char *) "y", NULL
5542 };
5543
5544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5545 if (obj0) {
5546 ecode1 = SWIG_AsVal_int(obj0, &val1);
5547 if (!SWIG_IsOK(ecode1)) {
5548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5549 }
5550 arg1 = static_cast< int >(val1);
5551 }
5552 if (obj1) {
5553 ecode2 = SWIG_AsVal_int(obj1, &val2);
5554 if (!SWIG_IsOK(ecode2)) {
5555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5556 }
5557 arg2 = static_cast< int >(val2);
5558 }
5559 {
5560 PyThreadState* __tstate = wxPyBeginAllowThreads();
5561 result = (wxPoint *)new wxPoint(arg1,arg2);
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5573 PyObject *resultobj = 0;
5574 wxPoint *arg1 = (wxPoint *) 0 ;
5575 void *argp1 = 0 ;
5576 int res1 = 0 ;
5577 PyObject *swig_obj[1] ;
5578
5579 if (!args) SWIG_fail;
5580 swig_obj[0] = args;
5581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5582 if (!SWIG_IsOK(res1)) {
5583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5584 }
5585 arg1 = reinterpret_cast< wxPoint * >(argp1);
5586 {
5587 PyThreadState* __tstate = wxPyBeginAllowThreads();
5588 delete arg1;
5589
5590 wxPyEndAllowThreads(__tstate);
5591 if (PyErr_Occurred()) SWIG_fail;
5592 }
5593 resultobj = SWIG_Py_Void();
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj = 0;
5602 wxPoint *arg1 = (wxPoint *) 0 ;
5603 wxPoint *arg2 = 0 ;
5604 bool result;
5605 void *argp1 = 0 ;
5606 int res1 = 0 ;
5607 wxPoint temp2 ;
5608 PyObject * obj0 = 0 ;
5609 PyObject * obj1 = 0 ;
5610 char * kwnames[] = {
5611 (char *) "self",(char *) "pt", NULL
5612 };
5613
5614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 {
5621 arg2 = &temp2;
5622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5623 }
5624 {
5625 PyThreadState* __tstate = wxPyBeginAllowThreads();
5626 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
5627 wxPyEndAllowThreads(__tstate);
5628 if (PyErr_Occurred()) SWIG_fail;
5629 }
5630 {
5631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5632 }
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj = 0;
5641 wxPoint *arg1 = (wxPoint *) 0 ;
5642 wxPoint *arg2 = 0 ;
5643 bool result;
5644 void *argp1 = 0 ;
5645 int res1 = 0 ;
5646 wxPoint temp2 ;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 char * kwnames[] = {
5650 (char *) "self",(char *) "pt", NULL
5651 };
5652
5653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5655 if (!SWIG_IsOK(res1)) {
5656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5657 }
5658 arg1 = reinterpret_cast< wxPoint * >(argp1);
5659 {
5660 arg2 = &temp2;
5661 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 {
5670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5671 }
5672 return resultobj;
5673 fail:
5674 return NULL;
5675 }
5676
5677
5678 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5679 PyObject *resultobj = 0;
5680 wxPoint *arg1 = (wxPoint *) 0 ;
5681 wxPoint *arg2 = 0 ;
5682 wxPoint result;
5683 void *argp1 = 0 ;
5684 int res1 = 0 ;
5685 wxPoint temp2 ;
5686 PyObject * obj0 = 0 ;
5687 PyObject * obj1 = 0 ;
5688 char * kwnames[] = {
5689 (char *) "self",(char *) "pt", NULL
5690 };
5691
5692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5694 if (!SWIG_IsOK(res1)) {
5695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5696 }
5697 arg1 = reinterpret_cast< wxPoint * >(argp1);
5698 {
5699 arg2 = &temp2;
5700 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5701 }
5702 {
5703 PyThreadState* __tstate = wxPyBeginAllowThreads();
5704 result = (arg1)->operator +((wxPoint const &)*arg2);
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5709 return resultobj;
5710 fail:
5711 return NULL;
5712 }
5713
5714
5715 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj = 0;
5717 wxPoint *arg1 = (wxPoint *) 0 ;
5718 wxPoint *arg2 = 0 ;
5719 wxPoint result;
5720 void *argp1 = 0 ;
5721 int res1 = 0 ;
5722 wxPoint temp2 ;
5723 PyObject * obj0 = 0 ;
5724 PyObject * obj1 = 0 ;
5725 char * kwnames[] = {
5726 (char *) "self",(char *) "pt", NULL
5727 };
5728
5729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5731 if (!SWIG_IsOK(res1)) {
5732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5733 }
5734 arg1 = reinterpret_cast< wxPoint * >(argp1);
5735 {
5736 arg2 = &temp2;
5737 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5738 }
5739 {
5740 PyThreadState* __tstate = wxPyBeginAllowThreads();
5741 result = (arg1)->operator -((wxPoint const &)*arg2);
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 wxPoint *arg2 = 0 ;
5756 wxPoint *result = 0 ;
5757 void *argp1 = 0 ;
5758 int res1 = 0 ;
5759 wxPoint temp2 ;
5760 PyObject * obj0 = 0 ;
5761 PyObject * obj1 = 0 ;
5762 char * kwnames[] = {
5763 (char *) "self",(char *) "pt", NULL
5764 };
5765
5766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5768 if (!SWIG_IsOK(res1)) {
5769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5770 }
5771 arg1 = reinterpret_cast< wxPoint * >(argp1);
5772 {
5773 arg2 = &temp2;
5774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5775 }
5776 {
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 {
5779 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5780 result = (wxPoint *) &_result_ref;
5781 }
5782 wxPyEndAllowThreads(__tstate);
5783 if (PyErr_Occurred()) SWIG_fail;
5784 }
5785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5793 PyObject *resultobj = 0;
5794 wxPoint *arg1 = (wxPoint *) 0 ;
5795 wxPoint *arg2 = 0 ;
5796 wxPoint *result = 0 ;
5797 void *argp1 = 0 ;
5798 int res1 = 0 ;
5799 wxPoint temp2 ;
5800 PyObject * obj0 = 0 ;
5801 PyObject * obj1 = 0 ;
5802 char * kwnames[] = {
5803 (char *) "self",(char *) "pt", NULL
5804 };
5805
5806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5808 if (!SWIG_IsOK(res1)) {
5809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5810 }
5811 arg1 = reinterpret_cast< wxPoint * >(argp1);
5812 {
5813 arg2 = &temp2;
5814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5815 }
5816 {
5817 PyThreadState* __tstate = wxPyBeginAllowThreads();
5818 {
5819 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5820 result = (wxPoint *) &_result_ref;
5821 }
5822 wxPyEndAllowThreads(__tstate);
5823 if (PyErr_Occurred()) SWIG_fail;
5824 }
5825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj = 0;
5834 wxPoint *arg1 = (wxPoint *) 0 ;
5835 long arg2 ;
5836 long arg3 ;
5837 void *argp1 = 0 ;
5838 int res1 = 0 ;
5839 long val2 ;
5840 int ecode2 = 0 ;
5841 long val3 ;
5842 int ecode3 = 0 ;
5843 PyObject * obj0 = 0 ;
5844 PyObject * obj1 = 0 ;
5845 PyObject * obj2 = 0 ;
5846 char * kwnames[] = {
5847 (char *) "self",(char *) "x",(char *) "y", NULL
5848 };
5849
5850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5852 if (!SWIG_IsOK(res1)) {
5853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5854 }
5855 arg1 = reinterpret_cast< wxPoint * >(argp1);
5856 ecode2 = SWIG_AsVal_long(obj1, &val2);
5857 if (!SWIG_IsOK(ecode2)) {
5858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5859 }
5860 arg2 = static_cast< long >(val2);
5861 ecode3 = SWIG_AsVal_long(obj2, &val3);
5862 if (!SWIG_IsOK(ecode3)) {
5863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5864 }
5865 arg3 = static_cast< long >(val3);
5866 {
5867 PyThreadState* __tstate = wxPyBeginAllowThreads();
5868 wxPoint_Set(arg1,arg2,arg3);
5869 wxPyEndAllowThreads(__tstate);
5870 if (PyErr_Occurred()) SWIG_fail;
5871 }
5872 resultobj = SWIG_Py_Void();
5873 return resultobj;
5874 fail:
5875 return NULL;
5876 }
5877
5878
5879 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5880 PyObject *resultobj = 0;
5881 wxPoint *arg1 = (wxPoint *) 0 ;
5882 PyObject *result = 0 ;
5883 void *argp1 = 0 ;
5884 int res1 = 0 ;
5885 PyObject *swig_obj[1] ;
5886
5887 if (!args) SWIG_fail;
5888 swig_obj[0] = args;
5889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5890 if (!SWIG_IsOK(res1)) {
5891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5892 }
5893 arg1 = reinterpret_cast< wxPoint * >(argp1);
5894 {
5895 PyThreadState* __tstate = wxPyBeginAllowThreads();
5896 result = (PyObject *)wxPoint_Get(arg1);
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 resultobj = result;
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5908 PyObject *obj;
5909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5910 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5911 return SWIG_Py_Void();
5912 }
5913
5914 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5915 return SWIG_Python_InitShadowInstance(args);
5916 }
5917
5918 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5919 PyObject *resultobj = 0;
5920 int arg1 = (int) 0 ;
5921 int arg2 = (int) 0 ;
5922 int arg3 = (int) 0 ;
5923 int arg4 = (int) 0 ;
5924 wxRect *result = 0 ;
5925 int val1 ;
5926 int ecode1 = 0 ;
5927 int val2 ;
5928 int ecode2 = 0 ;
5929 int val3 ;
5930 int ecode3 = 0 ;
5931 int val4 ;
5932 int ecode4 = 0 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 PyObject * obj2 = 0 ;
5936 PyObject * obj3 = 0 ;
5937 char * kwnames[] = {
5938 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
5939 };
5940
5941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5942 if (obj0) {
5943 ecode1 = SWIG_AsVal_int(obj0, &val1);
5944 if (!SWIG_IsOK(ecode1)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
5946 }
5947 arg1 = static_cast< int >(val1);
5948 }
5949 if (obj1) {
5950 ecode2 = SWIG_AsVal_int(obj1, &val2);
5951 if (!SWIG_IsOK(ecode2)) {
5952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
5953 }
5954 arg2 = static_cast< int >(val2);
5955 }
5956 if (obj2) {
5957 ecode3 = SWIG_AsVal_int(obj2, &val3);
5958 if (!SWIG_IsOK(ecode3)) {
5959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
5960 }
5961 arg3 = static_cast< int >(val3);
5962 }
5963 if (obj3) {
5964 ecode4 = SWIG_AsVal_int(obj3, &val4);
5965 if (!SWIG_IsOK(ecode4)) {
5966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
5967 }
5968 arg4 = static_cast< int >(val4);
5969 }
5970 {
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
5977 return resultobj;
5978 fail:
5979 return NULL;
5980 }
5981
5982
5983 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5984 PyObject *resultobj = 0;
5985 wxPoint *arg1 = 0 ;
5986 wxPoint *arg2 = 0 ;
5987 wxRect *result = 0 ;
5988 wxPoint temp1 ;
5989 wxPoint temp2 ;
5990 PyObject * obj0 = 0 ;
5991 PyObject * obj1 = 0 ;
5992 char * kwnames[] = {
5993 (char *) "topLeft",(char *) "bottomRight", NULL
5994 };
5995
5996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
5997 {
5998 arg1 = &temp1;
5999 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6000 }
6001 {
6002 arg2 = &temp2;
6003 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6004 }
6005 {
6006 PyThreadState* __tstate = wxPyBeginAllowThreads();
6007 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6008 wxPyEndAllowThreads(__tstate);
6009 if (PyErr_Occurred()) SWIG_fail;
6010 }
6011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6012 return resultobj;
6013 fail:
6014 return NULL;
6015 }
6016
6017
6018 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6019 PyObject *resultobj = 0;
6020 wxPoint *arg1 = 0 ;
6021 wxSize *arg2 = 0 ;
6022 wxRect *result = 0 ;
6023 wxPoint temp1 ;
6024 wxSize temp2 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 char * kwnames[] = {
6028 (char *) "pos",(char *) "size", NULL
6029 };
6030
6031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6032 {
6033 arg1 = &temp1;
6034 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6035 }
6036 {
6037 arg2 = &temp2;
6038 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6039 }
6040 {
6041 PyThreadState* __tstate = wxPyBeginAllowThreads();
6042 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6043 wxPyEndAllowThreads(__tstate);
6044 if (PyErr_Occurred()) SWIG_fail;
6045 }
6046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6047 return resultobj;
6048 fail:
6049 return NULL;
6050 }
6051
6052
6053 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6054 PyObject *resultobj = 0;
6055 wxSize *arg1 = 0 ;
6056 wxRect *result = 0 ;
6057 wxSize temp1 ;
6058 PyObject * obj0 = 0 ;
6059 char * kwnames[] = {
6060 (char *) "size", NULL
6061 };
6062
6063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6064 {
6065 arg1 = &temp1;
6066 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6067 }
6068 {
6069 PyThreadState* __tstate = wxPyBeginAllowThreads();
6070 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6082 PyObject *resultobj = 0;
6083 wxRect *arg1 = (wxRect *) 0 ;
6084 void *argp1 = 0 ;
6085 int res1 = 0 ;
6086 PyObject *swig_obj[1] ;
6087
6088 if (!args) SWIG_fail;
6089 swig_obj[0] = args;
6090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6091 if (!SWIG_IsOK(res1)) {
6092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6093 }
6094 arg1 = reinterpret_cast< wxRect * >(argp1);
6095 {
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 delete arg1;
6098
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_Py_Void();
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6110 PyObject *resultobj = 0;
6111 wxRect *arg1 = (wxRect *) 0 ;
6112 int result;
6113 void *argp1 = 0 ;
6114 int res1 = 0 ;
6115 PyObject *swig_obj[1] ;
6116
6117 if (!args) SWIG_fail;
6118 swig_obj[0] = args;
6119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6120 if (!SWIG_IsOK(res1)) {
6121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6122 }
6123 arg1 = reinterpret_cast< wxRect * >(argp1);
6124 {
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (int)((wxRect const *)arg1)->GetX();
6127 wxPyEndAllowThreads(__tstate);
6128 if (PyErr_Occurred()) SWIG_fail;
6129 }
6130 resultobj = SWIG_From_int(static_cast< int >(result));
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj = 0;
6139 wxRect *arg1 = (wxRect *) 0 ;
6140 int arg2 ;
6141 void *argp1 = 0 ;
6142 int res1 = 0 ;
6143 int val2 ;
6144 int ecode2 = 0 ;
6145 PyObject * obj0 = 0 ;
6146 PyObject * obj1 = 0 ;
6147 char * kwnames[] = {
6148 (char *) "self",(char *) "x", NULL
6149 };
6150
6151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6153 if (!SWIG_IsOK(res1)) {
6154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6155 }
6156 arg1 = reinterpret_cast< wxRect * >(argp1);
6157 ecode2 = SWIG_AsVal_int(obj1, &val2);
6158 if (!SWIG_IsOK(ecode2)) {
6159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6160 }
6161 arg2 = static_cast< int >(val2);
6162 {
6163 PyThreadState* __tstate = wxPyBeginAllowThreads();
6164 (arg1)->SetX(arg2);
6165 wxPyEndAllowThreads(__tstate);
6166 if (PyErr_Occurred()) SWIG_fail;
6167 }
6168 resultobj = SWIG_Py_Void();
6169 return resultobj;
6170 fail:
6171 return NULL;
6172 }
6173
6174
6175 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6176 PyObject *resultobj = 0;
6177 wxRect *arg1 = (wxRect *) 0 ;
6178 int result;
6179 void *argp1 = 0 ;
6180 int res1 = 0 ;
6181 PyObject *swig_obj[1] ;
6182
6183 if (!args) SWIG_fail;
6184 swig_obj[0] = args;
6185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6186 if (!SWIG_IsOK(res1)) {
6187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6188 }
6189 arg1 = reinterpret_cast< wxRect * >(argp1);
6190 {
6191 PyThreadState* __tstate = wxPyBeginAllowThreads();
6192 result = (int)(arg1)->GetY();
6193 wxPyEndAllowThreads(__tstate);
6194 if (PyErr_Occurred()) SWIG_fail;
6195 }
6196 resultobj = SWIG_From_int(static_cast< int >(result));
6197 return resultobj;
6198 fail:
6199 return NULL;
6200 }
6201
6202
6203 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj = 0;
6205 wxRect *arg1 = (wxRect *) 0 ;
6206 int arg2 ;
6207 void *argp1 = 0 ;
6208 int res1 = 0 ;
6209 int val2 ;
6210 int ecode2 = 0 ;
6211 PyObject * obj0 = 0 ;
6212 PyObject * obj1 = 0 ;
6213 char * kwnames[] = {
6214 (char *) "self",(char *) "y", NULL
6215 };
6216
6217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6219 if (!SWIG_IsOK(res1)) {
6220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6221 }
6222 arg1 = reinterpret_cast< wxRect * >(argp1);
6223 ecode2 = SWIG_AsVal_int(obj1, &val2);
6224 if (!SWIG_IsOK(ecode2)) {
6225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6226 }
6227 arg2 = static_cast< int >(val2);
6228 {
6229 PyThreadState* __tstate = wxPyBeginAllowThreads();
6230 (arg1)->SetY(arg2);
6231 wxPyEndAllowThreads(__tstate);
6232 if (PyErr_Occurred()) SWIG_fail;
6233 }
6234 resultobj = SWIG_Py_Void();
6235 return resultobj;
6236 fail:
6237 return NULL;
6238 }
6239
6240
6241 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6242 PyObject *resultobj = 0;
6243 wxRect *arg1 = (wxRect *) 0 ;
6244 int result;
6245 void *argp1 = 0 ;
6246 int res1 = 0 ;
6247 PyObject *swig_obj[1] ;
6248
6249 if (!args) SWIG_fail;
6250 swig_obj[0] = args;
6251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6252 if (!SWIG_IsOK(res1)) {
6253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6254 }
6255 arg1 = reinterpret_cast< wxRect * >(argp1);
6256 {
6257 PyThreadState* __tstate = wxPyBeginAllowThreads();
6258 result = (int)((wxRect const *)arg1)->GetWidth();
6259 wxPyEndAllowThreads(__tstate);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 resultobj = SWIG_From_int(static_cast< int >(result));
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = 0;
6271 wxRect *arg1 = (wxRect *) 0 ;
6272 int arg2 ;
6273 void *argp1 = 0 ;
6274 int res1 = 0 ;
6275 int val2 ;
6276 int ecode2 = 0 ;
6277 PyObject * obj0 = 0 ;
6278 PyObject * obj1 = 0 ;
6279 char * kwnames[] = {
6280 (char *) "self",(char *) "w", NULL
6281 };
6282
6283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6285 if (!SWIG_IsOK(res1)) {
6286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6287 }
6288 arg1 = reinterpret_cast< wxRect * >(argp1);
6289 ecode2 = SWIG_AsVal_int(obj1, &val2);
6290 if (!SWIG_IsOK(ecode2)) {
6291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6292 }
6293 arg2 = static_cast< int >(val2);
6294 {
6295 PyThreadState* __tstate = wxPyBeginAllowThreads();
6296 (arg1)->SetWidth(arg2);
6297 wxPyEndAllowThreads(__tstate);
6298 if (PyErr_Occurred()) SWIG_fail;
6299 }
6300 resultobj = SWIG_Py_Void();
6301 return resultobj;
6302 fail:
6303 return NULL;
6304 }
6305
6306
6307 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6308 PyObject *resultobj = 0;
6309 wxRect *arg1 = (wxRect *) 0 ;
6310 int result;
6311 void *argp1 = 0 ;
6312 int res1 = 0 ;
6313 PyObject *swig_obj[1] ;
6314
6315 if (!args) SWIG_fail;
6316 swig_obj[0] = args;
6317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6318 if (!SWIG_IsOK(res1)) {
6319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6320 }
6321 arg1 = reinterpret_cast< wxRect * >(argp1);
6322 {
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 result = (int)((wxRect const *)arg1)->GetHeight();
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 resultobj = SWIG_From_int(static_cast< int >(result));
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6336 PyObject *resultobj = 0;
6337 wxRect *arg1 = (wxRect *) 0 ;
6338 int arg2 ;
6339 void *argp1 = 0 ;
6340 int res1 = 0 ;
6341 int val2 ;
6342 int ecode2 = 0 ;
6343 PyObject * obj0 = 0 ;
6344 PyObject * obj1 = 0 ;
6345 char * kwnames[] = {
6346 (char *) "self",(char *) "h", NULL
6347 };
6348
6349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6351 if (!SWIG_IsOK(res1)) {
6352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6353 }
6354 arg1 = reinterpret_cast< wxRect * >(argp1);
6355 ecode2 = SWIG_AsVal_int(obj1, &val2);
6356 if (!SWIG_IsOK(ecode2)) {
6357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6358 }
6359 arg2 = static_cast< int >(val2);
6360 {
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 (arg1)->SetHeight(arg2);
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 resultobj = SWIG_Py_Void();
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6374 PyObject *resultobj = 0;
6375 wxRect *arg1 = (wxRect *) 0 ;
6376 wxPoint result;
6377 void *argp1 = 0 ;
6378 int res1 = 0 ;
6379 PyObject *swig_obj[1] ;
6380
6381 if (!args) SWIG_fail;
6382 swig_obj[0] = args;
6383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6384 if (!SWIG_IsOK(res1)) {
6385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6386 }
6387 arg1 = reinterpret_cast< wxRect * >(argp1);
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 result = ((wxRect const *)arg1)->GetPosition();
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj = 0;
6403 wxRect *arg1 = (wxRect *) 0 ;
6404 wxPoint *arg2 = 0 ;
6405 void *argp1 = 0 ;
6406 int res1 = 0 ;
6407 wxPoint temp2 ;
6408 PyObject * obj0 = 0 ;
6409 PyObject * obj1 = 0 ;
6410 char * kwnames[] = {
6411 (char *) "self",(char *) "p", NULL
6412 };
6413
6414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6416 if (!SWIG_IsOK(res1)) {
6417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6418 }
6419 arg1 = reinterpret_cast< wxRect * >(argp1);
6420 {
6421 arg2 = &temp2;
6422 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6423 }
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 (arg1)->SetPosition((wxPoint const &)*arg2);
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_Py_Void();
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6438 PyObject *resultobj = 0;
6439 wxRect *arg1 = (wxRect *) 0 ;
6440 wxSize result;
6441 void *argp1 = 0 ;
6442 int res1 = 0 ;
6443 PyObject *swig_obj[1] ;
6444
6445 if (!args) SWIG_fail;
6446 swig_obj[0] = args;
6447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6448 if (!SWIG_IsOK(res1)) {
6449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6450 }
6451 arg1 = reinterpret_cast< wxRect * >(argp1);
6452 {
6453 PyThreadState* __tstate = wxPyBeginAllowThreads();
6454 result = ((wxRect const *)arg1)->GetSize();
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj = 0;
6467 wxRect *arg1 = (wxRect *) 0 ;
6468 wxSize *arg2 = 0 ;
6469 void *argp1 = 0 ;
6470 int res1 = 0 ;
6471 wxSize temp2 ;
6472 PyObject * obj0 = 0 ;
6473 PyObject * obj1 = 0 ;
6474 char * kwnames[] = {
6475 (char *) "self",(char *) "s", NULL
6476 };
6477
6478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6480 if (!SWIG_IsOK(res1)) {
6481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6482 }
6483 arg1 = reinterpret_cast< wxRect * >(argp1);
6484 {
6485 arg2 = &temp2;
6486 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6487 }
6488 {
6489 PyThreadState* __tstate = wxPyBeginAllowThreads();
6490 (arg1)->SetSize((wxSize const &)*arg2);
6491 wxPyEndAllowThreads(__tstate);
6492 if (PyErr_Occurred()) SWIG_fail;
6493 }
6494 resultobj = SWIG_Py_Void();
6495 return resultobj;
6496 fail:
6497 return NULL;
6498 }
6499
6500
6501 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6502 PyObject *resultobj = 0;
6503 wxRect *arg1 = (wxRect *) 0 ;
6504 bool result;
6505 void *argp1 = 0 ;
6506 int res1 = 0 ;
6507 PyObject *swig_obj[1] ;
6508
6509 if (!args) SWIG_fail;
6510 swig_obj[0] = args;
6511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6512 if (!SWIG_IsOK(res1)) {
6513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6514 }
6515 arg1 = reinterpret_cast< wxRect * >(argp1);
6516 {
6517 PyThreadState* __tstate = wxPyBeginAllowThreads();
6518 result = (bool)((wxRect const *)arg1)->IsEmpty();
6519 wxPyEndAllowThreads(__tstate);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 {
6523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6524 }
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6532 PyObject *resultobj = 0;
6533 wxRect *arg1 = (wxRect *) 0 ;
6534 wxPoint result;
6535 void *argp1 = 0 ;
6536 int res1 = 0 ;
6537 PyObject *swig_obj[1] ;
6538
6539 if (!args) SWIG_fail;
6540 swig_obj[0] = args;
6541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6542 if (!SWIG_IsOK(res1)) {
6543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6544 }
6545 arg1 = reinterpret_cast< wxRect * >(argp1);
6546 {
6547 PyThreadState* __tstate = wxPyBeginAllowThreads();
6548 result = ((wxRect const *)arg1)->GetTopLeft();
6549 wxPyEndAllowThreads(__tstate);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6553 return resultobj;
6554 fail:
6555 return NULL;
6556 }
6557
6558
6559 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6560 PyObject *resultobj = 0;
6561 wxRect *arg1 = (wxRect *) 0 ;
6562 wxPoint *arg2 = 0 ;
6563 void *argp1 = 0 ;
6564 int res1 = 0 ;
6565 wxPoint temp2 ;
6566 PyObject * obj0 = 0 ;
6567 PyObject * obj1 = 0 ;
6568 char * kwnames[] = {
6569 (char *) "self",(char *) "p", NULL
6570 };
6571
6572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6574 if (!SWIG_IsOK(res1)) {
6575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6576 }
6577 arg1 = reinterpret_cast< wxRect * >(argp1);
6578 {
6579 arg2 = &temp2;
6580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6581 }
6582 {
6583 PyThreadState* __tstate = wxPyBeginAllowThreads();
6584 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6585 wxPyEndAllowThreads(__tstate);
6586 if (PyErr_Occurred()) SWIG_fail;
6587 }
6588 resultobj = SWIG_Py_Void();
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6596 PyObject *resultobj = 0;
6597 wxRect *arg1 = (wxRect *) 0 ;
6598 wxPoint result;
6599 void *argp1 = 0 ;
6600 int res1 = 0 ;
6601 PyObject *swig_obj[1] ;
6602
6603 if (!args) SWIG_fail;
6604 swig_obj[0] = args;
6605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6606 if (!SWIG_IsOK(res1)) {
6607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6608 }
6609 arg1 = reinterpret_cast< wxRect * >(argp1);
6610 {
6611 PyThreadState* __tstate = wxPyBeginAllowThreads();
6612 result = ((wxRect const *)arg1)->GetBottomRight();
6613 wxPyEndAllowThreads(__tstate);
6614 if (PyErr_Occurred()) SWIG_fail;
6615 }
6616 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6624 PyObject *resultobj = 0;
6625 wxRect *arg1 = (wxRect *) 0 ;
6626 wxPoint *arg2 = 0 ;
6627 void *argp1 = 0 ;
6628 int res1 = 0 ;
6629 wxPoint temp2 ;
6630 PyObject * obj0 = 0 ;
6631 PyObject * obj1 = 0 ;
6632 char * kwnames[] = {
6633 (char *) "self",(char *) "p", NULL
6634 };
6635
6636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6638 if (!SWIG_IsOK(res1)) {
6639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6640 }
6641 arg1 = reinterpret_cast< wxRect * >(argp1);
6642 {
6643 arg2 = &temp2;
6644 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6645 }
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 resultobj = SWIG_Py_Void();
6653 return resultobj;
6654 fail:
6655 return NULL;
6656 }
6657
6658
6659 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6660 PyObject *resultobj = 0;
6661 wxRect *arg1 = (wxRect *) 0 ;
6662 int result;
6663 void *argp1 = 0 ;
6664 int res1 = 0 ;
6665 PyObject *swig_obj[1] ;
6666
6667 if (!args) SWIG_fail;
6668 swig_obj[0] = args;
6669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6670 if (!SWIG_IsOK(res1)) {
6671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6672 }
6673 arg1 = reinterpret_cast< wxRect * >(argp1);
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 result = (int)((wxRect const *)arg1)->GetLeft();
6677 wxPyEndAllowThreads(__tstate);
6678 if (PyErr_Occurred()) SWIG_fail;
6679 }
6680 resultobj = SWIG_From_int(static_cast< int >(result));
6681 return resultobj;
6682 fail:
6683 return NULL;
6684 }
6685
6686
6687 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6688 PyObject *resultobj = 0;
6689 wxRect *arg1 = (wxRect *) 0 ;
6690 int result;
6691 void *argp1 = 0 ;
6692 int res1 = 0 ;
6693 PyObject *swig_obj[1] ;
6694
6695 if (!args) SWIG_fail;
6696 swig_obj[0] = args;
6697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6698 if (!SWIG_IsOK(res1)) {
6699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6700 }
6701 arg1 = reinterpret_cast< wxRect * >(argp1);
6702 {
6703 PyThreadState* __tstate = wxPyBeginAllowThreads();
6704 result = (int)((wxRect const *)arg1)->GetTop();
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 resultobj = SWIG_From_int(static_cast< int >(result));
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6716 PyObject *resultobj = 0;
6717 wxRect *arg1 = (wxRect *) 0 ;
6718 int result;
6719 void *argp1 = 0 ;
6720 int res1 = 0 ;
6721 PyObject *swig_obj[1] ;
6722
6723 if (!args) SWIG_fail;
6724 swig_obj[0] = args;
6725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6726 if (!SWIG_IsOK(res1)) {
6727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6728 }
6729 arg1 = reinterpret_cast< wxRect * >(argp1);
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 result = (int)((wxRect const *)arg1)->GetBottom();
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 resultobj = SWIG_From_int(static_cast< int >(result));
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6744 PyObject *resultobj = 0;
6745 wxRect *arg1 = (wxRect *) 0 ;
6746 int result;
6747 void *argp1 = 0 ;
6748 int res1 = 0 ;
6749 PyObject *swig_obj[1] ;
6750
6751 if (!args) SWIG_fail;
6752 swig_obj[0] = args;
6753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6754 if (!SWIG_IsOK(res1)) {
6755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6756 }
6757 arg1 = reinterpret_cast< wxRect * >(argp1);
6758 {
6759 PyThreadState* __tstate = wxPyBeginAllowThreads();
6760 result = (int)((wxRect const *)arg1)->GetRight();
6761 wxPyEndAllowThreads(__tstate);
6762 if (PyErr_Occurred()) SWIG_fail;
6763 }
6764 resultobj = SWIG_From_int(static_cast< int >(result));
6765 return resultobj;
6766 fail:
6767 return NULL;
6768 }
6769
6770
6771 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6772 PyObject *resultobj = 0;
6773 wxRect *arg1 = (wxRect *) 0 ;
6774 int arg2 ;
6775 void *argp1 = 0 ;
6776 int res1 = 0 ;
6777 int val2 ;
6778 int ecode2 = 0 ;
6779 PyObject * obj0 = 0 ;
6780 PyObject * obj1 = 0 ;
6781 char * kwnames[] = {
6782 (char *) "self",(char *) "left", NULL
6783 };
6784
6785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6787 if (!SWIG_IsOK(res1)) {
6788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6789 }
6790 arg1 = reinterpret_cast< wxRect * >(argp1);
6791 ecode2 = SWIG_AsVal_int(obj1, &val2);
6792 if (!SWIG_IsOK(ecode2)) {
6793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6794 }
6795 arg2 = static_cast< int >(val2);
6796 {
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 (arg1)->SetLeft(arg2);
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_Py_Void();
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj = 0;
6811 wxRect *arg1 = (wxRect *) 0 ;
6812 int arg2 ;
6813 void *argp1 = 0 ;
6814 int res1 = 0 ;
6815 int val2 ;
6816 int ecode2 = 0 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char * kwnames[] = {
6820 (char *) "self",(char *) "right", NULL
6821 };
6822
6823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6825 if (!SWIG_IsOK(res1)) {
6826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6827 }
6828 arg1 = reinterpret_cast< wxRect * >(argp1);
6829 ecode2 = SWIG_AsVal_int(obj1, &val2);
6830 if (!SWIG_IsOK(ecode2)) {
6831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6832 }
6833 arg2 = static_cast< int >(val2);
6834 {
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 (arg1)->SetRight(arg2);
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 resultobj = SWIG_Py_Void();
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6848 PyObject *resultobj = 0;
6849 wxRect *arg1 = (wxRect *) 0 ;
6850 int arg2 ;
6851 void *argp1 = 0 ;
6852 int res1 = 0 ;
6853 int val2 ;
6854 int ecode2 = 0 ;
6855 PyObject * obj0 = 0 ;
6856 PyObject * obj1 = 0 ;
6857 char * kwnames[] = {
6858 (char *) "self",(char *) "top", NULL
6859 };
6860
6861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6863 if (!SWIG_IsOK(res1)) {
6864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6865 }
6866 arg1 = reinterpret_cast< wxRect * >(argp1);
6867 ecode2 = SWIG_AsVal_int(obj1, &val2);
6868 if (!SWIG_IsOK(ecode2)) {
6869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6870 }
6871 arg2 = static_cast< int >(val2);
6872 {
6873 PyThreadState* __tstate = wxPyBeginAllowThreads();
6874 (arg1)->SetTop(arg2);
6875 wxPyEndAllowThreads(__tstate);
6876 if (PyErr_Occurred()) SWIG_fail;
6877 }
6878 resultobj = SWIG_Py_Void();
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6886 PyObject *resultobj = 0;
6887 wxRect *arg1 = (wxRect *) 0 ;
6888 int arg2 ;
6889 void *argp1 = 0 ;
6890 int res1 = 0 ;
6891 int val2 ;
6892 int ecode2 = 0 ;
6893 PyObject * obj0 = 0 ;
6894 PyObject * obj1 = 0 ;
6895 char * kwnames[] = {
6896 (char *) "self",(char *) "bottom", NULL
6897 };
6898
6899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6901 if (!SWIG_IsOK(res1)) {
6902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6903 }
6904 arg1 = reinterpret_cast< wxRect * >(argp1);
6905 ecode2 = SWIG_AsVal_int(obj1, &val2);
6906 if (!SWIG_IsOK(ecode2)) {
6907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6908 }
6909 arg2 = static_cast< int >(val2);
6910 {
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 (arg1)->SetBottom(arg2);
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_Py_Void();
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj = 0;
6925 wxRect *arg1 = (wxRect *) 0 ;
6926 int arg2 ;
6927 int arg3 ;
6928 wxRect *result = 0 ;
6929 void *argp1 = 0 ;
6930 int res1 = 0 ;
6931 int val2 ;
6932 int ecode2 = 0 ;
6933 int val3 ;
6934 int ecode3 = 0 ;
6935 PyObject * obj0 = 0 ;
6936 PyObject * obj1 = 0 ;
6937 PyObject * obj2 = 0 ;
6938 char * kwnames[] = {
6939 (char *) "self",(char *) "dx",(char *) "dy", NULL
6940 };
6941
6942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6944 if (!SWIG_IsOK(res1)) {
6945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
6946 }
6947 arg1 = reinterpret_cast< wxRect * >(argp1);
6948 ecode2 = SWIG_AsVal_int(obj1, &val2);
6949 if (!SWIG_IsOK(ecode2)) {
6950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
6951 }
6952 arg2 = static_cast< int >(val2);
6953 ecode3 = SWIG_AsVal_int(obj2, &val3);
6954 if (!SWIG_IsOK(ecode3)) {
6955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
6956 }
6957 arg3 = static_cast< int >(val3);
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 {
6961 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
6962 result = (wxRect *) &_result_ref;
6963 }
6964 wxPyEndAllowThreads(__tstate);
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj = 0;
6976 wxRect *arg1 = (wxRect *) 0 ;
6977 int arg2 ;
6978 int arg3 ;
6979 wxRect *result = 0 ;
6980 void *argp1 = 0 ;
6981 int res1 = 0 ;
6982 int val2 ;
6983 int ecode2 = 0 ;
6984 int val3 ;
6985 int ecode3 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 PyObject * obj2 = 0 ;
6989 char * kwnames[] = {
6990 (char *) "self",(char *) "dx",(char *) "dy", NULL
6991 };
6992
6993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6995 if (!SWIG_IsOK(res1)) {
6996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
6997 }
6998 arg1 = reinterpret_cast< wxRect * >(argp1);
6999 ecode2 = SWIG_AsVal_int(obj1, &val2);
7000 if (!SWIG_IsOK(ecode2)) {
7001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7002 }
7003 arg2 = static_cast< int >(val2);
7004 ecode3 = SWIG_AsVal_int(obj2, &val3);
7005 if (!SWIG_IsOK(ecode3)) {
7006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7007 }
7008 arg3 = static_cast< int >(val3);
7009 {
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 {
7012 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7013 result = (wxRect *) &_result_ref;
7014 }
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj = 0;
7027 wxRect *arg1 = (wxRect *) 0 ;
7028 int arg2 ;
7029 int arg3 ;
7030 void *argp1 = 0 ;
7031 int res1 = 0 ;
7032 int val2 ;
7033 int ecode2 = 0 ;
7034 int val3 ;
7035 int ecode3 = 0 ;
7036 PyObject * obj0 = 0 ;
7037 PyObject * obj1 = 0 ;
7038 PyObject * obj2 = 0 ;
7039 char * kwnames[] = {
7040 (char *) "self",(char *) "dx",(char *) "dy", NULL
7041 };
7042
7043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7047 }
7048 arg1 = reinterpret_cast< wxRect * >(argp1);
7049 ecode2 = SWIG_AsVal_int(obj1, &val2);
7050 if (!SWIG_IsOK(ecode2)) {
7051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7052 }
7053 arg2 = static_cast< int >(val2);
7054 ecode3 = SWIG_AsVal_int(obj2, &val3);
7055 if (!SWIG_IsOK(ecode3)) {
7056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7057 }
7058 arg3 = static_cast< int >(val3);
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 (arg1)->Offset(arg2,arg3);
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_Py_Void();
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxRect *arg1 = (wxRect *) 0 ;
7075 wxPoint *arg2 = 0 ;
7076 void *argp1 = 0 ;
7077 int res1 = 0 ;
7078 wxPoint temp2 ;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 char * kwnames[] = {
7082 (char *) "self",(char *) "pt", NULL
7083 };
7084
7085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7089 }
7090 arg1 = reinterpret_cast< wxRect * >(argp1);
7091 {
7092 arg2 = &temp2;
7093 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7094 }
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 (arg1)->Offset((wxPoint const &)*arg2);
7098 wxPyEndAllowThreads(__tstate);
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_Py_Void();
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 wxRect *arg2 = 0 ;
7112 wxRect result;
7113 void *argp1 = 0 ;
7114 int res1 = 0 ;
7115 wxRect temp2 ;
7116 PyObject * obj0 = 0 ;
7117 PyObject * obj1 = 0 ;
7118 char * kwnames[] = {
7119 (char *) "self",(char *) "rect", NULL
7120 };
7121
7122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7124 if (!SWIG_IsOK(res1)) {
7125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7126 }
7127 arg1 = reinterpret_cast< wxRect * >(argp1);
7128 {
7129 arg2 = &temp2;
7130 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7131 }
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 result = (arg1)->Intersect((wxRect const &)*arg2);
7135 wxPyEndAllowThreads(__tstate);
7136 if (PyErr_Occurred()) SWIG_fail;
7137 }
7138 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7146 PyObject *resultobj = 0;
7147 wxRect *arg1 = (wxRect *) 0 ;
7148 wxRect *arg2 = 0 ;
7149 wxRect result;
7150 void *argp1 = 0 ;
7151 int res1 = 0 ;
7152 wxRect temp2 ;
7153 PyObject * obj0 = 0 ;
7154 PyObject * obj1 = 0 ;
7155 char * kwnames[] = {
7156 (char *) "self",(char *) "rect", NULL
7157 };
7158
7159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7161 if (!SWIG_IsOK(res1)) {
7162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7163 }
7164 arg1 = reinterpret_cast< wxRect * >(argp1);
7165 {
7166 arg2 = &temp2;
7167 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7168 }
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 result = (arg1)->Union((wxRect const &)*arg2);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj = 0;
7184 wxRect *arg1 = (wxRect *) 0 ;
7185 wxRect *arg2 = 0 ;
7186 wxRect result;
7187 void *argp1 = 0 ;
7188 int res1 = 0 ;
7189 wxRect temp2 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 char * kwnames[] = {
7193 (char *) "self",(char *) "rect", NULL
7194 };
7195
7196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7198 if (!SWIG_IsOK(res1)) {
7199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7200 }
7201 arg1 = reinterpret_cast< wxRect * >(argp1);
7202 {
7203 arg2 = &temp2;
7204 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7205 }
7206 {
7207 PyThreadState* __tstate = wxPyBeginAllowThreads();
7208 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7209 wxPyEndAllowThreads(__tstate);
7210 if (PyErr_Occurred()) SWIG_fail;
7211 }
7212 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = 0;
7221 wxRect *arg1 = (wxRect *) 0 ;
7222 wxRect *arg2 = 0 ;
7223 wxRect *result = 0 ;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 wxRect temp2 ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 char * kwnames[] = {
7230 (char *) "self",(char *) "rect", NULL
7231 };
7232
7233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7235 if (!SWIG_IsOK(res1)) {
7236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7237 }
7238 arg1 = reinterpret_cast< wxRect * >(argp1);
7239 {
7240 arg2 = &temp2;
7241 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7242 }
7243 {
7244 PyThreadState* __tstate = wxPyBeginAllowThreads();
7245 {
7246 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7247 result = (wxRect *) &_result_ref;
7248 }
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj = 0;
7261 wxRect *arg1 = (wxRect *) 0 ;
7262 wxRect *arg2 = 0 ;
7263 bool result;
7264 void *argp1 = 0 ;
7265 int res1 = 0 ;
7266 wxRect temp2 ;
7267 PyObject * obj0 = 0 ;
7268 PyObject * obj1 = 0 ;
7269 char * kwnames[] = {
7270 (char *) "self",(char *) "rect", NULL
7271 };
7272
7273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7275 if (!SWIG_IsOK(res1)) {
7276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect const *""'");
7277 }
7278 arg1 = reinterpret_cast< wxRect * >(argp1);
7279 {
7280 arg2 = &temp2;
7281 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7282 }
7283 {
7284 PyThreadState* __tstate = wxPyBeginAllowThreads();
7285 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
7286 wxPyEndAllowThreads(__tstate);
7287 if (PyErr_Occurred()) SWIG_fail;
7288 }
7289 {
7290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7291 }
7292 return resultobj;
7293 fail:
7294 return NULL;
7295 }
7296
7297
7298 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7299 PyObject *resultobj = 0;
7300 wxRect *arg1 = (wxRect *) 0 ;
7301 wxRect *arg2 = 0 ;
7302 bool result;
7303 void *argp1 = 0 ;
7304 int res1 = 0 ;
7305 wxRect temp2 ;
7306 PyObject * obj0 = 0 ;
7307 PyObject * obj1 = 0 ;
7308 char * kwnames[] = {
7309 (char *) "self",(char *) "rect", NULL
7310 };
7311
7312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7314 if (!SWIG_IsOK(res1)) {
7315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect const *""'");
7316 }
7317 arg1 = reinterpret_cast< wxRect * >(argp1);
7318 {
7319 arg2 = &temp2;
7320 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7321 }
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
7325 wxPyEndAllowThreads(__tstate);
7326 if (PyErr_Occurred()) SWIG_fail;
7327 }
7328 {
7329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7330 }
7331 return resultobj;
7332 fail:
7333 return NULL;
7334 }
7335
7336
7337 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7338 PyObject *resultobj = 0;
7339 wxRect *arg1 = (wxRect *) 0 ;
7340 int arg2 ;
7341 int arg3 ;
7342 bool result;
7343 void *argp1 = 0 ;
7344 int res1 = 0 ;
7345 int val2 ;
7346 int ecode2 = 0 ;
7347 int val3 ;
7348 int ecode3 = 0 ;
7349 PyObject * obj0 = 0 ;
7350 PyObject * obj1 = 0 ;
7351 PyObject * obj2 = 0 ;
7352 char * kwnames[] = {
7353 (char *) "self",(char *) "x",(char *) "y", NULL
7354 };
7355
7356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7358 if (!SWIG_IsOK(res1)) {
7359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7360 }
7361 arg1 = reinterpret_cast< wxRect * >(argp1);
7362 ecode2 = SWIG_AsVal_int(obj1, &val2);
7363 if (!SWIG_IsOK(ecode2)) {
7364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7365 }
7366 arg2 = static_cast< int >(val2);
7367 ecode3 = SWIG_AsVal_int(obj2, &val3);
7368 if (!SWIG_IsOK(ecode3)) {
7369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7370 }
7371 arg3 = static_cast< int >(val3);
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 {
7379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7380 }
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj = 0;
7389 wxRect *arg1 = (wxRect *) 0 ;
7390 wxPoint *arg2 = 0 ;
7391 bool result;
7392 void *argp1 = 0 ;
7393 int res1 = 0 ;
7394 wxPoint temp2 ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 char * kwnames[] = {
7398 (char *) "self",(char *) "pt", NULL
7399 };
7400
7401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7403 if (!SWIG_IsOK(res1)) {
7404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7405 }
7406 arg1 = reinterpret_cast< wxRect * >(argp1);
7407 {
7408 arg2 = &temp2;
7409 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7410 }
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 {
7418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7419 }
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7427 PyObject *resultobj = 0;
7428 wxRect *arg1 = (wxRect *) 0 ;
7429 wxRect *arg2 = 0 ;
7430 bool result;
7431 void *argp1 = 0 ;
7432 int res1 = 0 ;
7433 wxRect temp2 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char * kwnames[] = {
7437 (char *) "self",(char *) "rect", NULL
7438 };
7439
7440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7442 if (!SWIG_IsOK(res1)) {
7443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7444 }
7445 arg1 = reinterpret_cast< wxRect * >(argp1);
7446 {
7447 arg2 = &temp2;
7448 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7449 }
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj = 0;
7467 wxRect *arg1 = (wxRect *) 0 ;
7468 wxRect *arg2 = 0 ;
7469 int arg3 = (int) wxBOTH ;
7470 wxRect result;
7471 void *argp1 = 0 ;
7472 int res1 = 0 ;
7473 wxRect temp2 ;
7474 int val3 ;
7475 int ecode3 = 0 ;
7476 PyObject * obj0 = 0 ;
7477 PyObject * obj1 = 0 ;
7478 PyObject * obj2 = 0 ;
7479 char * kwnames[] = {
7480 (char *) "self",(char *) "r",(char *) "dir", NULL
7481 };
7482
7483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7485 if (!SWIG_IsOK(res1)) {
7486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7487 }
7488 arg1 = reinterpret_cast< wxRect * >(argp1);
7489 {
7490 arg2 = &temp2;
7491 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7492 }
7493 if (obj2) {
7494 ecode3 = SWIG_AsVal_int(obj2, &val3);
7495 if (!SWIG_IsOK(ecode3)) {
7496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7497 }
7498 arg3 = static_cast< int >(val3);
7499 }
7500 {
7501 PyThreadState* __tstate = wxPyBeginAllowThreads();
7502 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7503 wxPyEndAllowThreads(__tstate);
7504 if (PyErr_Occurred()) SWIG_fail;
7505 }
7506 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7507 return resultobj;
7508 fail:
7509 return NULL;
7510 }
7511
7512
7513 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7514 PyObject *resultobj = 0;
7515 wxRect *arg1 = (wxRect *) 0 ;
7516 int arg2 ;
7517 void *argp1 = 0 ;
7518 int res1 = 0 ;
7519 int val2 ;
7520 int ecode2 = 0 ;
7521 PyObject *swig_obj[2] ;
7522
7523 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7525 if (!SWIG_IsOK(res1)) {
7526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7527 }
7528 arg1 = reinterpret_cast< wxRect * >(argp1);
7529 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7530 if (!SWIG_IsOK(ecode2)) {
7531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7532 }
7533 arg2 = static_cast< int >(val2);
7534 if (arg1) (arg1)->x = arg2;
7535
7536 resultobj = SWIG_Py_Void();
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 int result;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 PyObject *swig_obj[1] ;
7550
7551 if (!args) SWIG_fail;
7552 swig_obj[0] = args;
7553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7556 }
7557 arg1 = reinterpret_cast< wxRect * >(argp1);
7558 result = (int) ((arg1)->x);
7559 resultobj = SWIG_From_int(static_cast< int >(result));
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7567 PyObject *resultobj = 0;
7568 wxRect *arg1 = (wxRect *) 0 ;
7569 int arg2 ;
7570 void *argp1 = 0 ;
7571 int res1 = 0 ;
7572 int val2 ;
7573 int ecode2 = 0 ;
7574 PyObject *swig_obj[2] ;
7575
7576 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7578 if (!SWIG_IsOK(res1)) {
7579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7580 }
7581 arg1 = reinterpret_cast< wxRect * >(argp1);
7582 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7583 if (!SWIG_IsOK(ecode2)) {
7584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7585 }
7586 arg2 = static_cast< int >(val2);
7587 if (arg1) (arg1)->y = arg2;
7588
7589 resultobj = SWIG_Py_Void();
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7597 PyObject *resultobj = 0;
7598 wxRect *arg1 = (wxRect *) 0 ;
7599 int result;
7600 void *argp1 = 0 ;
7601 int res1 = 0 ;
7602 PyObject *swig_obj[1] ;
7603
7604 if (!args) SWIG_fail;
7605 swig_obj[0] = args;
7606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7609 }
7610 arg1 = reinterpret_cast< wxRect * >(argp1);
7611 result = (int) ((arg1)->y);
7612 resultobj = SWIG_From_int(static_cast< int >(result));
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7620 PyObject *resultobj = 0;
7621 wxRect *arg1 = (wxRect *) 0 ;
7622 int arg2 ;
7623 void *argp1 = 0 ;
7624 int res1 = 0 ;
7625 int val2 ;
7626 int ecode2 = 0 ;
7627 PyObject *swig_obj[2] ;
7628
7629 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7631 if (!SWIG_IsOK(res1)) {
7632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7633 }
7634 arg1 = reinterpret_cast< wxRect * >(argp1);
7635 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7636 if (!SWIG_IsOK(ecode2)) {
7637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7638 }
7639 arg2 = static_cast< int >(val2);
7640 if (arg1) (arg1)->width = arg2;
7641
7642 resultobj = SWIG_Py_Void();
7643 return resultobj;
7644 fail:
7645 return NULL;
7646 }
7647
7648
7649 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7650 PyObject *resultobj = 0;
7651 wxRect *arg1 = (wxRect *) 0 ;
7652 int result;
7653 void *argp1 = 0 ;
7654 int res1 = 0 ;
7655 PyObject *swig_obj[1] ;
7656
7657 if (!args) SWIG_fail;
7658 swig_obj[0] = args;
7659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7660 if (!SWIG_IsOK(res1)) {
7661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7662 }
7663 arg1 = reinterpret_cast< wxRect * >(argp1);
7664 result = (int) ((arg1)->width);
7665 resultobj = SWIG_From_int(static_cast< int >(result));
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7673 PyObject *resultobj = 0;
7674 wxRect *arg1 = (wxRect *) 0 ;
7675 int arg2 ;
7676 void *argp1 = 0 ;
7677 int res1 = 0 ;
7678 int val2 ;
7679 int ecode2 = 0 ;
7680 PyObject *swig_obj[2] ;
7681
7682 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7686 }
7687 arg1 = reinterpret_cast< wxRect * >(argp1);
7688 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7689 if (!SWIG_IsOK(ecode2)) {
7690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7691 }
7692 arg2 = static_cast< int >(val2);
7693 if (arg1) (arg1)->height = arg2;
7694
7695 resultobj = SWIG_Py_Void();
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7703 PyObject *resultobj = 0;
7704 wxRect *arg1 = (wxRect *) 0 ;
7705 int result;
7706 void *argp1 = 0 ;
7707 int res1 = 0 ;
7708 PyObject *swig_obj[1] ;
7709
7710 if (!args) SWIG_fail;
7711 swig_obj[0] = args;
7712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7713 if (!SWIG_IsOK(res1)) {
7714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7715 }
7716 arg1 = reinterpret_cast< wxRect * >(argp1);
7717 result = (int) ((arg1)->height);
7718 resultobj = SWIG_From_int(static_cast< int >(result));
7719 return resultobj;
7720 fail:
7721 return NULL;
7722 }
7723
7724
7725 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7726 PyObject *resultobj = 0;
7727 wxRect *arg1 = (wxRect *) 0 ;
7728 int arg2 = (int) 0 ;
7729 int arg3 = (int) 0 ;
7730 int arg4 = (int) 0 ;
7731 int arg5 = (int) 0 ;
7732 void *argp1 = 0 ;
7733 int res1 = 0 ;
7734 int val2 ;
7735 int ecode2 = 0 ;
7736 int val3 ;
7737 int ecode3 = 0 ;
7738 int val4 ;
7739 int ecode4 = 0 ;
7740 int val5 ;
7741 int ecode5 = 0 ;
7742 PyObject * obj0 = 0 ;
7743 PyObject * obj1 = 0 ;
7744 PyObject * obj2 = 0 ;
7745 PyObject * obj3 = 0 ;
7746 PyObject * obj4 = 0 ;
7747 char * kwnames[] = {
7748 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7749 };
7750
7751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7753 if (!SWIG_IsOK(res1)) {
7754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7755 }
7756 arg1 = reinterpret_cast< wxRect * >(argp1);
7757 if (obj1) {
7758 ecode2 = SWIG_AsVal_int(obj1, &val2);
7759 if (!SWIG_IsOK(ecode2)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7761 }
7762 arg2 = static_cast< int >(val2);
7763 }
7764 if (obj2) {
7765 ecode3 = SWIG_AsVal_int(obj2, &val3);
7766 if (!SWIG_IsOK(ecode3)) {
7767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7768 }
7769 arg3 = static_cast< int >(val3);
7770 }
7771 if (obj3) {
7772 ecode4 = SWIG_AsVal_int(obj3, &val4);
7773 if (!SWIG_IsOK(ecode4)) {
7774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7775 }
7776 arg4 = static_cast< int >(val4);
7777 }
7778 if (obj4) {
7779 ecode5 = SWIG_AsVal_int(obj4, &val5);
7780 if (!SWIG_IsOK(ecode5)) {
7781 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7782 }
7783 arg5 = static_cast< int >(val5);
7784 }
7785 {
7786 PyThreadState* __tstate = wxPyBeginAllowThreads();
7787 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7788 wxPyEndAllowThreads(__tstate);
7789 if (PyErr_Occurred()) SWIG_fail;
7790 }
7791 resultobj = SWIG_Py_Void();
7792 return resultobj;
7793 fail:
7794 return NULL;
7795 }
7796
7797
7798 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7799 PyObject *resultobj = 0;
7800 wxRect *arg1 = (wxRect *) 0 ;
7801 PyObject *result = 0 ;
7802 void *argp1 = 0 ;
7803 int res1 = 0 ;
7804 PyObject *swig_obj[1] ;
7805
7806 if (!args) SWIG_fail;
7807 swig_obj[0] = args;
7808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7809 if (!SWIG_IsOK(res1)) {
7810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7811 }
7812 arg1 = reinterpret_cast< wxRect * >(argp1);
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 result = (PyObject *)wxRect_Get(arg1);
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 resultobj = result;
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7827 PyObject *obj;
7828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7829 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7830 return SWIG_Py_Void();
7831 }
7832
7833 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7834 return SWIG_Python_InitShadowInstance(args);
7835 }
7836
7837 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj = 0;
7839 wxRect *arg1 = (wxRect *) 0 ;
7840 wxRect *arg2 = (wxRect *) 0 ;
7841 PyObject *result = 0 ;
7842 void *argp1 = 0 ;
7843 int res1 = 0 ;
7844 void *argp2 = 0 ;
7845 int res2 = 0 ;
7846 PyObject * obj0 = 0 ;
7847 PyObject * obj1 = 0 ;
7848 char * kwnames[] = {
7849 (char *) "r1",(char *) "r2", NULL
7850 };
7851
7852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7854 if (!SWIG_IsOK(res1)) {
7855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7856 }
7857 arg1 = reinterpret_cast< wxRect * >(argp1);
7858 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7859 if (!SWIG_IsOK(res2)) {
7860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7861 }
7862 arg2 = reinterpret_cast< wxRect * >(argp2);
7863 {
7864 if (!wxPyCheckForApp()) SWIG_fail;
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 result = (PyObject *)wxIntersectRect(arg1,arg2);
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 resultobj = result;
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7878 PyObject *resultobj = 0;
7879 double arg1 = (double) 0.0 ;
7880 double arg2 = (double) 0.0 ;
7881 wxPoint2D *result = 0 ;
7882 double val1 ;
7883 int ecode1 = 0 ;
7884 double val2 ;
7885 int ecode2 = 0 ;
7886 PyObject * obj0 = 0 ;
7887 PyObject * obj1 = 0 ;
7888 char * kwnames[] = {
7889 (char *) "x",(char *) "y", NULL
7890 };
7891
7892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7893 if (obj0) {
7894 ecode1 = SWIG_AsVal_double(obj0, &val1);
7895 if (!SWIG_IsOK(ecode1)) {
7896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7897 }
7898 arg1 = static_cast< double >(val1);
7899 }
7900 if (obj1) {
7901 ecode2 = SWIG_AsVal_double(obj1, &val2);
7902 if (!SWIG_IsOK(ecode2)) {
7903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7904 }
7905 arg2 = static_cast< double >(val2);
7906 }
7907 {
7908 PyThreadState* __tstate = wxPyBeginAllowThreads();
7909 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj = 0;
7922 wxPoint2D *arg1 = 0 ;
7923 wxPoint2D *result = 0 ;
7924 wxPoint2D temp1 ;
7925 PyObject * obj0 = 0 ;
7926 char * kwnames[] = {
7927 (char *) "pt", NULL
7928 };
7929
7930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7931 {
7932 arg1 = &temp1;
7933 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7934 }
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj = 0;
7950 wxPoint *arg1 = 0 ;
7951 wxPoint2D *result = 0 ;
7952 wxPoint temp1 ;
7953 PyObject * obj0 = 0 ;
7954 char * kwnames[] = {
7955 (char *) "pt", NULL
7956 };
7957
7958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
7959 {
7960 arg1 = &temp1;
7961 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7962 }
7963 {
7964 PyThreadState* __tstate = wxPyBeginAllowThreads();
7965 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
7966 wxPyEndAllowThreads(__tstate);
7967 if (PyErr_Occurred()) SWIG_fail;
7968 }
7969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7970 return resultobj;
7971 fail:
7972 return NULL;
7973 }
7974
7975
7976 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7977 PyObject *resultobj = 0;
7978 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7979 int *arg2 = (int *) 0 ;
7980 int *arg3 = (int *) 0 ;
7981 void *argp1 = 0 ;
7982 int res1 = 0 ;
7983 int temp2 ;
7984 int res2 = SWIG_TMPOBJ ;
7985 int temp3 ;
7986 int res3 = SWIG_TMPOBJ ;
7987 PyObject *swig_obj[1] ;
7988
7989 arg2 = &temp2;
7990 arg3 = &temp3;
7991 if (!args) SWIG_fail;
7992 swig_obj[0] = args;
7993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
7996 }
7997 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
7998 {
7999 PyThreadState* __tstate = wxPyBeginAllowThreads();
8000 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 resultobj = SWIG_Py_Void();
8005 if (SWIG_IsTmpObj(res2)) {
8006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8007 } else {
8008 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8010 }
8011 if (SWIG_IsTmpObj(res3)) {
8012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8013 } else {
8014 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8016 }
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8026 int *arg2 = (int *) 0 ;
8027 int *arg3 = (int *) 0 ;
8028 void *argp1 = 0 ;
8029 int res1 = 0 ;
8030 int temp2 ;
8031 int res2 = SWIG_TMPOBJ ;
8032 int temp3 ;
8033 int res3 = SWIG_TMPOBJ ;
8034 PyObject *swig_obj[1] ;
8035
8036 arg2 = &temp2;
8037 arg3 = &temp3;
8038 if (!args) SWIG_fail;
8039 swig_obj[0] = args;
8040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8041 if (!SWIG_IsOK(res1)) {
8042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8043 }
8044 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_Py_Void();
8052 if (SWIG_IsTmpObj(res2)) {
8053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8054 } else {
8055 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8056 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8057 }
8058 if (SWIG_IsTmpObj(res3)) {
8059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8060 } else {
8061 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8063 }
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8071 PyObject *resultobj = 0;
8072 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8073 double result;
8074 void *argp1 = 0 ;
8075 int res1 = 0 ;
8076 PyObject *swig_obj[1] ;
8077
8078 if (!args) SWIG_fail;
8079 swig_obj[0] = args;
8080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8081 if (!SWIG_IsOK(res1)) {
8082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8083 }
8084 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8085 {
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 resultobj = SWIG_From_double(static_cast< double >(result));
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8099 PyObject *resultobj = 0;
8100 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8101 double result;
8102 void *argp1 = 0 ;
8103 int res1 = 0 ;
8104 PyObject *swig_obj[1] ;
8105
8106 if (!args) SWIG_fail;
8107 swig_obj[0] = args;
8108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8109 if (!SWIG_IsOK(res1)) {
8110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8111 }
8112 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8113 {
8114 PyThreadState* __tstate = wxPyBeginAllowThreads();
8115 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 resultobj = SWIG_From_double(static_cast< double >(result));
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj = 0;
8128 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8129 double arg2 ;
8130 void *argp1 = 0 ;
8131 int res1 = 0 ;
8132 double val2 ;
8133 int ecode2 = 0 ;
8134 PyObject * obj0 = 0 ;
8135 PyObject * obj1 = 0 ;
8136 char * kwnames[] = {
8137 (char *) "self",(char *) "length", NULL
8138 };
8139
8140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8142 if (!SWIG_IsOK(res1)) {
8143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8144 }
8145 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8146 ecode2 = SWIG_AsVal_double(obj1, &val2);
8147 if (!SWIG_IsOK(ecode2)) {
8148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8149 }
8150 arg2 = static_cast< double >(val2);
8151 {
8152 PyThreadState* __tstate = wxPyBeginAllowThreads();
8153 (arg1)->SetVectorLength(arg2);
8154 wxPyEndAllowThreads(__tstate);
8155 if (PyErr_Occurred()) SWIG_fail;
8156 }
8157 resultobj = SWIG_Py_Void();
8158 return resultobj;
8159 fail:
8160 return NULL;
8161 }
8162
8163
8164 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8165 PyObject *resultobj = 0;
8166 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8167 double arg2 ;
8168 void *argp1 = 0 ;
8169 int res1 = 0 ;
8170 double val2 ;
8171 int ecode2 = 0 ;
8172 PyObject * obj0 = 0 ;
8173 PyObject * obj1 = 0 ;
8174 char * kwnames[] = {
8175 (char *) "self",(char *) "degrees", NULL
8176 };
8177
8178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8180 if (!SWIG_IsOK(res1)) {
8181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8182 }
8183 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8184 ecode2 = SWIG_AsVal_double(obj1, &val2);
8185 if (!SWIG_IsOK(ecode2)) {
8186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8187 }
8188 arg2 = static_cast< double >(val2);
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 (arg1)->SetVectorAngle(arg2);
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_Py_Void();
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj = 0;
8204 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8205 wxPoint2D *arg2 = 0 ;
8206 double result;
8207 void *argp1 = 0 ;
8208 int res1 = 0 ;
8209 wxPoint2D temp2 ;
8210 PyObject * obj0 = 0 ;
8211 PyObject * obj1 = 0 ;
8212 char * kwnames[] = {
8213 (char *) "self",(char *) "pt", NULL
8214 };
8215
8216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8220 }
8221 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8222 {
8223 arg2 = &temp2;
8224 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8225 }
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_From_double(static_cast< double >(result));
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj = 0;
8241 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8242 wxPoint2D *arg2 = 0 ;
8243 double result;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 wxPoint2D temp2 ;
8247 PyObject * obj0 = 0 ;
8248 PyObject * obj1 = 0 ;
8249 char * kwnames[] = {
8250 (char *) "self",(char *) "pt", NULL
8251 };
8252
8253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8255 if (!SWIG_IsOK(res1)) {
8256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8257 }
8258 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8259 {
8260 arg2 = &temp2;
8261 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8262 }
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 resultobj = SWIG_From_double(static_cast< double >(result));
8270 return resultobj;
8271 fail:
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8277 PyObject *resultobj = 0;
8278 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8279 wxPoint2D *arg2 = 0 ;
8280 double result;
8281 void *argp1 = 0 ;
8282 int res1 = 0 ;
8283 wxPoint2D temp2 ;
8284 PyObject * obj0 = 0 ;
8285 PyObject * obj1 = 0 ;
8286 char * kwnames[] = {
8287 (char *) "self",(char *) "vec", NULL
8288 };
8289
8290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8292 if (!SWIG_IsOK(res1)) {
8293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8294 }
8295 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8296 {
8297 arg2 = &temp2;
8298 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8299 }
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8303 wxPyEndAllowThreads(__tstate);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 resultobj = SWIG_From_double(static_cast< double >(result));
8307 return resultobj;
8308 fail:
8309 return NULL;
8310 }
8311
8312
8313 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8314 PyObject *resultobj = 0;
8315 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8316 wxPoint2D *arg2 = 0 ;
8317 double result;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 wxPoint2D temp2 ;
8321 PyObject * obj0 = 0 ;
8322 PyObject * obj1 = 0 ;
8323 char * kwnames[] = {
8324 (char *) "self",(char *) "vec", NULL
8325 };
8326
8327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8329 if (!SWIG_IsOK(res1)) {
8330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8331 }
8332 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8333 {
8334 arg2 = &temp2;
8335 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 resultobj = SWIG_From_double(static_cast< double >(result));
8344 return resultobj;
8345 fail:
8346 return NULL;
8347 }
8348
8349
8350 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8351 PyObject *resultobj = 0;
8352 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8353 wxPoint2D result;
8354 void *argp1 = 0 ;
8355 int res1 = 0 ;
8356 PyObject *swig_obj[1] ;
8357
8358 if (!args) SWIG_fail;
8359 swig_obj[0] = args;
8360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8361 if (!SWIG_IsOK(res1)) {
8362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8363 }
8364 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8365 {
8366 PyThreadState* __tstate = wxPyBeginAllowThreads();
8367 result = (arg1)->operator -();
8368 wxPyEndAllowThreads(__tstate);
8369 if (PyErr_Occurred()) SWIG_fail;
8370 }
8371 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj = 0;
8380 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8381 wxPoint2D *arg2 = 0 ;
8382 wxPoint2D *result = 0 ;
8383 void *argp1 = 0 ;
8384 int res1 = 0 ;
8385 wxPoint2D temp2 ;
8386 PyObject * obj0 = 0 ;
8387 PyObject * obj1 = 0 ;
8388 char * kwnames[] = {
8389 (char *) "self",(char *) "pt", NULL
8390 };
8391
8392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8394 if (!SWIG_IsOK(res1)) {
8395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8396 }
8397 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8398 {
8399 arg2 = &temp2;
8400 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8401 }
8402 {
8403 PyThreadState* __tstate = wxPyBeginAllowThreads();
8404 {
8405 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8406 result = (wxPoint2D *) &_result_ref;
8407 }
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8419 PyObject *resultobj = 0;
8420 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8421 wxPoint2D *arg2 = 0 ;
8422 wxPoint2D *result = 0 ;
8423 void *argp1 = 0 ;
8424 int res1 = 0 ;
8425 wxPoint2D temp2 ;
8426 PyObject * obj0 = 0 ;
8427 PyObject * obj1 = 0 ;
8428 char * kwnames[] = {
8429 (char *) "self",(char *) "pt", NULL
8430 };
8431
8432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8434 if (!SWIG_IsOK(res1)) {
8435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8436 }
8437 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8438 {
8439 arg2 = &temp2;
8440 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8441 }
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 {
8445 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8446 result = (wxPoint2D *) &_result_ref;
8447 }
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 wxPoint2D *arg2 = 0 ;
8462 wxPoint2D *result = 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 wxPoint2D temp2 ;
8466 PyObject * obj0 = 0 ;
8467 PyObject * obj1 = 0 ;
8468 char * kwnames[] = {
8469 (char *) "self",(char *) "pt", NULL
8470 };
8471
8472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8474 if (!SWIG_IsOK(res1)) {
8475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8476 }
8477 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8478 {
8479 arg2 = &temp2;
8480 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8481 }
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 {
8485 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8486 result = (wxPoint2D *) &_result_ref;
8487 }
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8492 return resultobj;
8493 fail:
8494 return NULL;
8495 }
8496
8497
8498 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8499 PyObject *resultobj = 0;
8500 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8501 wxPoint2D *arg2 = 0 ;
8502 wxPoint2D *result = 0 ;
8503 void *argp1 = 0 ;
8504 int res1 = 0 ;
8505 wxPoint2D temp2 ;
8506 PyObject * obj0 = 0 ;
8507 PyObject * obj1 = 0 ;
8508 char * kwnames[] = {
8509 (char *) "self",(char *) "pt", NULL
8510 };
8511
8512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8514 if (!SWIG_IsOK(res1)) {
8515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8516 }
8517 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8518 {
8519 arg2 = &temp2;
8520 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8521 }
8522 {
8523 PyThreadState* __tstate = wxPyBeginAllowThreads();
8524 {
8525 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8526 result = (wxPoint2D *) &_result_ref;
8527 }
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8532 return resultobj;
8533 fail:
8534 return NULL;
8535 }
8536
8537
8538 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj = 0;
8540 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8541 wxPoint2D *arg2 = 0 ;
8542 bool result;
8543 void *argp1 = 0 ;
8544 int res1 = 0 ;
8545 wxPoint2D temp2 ;
8546 PyObject * obj0 = 0 ;
8547 PyObject * obj1 = 0 ;
8548 char * kwnames[] = {
8549 (char *) "self",(char *) "pt", NULL
8550 };
8551
8552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8554 if (!SWIG_IsOK(res1)) {
8555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8556 }
8557 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8558 {
8559 arg2 = &temp2;
8560 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8561 }
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 {
8569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8570 }
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj = 0;
8579 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8580 wxPoint2D *arg2 = 0 ;
8581 bool result;
8582 void *argp1 = 0 ;
8583 int res1 = 0 ;
8584 wxPoint2D temp2 ;
8585 PyObject * obj0 = 0 ;
8586 PyObject * obj1 = 0 ;
8587 char * kwnames[] = {
8588 (char *) "self",(char *) "pt", NULL
8589 };
8590
8591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8595 }
8596 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8597 {
8598 arg2 = &temp2;
8599 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8600 }
8601 {
8602 PyThreadState* __tstate = wxPyBeginAllowThreads();
8603 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 {
8608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8609 }
8610 return resultobj;
8611 fail:
8612 return NULL;
8613 }
8614
8615
8616 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8617 PyObject *resultobj = 0;
8618 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8619 double arg2 ;
8620 void *argp1 = 0 ;
8621 int res1 = 0 ;
8622 double val2 ;
8623 int ecode2 = 0 ;
8624 PyObject *swig_obj[2] ;
8625
8626 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8628 if (!SWIG_IsOK(res1)) {
8629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8630 }
8631 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8632 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8633 if (!SWIG_IsOK(ecode2)) {
8634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8635 }
8636 arg2 = static_cast< double >(val2);
8637 if (arg1) (arg1)->m_x = arg2;
8638
8639 resultobj = SWIG_Py_Void();
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8647 PyObject *resultobj = 0;
8648 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8649 double result;
8650 void *argp1 = 0 ;
8651 int res1 = 0 ;
8652 PyObject *swig_obj[1] ;
8653
8654 if (!args) SWIG_fail;
8655 swig_obj[0] = args;
8656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8657 if (!SWIG_IsOK(res1)) {
8658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8659 }
8660 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8661 result = (double) ((arg1)->m_x);
8662 resultobj = SWIG_From_double(static_cast< double >(result));
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8670 PyObject *resultobj = 0;
8671 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8672 double arg2 ;
8673 void *argp1 = 0 ;
8674 int res1 = 0 ;
8675 double val2 ;
8676 int ecode2 = 0 ;
8677 PyObject *swig_obj[2] ;
8678
8679 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8681 if (!SWIG_IsOK(res1)) {
8682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8683 }
8684 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8685 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8686 if (!SWIG_IsOK(ecode2)) {
8687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8688 }
8689 arg2 = static_cast< double >(val2);
8690 if (arg1) (arg1)->m_y = arg2;
8691
8692 resultobj = SWIG_Py_Void();
8693 return resultobj;
8694 fail:
8695 return NULL;
8696 }
8697
8698
8699 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8700 PyObject *resultobj = 0;
8701 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8702 double result;
8703 void *argp1 = 0 ;
8704 int res1 = 0 ;
8705 PyObject *swig_obj[1] ;
8706
8707 if (!args) SWIG_fail;
8708 swig_obj[0] = args;
8709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 result = (double) ((arg1)->m_y);
8715 resultobj = SWIG_From_double(static_cast< double >(result));
8716 return resultobj;
8717 fail:
8718 return NULL;
8719 }
8720
8721
8722 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8723 PyObject *resultobj = 0;
8724 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8725 double arg2 = (double) 0 ;
8726 double arg3 = (double) 0 ;
8727 void *argp1 = 0 ;
8728 int res1 = 0 ;
8729 double val2 ;
8730 int ecode2 = 0 ;
8731 double val3 ;
8732 int ecode3 = 0 ;
8733 PyObject * obj0 = 0 ;
8734 PyObject * obj1 = 0 ;
8735 PyObject * obj2 = 0 ;
8736 char * kwnames[] = {
8737 (char *) "self",(char *) "x",(char *) "y", NULL
8738 };
8739
8740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8742 if (!SWIG_IsOK(res1)) {
8743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8744 }
8745 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8746 if (obj1) {
8747 ecode2 = SWIG_AsVal_double(obj1, &val2);
8748 if (!SWIG_IsOK(ecode2)) {
8749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8750 }
8751 arg2 = static_cast< double >(val2);
8752 }
8753 if (obj2) {
8754 ecode3 = SWIG_AsVal_double(obj2, &val3);
8755 if (!SWIG_IsOK(ecode3)) {
8756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8757 }
8758 arg3 = static_cast< double >(val3);
8759 }
8760 {
8761 PyThreadState* __tstate = wxPyBeginAllowThreads();
8762 wxPoint2D_Set(arg1,arg2,arg3);
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 resultobj = SWIG_Py_Void();
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8774 PyObject *resultobj = 0;
8775 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8776 PyObject *result = 0 ;
8777 void *argp1 = 0 ;
8778 int res1 = 0 ;
8779 PyObject *swig_obj[1] ;
8780
8781 if (!args) SWIG_fail;
8782 swig_obj[0] = args;
8783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8784 if (!SWIG_IsOK(res1)) {
8785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8786 }
8787 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 result = (PyObject *)wxPoint2D_Get(arg1);
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 resultobj = result;
8795 return resultobj;
8796 fail:
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8802 PyObject *obj;
8803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8804 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8805 return SWIG_Py_Void();
8806 }
8807
8808 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8809 return SWIG_Python_InitShadowInstance(args);
8810 }
8811
8812 SWIGINTERN int DefaultPosition_set(PyObject *) {
8813 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8814 return 1;
8815 }
8816
8817
8818 SWIGINTERN PyObject *DefaultPosition_get(void) {
8819 PyObject *pyobj = 0;
8820
8821 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8822 return pyobj;
8823 }
8824
8825
8826 SWIGINTERN int DefaultSize_set(PyObject *) {
8827 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8828 return 1;
8829 }
8830
8831
8832 SWIGINTERN PyObject *DefaultSize_get(void) {
8833 PyObject *pyobj = 0;
8834
8835 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8836 return pyobj;
8837 }
8838
8839
8840 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8841 PyObject *resultobj = 0;
8842 PyObject *arg1 = (PyObject *) 0 ;
8843 wxPyInputStream *result = 0 ;
8844 PyObject * obj0 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "p", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8850 arg1 = obj0;
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8854 wxPyEndAllowThreads(__tstate);
8855 if (PyErr_Occurred()) SWIG_fail;
8856 }
8857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8858 return resultobj;
8859 fail:
8860 return NULL;
8861 }
8862
8863
8864 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8865 PyObject *resultobj = 0;
8866 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8867 void *argp1 = 0 ;
8868 int res1 = 0 ;
8869 PyObject *swig_obj[1] ;
8870
8871 if (!args) SWIG_fail;
8872 swig_obj[0] = args;
8873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8874 if (!SWIG_IsOK(res1)) {
8875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8876 }
8877 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 delete arg1;
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_Py_Void();
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8893 PyObject *resultobj = 0;
8894 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8895 void *argp1 = 0 ;
8896 int res1 = 0 ;
8897 PyObject *swig_obj[1] ;
8898
8899 if (!args) SWIG_fail;
8900 swig_obj[0] = args;
8901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8902 if (!SWIG_IsOK(res1)) {
8903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8904 }
8905 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 (arg1)->close();
8909 wxPyEndAllowThreads(__tstate);
8910 if (PyErr_Occurred()) SWIG_fail;
8911 }
8912 resultobj = SWIG_Py_Void();
8913 return resultobj;
8914 fail:
8915 return NULL;
8916 }
8917
8918
8919 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8920 PyObject *resultobj = 0;
8921 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8922 void *argp1 = 0 ;
8923 int res1 = 0 ;
8924 PyObject *swig_obj[1] ;
8925
8926 if (!args) SWIG_fail;
8927 swig_obj[0] = args;
8928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8929 if (!SWIG_IsOK(res1)) {
8930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8931 }
8932 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8933 {
8934 PyThreadState* __tstate = wxPyBeginAllowThreads();
8935 (arg1)->flush();
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 resultobj = SWIG_Py_Void();
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8947 PyObject *resultobj = 0;
8948 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8949 bool result;
8950 void *argp1 = 0 ;
8951 int res1 = 0 ;
8952 PyObject *swig_obj[1] ;
8953
8954 if (!args) SWIG_fail;
8955 swig_obj[0] = args;
8956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8957 if (!SWIG_IsOK(res1)) {
8958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8959 }
8960 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8961 {
8962 PyThreadState* __tstate = wxPyBeginAllowThreads();
8963 result = (bool)(arg1)->eof();
8964 wxPyEndAllowThreads(__tstate);
8965 if (PyErr_Occurred()) SWIG_fail;
8966 }
8967 {
8968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8969 }
8970 return resultobj;
8971 fail:
8972 return NULL;
8973 }
8974
8975
8976 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8977 PyObject *resultobj = 0;
8978 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8979 int arg2 = (int) -1 ;
8980 PyObject *result = 0 ;
8981 void *argp1 = 0 ;
8982 int res1 = 0 ;
8983 int val2 ;
8984 int ecode2 = 0 ;
8985 PyObject * obj0 = 0 ;
8986 PyObject * obj1 = 0 ;
8987 char * kwnames[] = {
8988 (char *) "self",(char *) "size", NULL
8989 };
8990
8991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
8992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8993 if (!SWIG_IsOK(res1)) {
8994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8995 }
8996 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8997 if (obj1) {
8998 ecode2 = SWIG_AsVal_int(obj1, &val2);
8999 if (!SWIG_IsOK(ecode2)) {
9000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9001 }
9002 arg2 = static_cast< int >(val2);
9003 }
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 result = (PyObject *)(arg1)->read(arg2);
9007 wxPyEndAllowThreads(__tstate);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 resultobj = result;
9011 return resultobj;
9012 fail:
9013 return NULL;
9014 }
9015
9016
9017 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9018 PyObject *resultobj = 0;
9019 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9020 int arg2 = (int) -1 ;
9021 PyObject *result = 0 ;
9022 void *argp1 = 0 ;
9023 int res1 = 0 ;
9024 int val2 ;
9025 int ecode2 = 0 ;
9026 PyObject * obj0 = 0 ;
9027 PyObject * obj1 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "self",(char *) "size", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9038 if (obj1) {
9039 ecode2 = SWIG_AsVal_int(obj1, &val2);
9040 if (!SWIG_IsOK(ecode2)) {
9041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9042 }
9043 arg2 = static_cast< int >(val2);
9044 }
9045 {
9046 PyThreadState* __tstate = wxPyBeginAllowThreads();
9047 result = (PyObject *)(arg1)->readline(arg2);
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 resultobj = result;
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9059 PyObject *resultobj = 0;
9060 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9061 int arg2 = (int) -1 ;
9062 PyObject *result = 0 ;
9063 void *argp1 = 0 ;
9064 int res1 = 0 ;
9065 int val2 ;
9066 int ecode2 = 0 ;
9067 PyObject * obj0 = 0 ;
9068 PyObject * obj1 = 0 ;
9069 char * kwnames[] = {
9070 (char *) "self",(char *) "sizehint", NULL
9071 };
9072
9073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9075 if (!SWIG_IsOK(res1)) {
9076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9077 }
9078 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9079 if (obj1) {
9080 ecode2 = SWIG_AsVal_int(obj1, &val2);
9081 if (!SWIG_IsOK(ecode2)) {
9082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9083 }
9084 arg2 = static_cast< int >(val2);
9085 }
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 result = (PyObject *)(arg1)->readlines(arg2);
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 resultobj = result;
9093 return resultobj;
9094 fail:
9095 return NULL;
9096 }
9097
9098
9099 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9100 PyObject *resultobj = 0;
9101 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9102 int arg2 ;
9103 int arg3 = (int) 0 ;
9104 void *argp1 = 0 ;
9105 int res1 = 0 ;
9106 int val2 ;
9107 int ecode2 = 0 ;
9108 int val3 ;
9109 int ecode3 = 0 ;
9110 PyObject * obj0 = 0 ;
9111 PyObject * obj1 = 0 ;
9112 PyObject * obj2 = 0 ;
9113 char * kwnames[] = {
9114 (char *) "self",(char *) "offset",(char *) "whence", NULL
9115 };
9116
9117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9121 }
9122 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9123 ecode2 = SWIG_AsVal_int(obj1, &val2);
9124 if (!SWIG_IsOK(ecode2)) {
9125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9126 }
9127 arg2 = static_cast< int >(val2);
9128 if (obj2) {
9129 ecode3 = SWIG_AsVal_int(obj2, &val3);
9130 if (!SWIG_IsOK(ecode3)) {
9131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9132 }
9133 arg3 = static_cast< int >(val3);
9134 }
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 (arg1)->seek(arg2,arg3);
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 resultobj = SWIG_Py_Void();
9142 return resultobj;
9143 fail:
9144 return NULL;
9145 }
9146
9147
9148 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9149 PyObject *resultobj = 0;
9150 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9151 int result;
9152 void *argp1 = 0 ;
9153 int res1 = 0 ;
9154 PyObject *swig_obj[1] ;
9155
9156 if (!args) SWIG_fail;
9157 swig_obj[0] = args;
9158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9161 }
9162 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9163 {
9164 PyThreadState* __tstate = wxPyBeginAllowThreads();
9165 result = (int)(arg1)->tell();
9166 wxPyEndAllowThreads(__tstate);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 resultobj = SWIG_From_int(static_cast< int >(result));
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9177 PyObject *resultobj = 0;
9178 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9179 char result;
9180 void *argp1 = 0 ;
9181 int res1 = 0 ;
9182 PyObject *swig_obj[1] ;
9183
9184 if (!args) SWIG_fail;
9185 swig_obj[0] = args;
9186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9187 if (!SWIG_IsOK(res1)) {
9188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9189 }
9190 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9191 {
9192 PyThreadState* __tstate = wxPyBeginAllowThreads();
9193 result = (char)(arg1)->Peek();
9194 wxPyEndAllowThreads(__tstate);
9195 if (PyErr_Occurred()) SWIG_fail;
9196 }
9197 resultobj = SWIG_From_char(static_cast< char >(result));
9198 return resultobj;
9199 fail:
9200 return NULL;
9201 }
9202
9203
9204 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9205 PyObject *resultobj = 0;
9206 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9207 char result;
9208 void *argp1 = 0 ;
9209 int res1 = 0 ;
9210 PyObject *swig_obj[1] ;
9211
9212 if (!args) SWIG_fail;
9213 swig_obj[0] = args;
9214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9215 if (!SWIG_IsOK(res1)) {
9216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9217 }
9218 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 result = (char)(arg1)->GetC();
9222 wxPyEndAllowThreads(__tstate);
9223 if (PyErr_Occurred()) SWIG_fail;
9224 }
9225 resultobj = SWIG_From_char(static_cast< char >(result));
9226 return resultobj;
9227 fail:
9228 return NULL;
9229 }
9230
9231
9232 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9233 PyObject *resultobj = 0;
9234 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9235 size_t result;
9236 void *argp1 = 0 ;
9237 int res1 = 0 ;
9238 PyObject *swig_obj[1] ;
9239
9240 if (!args) SWIG_fail;
9241 swig_obj[0] = args;
9242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9245 }
9246 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 result = (size_t)(arg1)->LastRead();
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9261 PyObject *resultobj = 0;
9262 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9263 bool result;
9264 void *argp1 = 0 ;
9265 int res1 = 0 ;
9266 PyObject *swig_obj[1] ;
9267
9268 if (!args) SWIG_fail;
9269 swig_obj[0] = args;
9270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9271 if (!SWIG_IsOK(res1)) {
9272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9273 }
9274 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 result = (bool)(arg1)->CanRead();
9278 wxPyEndAllowThreads(__tstate);
9279 if (PyErr_Occurred()) SWIG_fail;
9280 }
9281 {
9282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9283 }
9284 return resultobj;
9285 fail:
9286 return NULL;
9287 }
9288
9289
9290 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9291 PyObject *resultobj = 0;
9292 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9293 bool result;
9294 void *argp1 = 0 ;
9295 int res1 = 0 ;
9296 PyObject *swig_obj[1] ;
9297
9298 if (!args) SWIG_fail;
9299 swig_obj[0] = args;
9300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9301 if (!SWIG_IsOK(res1)) {
9302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9303 }
9304 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (bool)(arg1)->Eof();
9308 wxPyEndAllowThreads(__tstate);
9309 if (PyErr_Occurred()) SWIG_fail;
9310 }
9311 {
9312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9313 }
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9321 PyObject *resultobj = 0;
9322 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9323 char arg2 ;
9324 bool result;
9325 void *argp1 = 0 ;
9326 int res1 = 0 ;
9327 char val2 ;
9328 int ecode2 = 0 ;
9329 PyObject * obj0 = 0 ;
9330 PyObject * obj1 = 0 ;
9331 char * kwnames[] = {
9332 (char *) "self",(char *) "c", NULL
9333 };
9334
9335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9337 if (!SWIG_IsOK(res1)) {
9338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9339 }
9340 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9341 ecode2 = SWIG_AsVal_char(obj1, &val2);
9342 if (!SWIG_IsOK(ecode2)) {
9343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9344 }
9345 arg2 = static_cast< char >(val2);
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (bool)(arg1)->Ungetch(arg2);
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 {
9353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9354 }
9355 return resultobj;
9356 fail:
9357 return NULL;
9358 }
9359
9360
9361 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9362 PyObject *resultobj = 0;
9363 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9364 long arg2 ;
9365 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9366 long result;
9367 void *argp1 = 0 ;
9368 int res1 = 0 ;
9369 long val2 ;
9370 int ecode2 = 0 ;
9371 int val3 ;
9372 int ecode3 = 0 ;
9373 PyObject * obj0 = 0 ;
9374 PyObject * obj1 = 0 ;
9375 PyObject * obj2 = 0 ;
9376 char * kwnames[] = {
9377 (char *) "self",(char *) "pos",(char *) "mode", NULL
9378 };
9379
9380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9384 }
9385 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9386 ecode2 = SWIG_AsVal_long(obj1, &val2);
9387 if (!SWIG_IsOK(ecode2)) {
9388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9389 }
9390 arg2 = static_cast< long >(val2);
9391 if (obj2) {
9392 ecode3 = SWIG_AsVal_int(obj2, &val3);
9393 if (!SWIG_IsOK(ecode3)) {
9394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9395 }
9396 arg3 = static_cast< wxSeekMode >(val3);
9397 }
9398 {
9399 PyThreadState* __tstate = wxPyBeginAllowThreads();
9400 result = (long)(arg1)->SeekI(arg2,arg3);
9401 wxPyEndAllowThreads(__tstate);
9402 if (PyErr_Occurred()) SWIG_fail;
9403 }
9404 resultobj = SWIG_From_long(static_cast< long >(result));
9405 return resultobj;
9406 fail:
9407 return NULL;
9408 }
9409
9410
9411 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9412 PyObject *resultobj = 0;
9413 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9414 long result;
9415 void *argp1 = 0 ;
9416 int res1 = 0 ;
9417 PyObject *swig_obj[1] ;
9418
9419 if (!args) SWIG_fail;
9420 swig_obj[0] = args;
9421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9422 if (!SWIG_IsOK(res1)) {
9423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9424 }
9425 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9426 {
9427 PyThreadState* __tstate = wxPyBeginAllowThreads();
9428 result = (long)(arg1)->TellI();
9429 wxPyEndAllowThreads(__tstate);
9430 if (PyErr_Occurred()) SWIG_fail;
9431 }
9432 resultobj = SWIG_From_long(static_cast< long >(result));
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9440 PyObject *obj;
9441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9442 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9443 return SWIG_Py_Void();
9444 }
9445
9446 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9447 return SWIG_Python_InitShadowInstance(args);
9448 }
9449
9450 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9451 PyObject *resultobj = 0;
9452 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9453 PyObject *arg2 = (PyObject *) 0 ;
9454 void *argp1 = 0 ;
9455 int res1 = 0 ;
9456 PyObject * obj0 = 0 ;
9457 PyObject * obj1 = 0 ;
9458 char * kwnames[] = {
9459 (char *) "self",(char *) "obj", NULL
9460 };
9461
9462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9464 if (!SWIG_IsOK(res1)) {
9465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9466 }
9467 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9468 arg2 = obj1;
9469 {
9470 PyThreadState* __tstate = wxPyBeginAllowThreads();
9471 wxOutputStream_write(arg1,arg2);
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 resultobj = SWIG_Py_Void();
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9483 PyObject *resultobj = 0;
9484 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9485 size_t result;
9486 void *argp1 = 0 ;
9487 int res1 = 0 ;
9488 PyObject *swig_obj[1] ;
9489
9490 if (!args) SWIG_fail;
9491 swig_obj[0] = args;
9492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9493 if (!SWIG_IsOK(res1)) {
9494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9495 }
9496 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9497 {
9498 PyThreadState* __tstate = wxPyBeginAllowThreads();
9499 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9500 wxPyEndAllowThreads(__tstate);
9501 if (PyErr_Occurred()) SWIG_fail;
9502 }
9503 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9504 return resultobj;
9505 fail:
9506 return NULL;
9507 }
9508
9509
9510 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9511 PyObject *obj;
9512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9513 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9514 return SWIG_Py_Void();
9515 }
9516
9517 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj = 0;
9519 wxInputStream *arg1 = (wxInputStream *) 0 ;
9520 wxString *arg2 = 0 ;
9521 wxString *arg3 = 0 ;
9522 wxString *arg4 = 0 ;
9523 wxDateTime arg5 ;
9524 wxFSFile *result = 0 ;
9525 wxPyInputStream *temp1 ;
9526 bool temp2 = false ;
9527 bool temp3 = false ;
9528 bool temp4 = false ;
9529 void *argp5 ;
9530 int res5 = 0 ;
9531 PyObject * obj0 = 0 ;
9532 PyObject * obj1 = 0 ;
9533 PyObject * obj2 = 0 ;
9534 PyObject * obj3 = 0 ;
9535 PyObject * obj4 = 0 ;
9536 char * kwnames[] = {
9537 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9538 };
9539
9540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9541 {
9542 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9543 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9544 } else {
9545 PyErr_Clear(); // clear the failure of the wxPyConvert above
9546 arg1 = wxPyCBInputStream_create(obj0, true);
9547 if (arg1 == NULL) {
9548 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9549 SWIG_fail;
9550 }
9551 }
9552 }
9553 {
9554 arg2 = wxString_in_helper(obj1);
9555 if (arg2 == NULL) SWIG_fail;
9556 temp2 = true;
9557 }
9558 {
9559 arg3 = wxString_in_helper(obj2);
9560 if (arg3 == NULL) SWIG_fail;
9561 temp3 = true;
9562 }
9563 {
9564 arg4 = wxString_in_helper(obj3);
9565 if (arg4 == NULL) SWIG_fail;
9566 temp4 = true;
9567 }
9568 {
9569 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9570 if (!SWIG_IsOK(res5)) {
9571 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9572 }
9573 if (!argp5) {
9574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9575 } else {
9576 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9577 arg5 = *temp;
9578 if (SWIG_IsNewObj(res5)) delete temp;
9579 }
9580 }
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 {
9588 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9589 }
9590 {
9591 if (temp2)
9592 delete arg2;
9593 }
9594 {
9595 if (temp3)
9596 delete arg3;
9597 }
9598 {
9599 if (temp4)
9600 delete arg4;
9601 }
9602 return resultobj;
9603 fail:
9604 {
9605 if (temp2)
9606 delete arg2;
9607 }
9608 {
9609 if (temp3)
9610 delete arg3;
9611 }
9612 {
9613 if (temp4)
9614 delete arg4;
9615 }
9616 return NULL;
9617 }
9618
9619
9620 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9621 PyObject *resultobj = 0;
9622 wxFSFile *arg1 = (wxFSFile *) 0 ;
9623 void *argp1 = 0 ;
9624 int res1 = 0 ;
9625 PyObject *swig_obj[1] ;
9626
9627 if (!args) SWIG_fail;
9628 swig_obj[0] = args;
9629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9630 if (!SWIG_IsOK(res1)) {
9631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9632 }
9633 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9634 {
9635 PyThreadState* __tstate = wxPyBeginAllowThreads();
9636 delete arg1;
9637
9638 wxPyEndAllowThreads(__tstate);
9639 if (PyErr_Occurred()) SWIG_fail;
9640 }
9641 resultobj = SWIG_Py_Void();
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
9648 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9649 PyObject *resultobj = 0;
9650 wxFSFile *arg1 = (wxFSFile *) 0 ;
9651 wxInputStream *result = 0 ;
9652 void *argp1 = 0 ;
9653 int res1 = 0 ;
9654 PyObject *swig_obj[1] ;
9655
9656 if (!args) SWIG_fail;
9657 swig_obj[0] = args;
9658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9659 if (!SWIG_IsOK(res1)) {
9660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9661 }
9662 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9663 {
9664 PyThreadState* __tstate = wxPyBeginAllowThreads();
9665 result = (wxInputStream *)(arg1)->GetStream();
9666 wxPyEndAllowThreads(__tstate);
9667 if (PyErr_Occurred()) SWIG_fail;
9668 }
9669 {
9670 wxPyInputStream * _ptr = NULL;
9671
9672 if (result) {
9673 _ptr = new wxPyInputStream(result);
9674 }
9675 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9676 }
9677 return resultobj;
9678 fail:
9679 return NULL;
9680 }
9681
9682
9683 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9684 PyObject *resultobj = 0;
9685 wxFSFile *arg1 = (wxFSFile *) 0 ;
9686 wxString *result = 0 ;
9687 void *argp1 = 0 ;
9688 int res1 = 0 ;
9689 PyObject *swig_obj[1] ;
9690
9691 if (!args) SWIG_fail;
9692 swig_obj[0] = args;
9693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9694 if (!SWIG_IsOK(res1)) {
9695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9696 }
9697 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 {
9701 wxString const &_result_ref = (arg1)->GetMimeType();
9702 result = (wxString *) &_result_ref;
9703 }
9704 wxPyEndAllowThreads(__tstate);
9705 if (PyErr_Occurred()) SWIG_fail;
9706 }
9707 {
9708 #if wxUSE_UNICODE
9709 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9710 #else
9711 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9712 #endif
9713 }
9714 return resultobj;
9715 fail:
9716 return NULL;
9717 }
9718
9719
9720 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9721 PyObject *resultobj = 0;
9722 wxFSFile *arg1 = (wxFSFile *) 0 ;
9723 wxString *result = 0 ;
9724 void *argp1 = 0 ;
9725 int res1 = 0 ;
9726 PyObject *swig_obj[1] ;
9727
9728 if (!args) SWIG_fail;
9729 swig_obj[0] = args;
9730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9731 if (!SWIG_IsOK(res1)) {
9732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9733 }
9734 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 {
9738 wxString const &_result_ref = (arg1)->GetLocation();
9739 result = (wxString *) &_result_ref;
9740 }
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 {
9745 #if wxUSE_UNICODE
9746 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9747 #else
9748 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9749 #endif
9750 }
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9758 PyObject *resultobj = 0;
9759 wxFSFile *arg1 = (wxFSFile *) 0 ;
9760 wxString *result = 0 ;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 PyObject *swig_obj[1] ;
9764
9765 if (!args) SWIG_fail;
9766 swig_obj[0] = args;
9767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9768 if (!SWIG_IsOK(res1)) {
9769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9770 }
9771 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9772 {
9773 PyThreadState* __tstate = wxPyBeginAllowThreads();
9774 {
9775 wxString const &_result_ref = (arg1)->GetAnchor();
9776 result = (wxString *) &_result_ref;
9777 }
9778 wxPyEndAllowThreads(__tstate);
9779 if (PyErr_Occurred()) SWIG_fail;
9780 }
9781 {
9782 #if wxUSE_UNICODE
9783 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9784 #else
9785 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9786 #endif
9787 }
9788 return resultobj;
9789 fail:
9790 return NULL;
9791 }
9792
9793
9794 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9795 PyObject *resultobj = 0;
9796 wxFSFile *arg1 = (wxFSFile *) 0 ;
9797 wxDateTime result;
9798 void *argp1 = 0 ;
9799 int res1 = 0 ;
9800 PyObject *swig_obj[1] ;
9801
9802 if (!args) SWIG_fail;
9803 swig_obj[0] = args;
9804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9805 if (!SWIG_IsOK(res1)) {
9806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9807 }
9808 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 result = (arg1)->GetModificationTime();
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9816 return resultobj;
9817 fail:
9818 return NULL;
9819 }
9820
9821
9822 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9823 PyObject *obj;
9824 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9825 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9826 return SWIG_Py_Void();
9827 }
9828
9829 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 return SWIG_Python_InitShadowInstance(args);
9831 }
9832
9833 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9834 PyObject *resultobj = 0;
9835 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9836 void *argp1 = 0 ;
9837 int res1 = 0 ;
9838 PyObject *swig_obj[1] ;
9839
9840 if (!args) SWIG_fail;
9841 swig_obj[0] = args;
9842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9843 if (!SWIG_IsOK(res1)) {
9844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9845 }
9846 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9847 {
9848 PyThreadState* __tstate = wxPyBeginAllowThreads();
9849 delete arg1;
9850
9851 wxPyEndAllowThreads(__tstate);
9852 if (PyErr_Occurred()) SWIG_fail;
9853 }
9854 resultobj = SWIG_Py_Void();
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9862 PyObject *obj;
9863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9864 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9865 return SWIG_Py_Void();
9866 }
9867
9868 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9869 PyObject *resultobj = 0;
9870 wxPyFileSystemHandler *result = 0 ;
9871
9872 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9873 {
9874 PyThreadState* __tstate = wxPyBeginAllowThreads();
9875 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9887 PyObject *resultobj = 0;
9888 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9889 PyObject *arg2 = (PyObject *) 0 ;
9890 PyObject *arg3 = (PyObject *) 0 ;
9891 void *argp1 = 0 ;
9892 int res1 = 0 ;
9893 PyObject * obj0 = 0 ;
9894 PyObject * obj1 = 0 ;
9895 PyObject * obj2 = 0 ;
9896 char * kwnames[] = {
9897 (char *) "self",(char *) "self",(char *) "_class", NULL
9898 };
9899
9900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9902 if (!SWIG_IsOK(res1)) {
9903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9904 }
9905 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9906 arg2 = obj1;
9907 arg3 = obj2;
9908 {
9909 PyThreadState* __tstate = wxPyBeginAllowThreads();
9910 (arg1)->_setCallbackInfo(arg2,arg3);
9911 wxPyEndAllowThreads(__tstate);
9912 if (PyErr_Occurred()) SWIG_fail;
9913 }
9914 resultobj = SWIG_Py_Void();
9915 return resultobj;
9916 fail:
9917 return NULL;
9918 }
9919
9920
9921 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9922 PyObject *resultobj = 0;
9923 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9924 wxString *arg2 = 0 ;
9925 bool result;
9926 void *argp1 = 0 ;
9927 int res1 = 0 ;
9928 bool temp2 = false ;
9929 PyObject * obj0 = 0 ;
9930 PyObject * obj1 = 0 ;
9931 char * kwnames[] = {
9932 (char *) "self",(char *) "location", NULL
9933 };
9934
9935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9937 if (!SWIG_IsOK(res1)) {
9938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9939 }
9940 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9941 {
9942 arg2 = wxString_in_helper(obj1);
9943 if (arg2 == NULL) SWIG_fail;
9944 temp2 = true;
9945 }
9946 {
9947 PyThreadState* __tstate = wxPyBeginAllowThreads();
9948 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9949 wxPyEndAllowThreads(__tstate);
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 {
9953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9954 }
9955 {
9956 if (temp2)
9957 delete arg2;
9958 }
9959 return resultobj;
9960 fail:
9961 {
9962 if (temp2)
9963 delete arg2;
9964 }
9965 return NULL;
9966 }
9967
9968
9969 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9970 PyObject *resultobj = 0;
9971 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9972 wxFileSystem *arg2 = 0 ;
9973 wxString *arg3 = 0 ;
9974 wxFSFile *result = 0 ;
9975 void *argp1 = 0 ;
9976 int res1 = 0 ;
9977 void *argp2 = 0 ;
9978 int res2 = 0 ;
9979 bool temp3 = false ;
9980 PyObject * obj0 = 0 ;
9981 PyObject * obj1 = 0 ;
9982 PyObject * obj2 = 0 ;
9983 char * kwnames[] = {
9984 (char *) "self",(char *) "fs",(char *) "location", NULL
9985 };
9986
9987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9989 if (!SWIG_IsOK(res1)) {
9990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9991 }
9992 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
9994 if (!SWIG_IsOK(res2)) {
9995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9996 }
9997 if (!argp2) {
9998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9999 }
10000 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10001 {
10002 arg3 = wxString_in_helper(obj2);
10003 if (arg3 == NULL) SWIG_fail;
10004 temp3 = true;
10005 }
10006 {
10007 PyThreadState* __tstate = wxPyBeginAllowThreads();
10008 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10009 wxPyEndAllowThreads(__tstate);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 {
10013 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10014 }
10015 {
10016 if (temp3)
10017 delete arg3;
10018 }
10019 return resultobj;
10020 fail:
10021 {
10022 if (temp3)
10023 delete arg3;
10024 }
10025 return NULL;
10026 }
10027
10028
10029 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj = 0;
10031 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10032 wxString *arg2 = 0 ;
10033 int arg3 = (int) 0 ;
10034 wxString result;
10035 void *argp1 = 0 ;
10036 int res1 = 0 ;
10037 bool temp2 = false ;
10038 int val3 ;
10039 int ecode3 = 0 ;
10040 PyObject * obj0 = 0 ;
10041 PyObject * obj1 = 0 ;
10042 PyObject * obj2 = 0 ;
10043 char * kwnames[] = {
10044 (char *) "self",(char *) "spec",(char *) "flags", NULL
10045 };
10046
10047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10049 if (!SWIG_IsOK(res1)) {
10050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10051 }
10052 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10053 {
10054 arg2 = wxString_in_helper(obj1);
10055 if (arg2 == NULL) SWIG_fail;
10056 temp2 = true;
10057 }
10058 if (obj2) {
10059 ecode3 = SWIG_AsVal_int(obj2, &val3);
10060 if (!SWIG_IsOK(ecode3)) {
10061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10062 }
10063 arg3 = static_cast< int >(val3);
10064 }
10065 {
10066 PyThreadState* __tstate = wxPyBeginAllowThreads();
10067 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 {
10072 #if wxUSE_UNICODE
10073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10074 #else
10075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10076 #endif
10077 }
10078 {
10079 if (temp2)
10080 delete arg2;
10081 }
10082 return resultobj;
10083 fail:
10084 {
10085 if (temp2)
10086 delete arg2;
10087 }
10088 return NULL;
10089 }
10090
10091
10092 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10093 PyObject *resultobj = 0;
10094 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10095 wxString result;
10096 void *argp1 = 0 ;
10097 int res1 = 0 ;
10098 PyObject *swig_obj[1] ;
10099
10100 if (!args) SWIG_fail;
10101 swig_obj[0] = args;
10102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10103 if (!SWIG_IsOK(res1)) {
10104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10105 }
10106 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10107 {
10108 PyThreadState* __tstate = wxPyBeginAllowThreads();
10109 result = (arg1)->FindNext();
10110 wxPyEndAllowThreads(__tstate);
10111 if (PyErr_Occurred()) SWIG_fail;
10112 }
10113 {
10114 #if wxUSE_UNICODE
10115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10116 #else
10117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10118 #endif
10119 }
10120 return resultobj;
10121 fail:
10122 return NULL;
10123 }
10124
10125
10126 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10127 PyObject *resultobj = 0;
10128 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10129 wxString *arg2 = 0 ;
10130 wxString result;
10131 void *argp1 = 0 ;
10132 int res1 = 0 ;
10133 bool temp2 = false ;
10134 PyObject * obj0 = 0 ;
10135 PyObject * obj1 = 0 ;
10136 char * kwnames[] = {
10137 (char *) "self",(char *) "location", NULL
10138 };
10139
10140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10142 if (!SWIG_IsOK(res1)) {
10143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10144 }
10145 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10146 {
10147 arg2 = wxString_in_helper(obj1);
10148 if (arg2 == NULL) SWIG_fail;
10149 temp2 = true;
10150 }
10151 {
10152 PyThreadState* __tstate = wxPyBeginAllowThreads();
10153 result = (arg1)->GetProtocol((wxString const &)*arg2);
10154 wxPyEndAllowThreads(__tstate);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 {
10158 #if wxUSE_UNICODE
10159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10160 #else
10161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10162 #endif
10163 }
10164 {
10165 if (temp2)
10166 delete arg2;
10167 }
10168 return resultobj;
10169 fail:
10170 {
10171 if (temp2)
10172 delete arg2;
10173 }
10174 return NULL;
10175 }
10176
10177
10178 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj = 0;
10180 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10181 wxString *arg2 = 0 ;
10182 wxString result;
10183 void *argp1 = 0 ;
10184 int res1 = 0 ;
10185 bool temp2 = false ;
10186 PyObject * obj0 = 0 ;
10187 PyObject * obj1 = 0 ;
10188 char * kwnames[] = {
10189 (char *) "self",(char *) "location", NULL
10190 };
10191
10192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10194 if (!SWIG_IsOK(res1)) {
10195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10196 }
10197 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10198 {
10199 arg2 = wxString_in_helper(obj1);
10200 if (arg2 == NULL) SWIG_fail;
10201 temp2 = true;
10202 }
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 {
10210 #if wxUSE_UNICODE
10211 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10212 #else
10213 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10214 #endif
10215 }
10216 {
10217 if (temp2)
10218 delete arg2;
10219 }
10220 return resultobj;
10221 fail:
10222 {
10223 if (temp2)
10224 delete arg2;
10225 }
10226 return NULL;
10227 }
10228
10229
10230 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10231 PyObject *resultobj = 0;
10232 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10233 wxString *arg2 = 0 ;
10234 wxString result;
10235 void *argp1 = 0 ;
10236 int res1 = 0 ;
10237 bool temp2 = false ;
10238 PyObject * obj0 = 0 ;
10239 PyObject * obj1 = 0 ;
10240 char * kwnames[] = {
10241 (char *) "self",(char *) "location", NULL
10242 };
10243
10244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10246 if (!SWIG_IsOK(res1)) {
10247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10248 }
10249 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10250 {
10251 arg2 = wxString_in_helper(obj1);
10252 if (arg2 == NULL) SWIG_fail;
10253 temp2 = true;
10254 }
10255 {
10256 PyThreadState* __tstate = wxPyBeginAllowThreads();
10257 result = (arg1)->GetAnchor((wxString const &)*arg2);
10258 wxPyEndAllowThreads(__tstate);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 {
10262 #if wxUSE_UNICODE
10263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10264 #else
10265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10266 #endif
10267 }
10268 {
10269 if (temp2)
10270 delete arg2;
10271 }
10272 return resultobj;
10273 fail:
10274 {
10275 if (temp2)
10276 delete arg2;
10277 }
10278 return NULL;
10279 }
10280
10281
10282 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj = 0;
10284 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10285 wxString *arg2 = 0 ;
10286 wxString result;
10287 void *argp1 = 0 ;
10288 int res1 = 0 ;
10289 bool temp2 = false ;
10290 PyObject * obj0 = 0 ;
10291 PyObject * obj1 = 0 ;
10292 char * kwnames[] = {
10293 (char *) "self",(char *) "location", NULL
10294 };
10295
10296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10298 if (!SWIG_IsOK(res1)) {
10299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10300 }
10301 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10302 {
10303 arg2 = wxString_in_helper(obj1);
10304 if (arg2 == NULL) SWIG_fail;
10305 temp2 = true;
10306 }
10307 {
10308 PyThreadState* __tstate = wxPyBeginAllowThreads();
10309 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10310 wxPyEndAllowThreads(__tstate);
10311 if (PyErr_Occurred()) SWIG_fail;
10312 }
10313 {
10314 #if wxUSE_UNICODE
10315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10316 #else
10317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10318 #endif
10319 }
10320 {
10321 if (temp2)
10322 delete arg2;
10323 }
10324 return resultobj;
10325 fail:
10326 {
10327 if (temp2)
10328 delete arg2;
10329 }
10330 return NULL;
10331 }
10332
10333
10334 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj = 0;
10336 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10337 wxString *arg2 = 0 ;
10338 wxString result;
10339 void *argp1 = 0 ;
10340 int res1 = 0 ;
10341 bool temp2 = false ;
10342 PyObject * obj0 = 0 ;
10343 PyObject * obj1 = 0 ;
10344 char * kwnames[] = {
10345 (char *) "self",(char *) "location", NULL
10346 };
10347
10348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10350 if (!SWIG_IsOK(res1)) {
10351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10352 }
10353 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10354 {
10355 arg2 = wxString_in_helper(obj1);
10356 if (arg2 == NULL) SWIG_fail;
10357 temp2 = true;
10358 }
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10362 wxPyEndAllowThreads(__tstate);
10363 if (PyErr_Occurred()) SWIG_fail;
10364 }
10365 {
10366 #if wxUSE_UNICODE
10367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10368 #else
10369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10370 #endif
10371 }
10372 {
10373 if (temp2)
10374 delete arg2;
10375 }
10376 return resultobj;
10377 fail:
10378 {
10379 if (temp2)
10380 delete arg2;
10381 }
10382 return NULL;
10383 }
10384
10385
10386 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10387 PyObject *obj;
10388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10389 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10390 return SWIG_Py_Void();
10391 }
10392
10393 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10394 return SWIG_Python_InitShadowInstance(args);
10395 }
10396
10397 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10398 PyObject *resultobj = 0;
10399 wxFileSystem *result = 0 ;
10400
10401 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10402 {
10403 PyThreadState* __tstate = wxPyBeginAllowThreads();
10404 result = (wxFileSystem *)new wxFileSystem();
10405 wxPyEndAllowThreads(__tstate);
10406 if (PyErr_Occurred()) SWIG_fail;
10407 }
10408 {
10409 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10410 }
10411 return resultobj;
10412 fail:
10413 return NULL;
10414 }
10415
10416
10417 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10418 PyObject *resultobj = 0;
10419 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 PyObject *swig_obj[1] ;
10423
10424 if (!args) SWIG_fail;
10425 swig_obj[0] = args;
10426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10427 if (!SWIG_IsOK(res1)) {
10428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10429 }
10430 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10431 {
10432 PyThreadState* __tstate = wxPyBeginAllowThreads();
10433 delete arg1;
10434
10435 wxPyEndAllowThreads(__tstate);
10436 if (PyErr_Occurred()) SWIG_fail;
10437 }
10438 resultobj = SWIG_Py_Void();
10439 return resultobj;
10440 fail:
10441 return NULL;
10442 }
10443
10444
10445 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10446 PyObject *resultobj = 0;
10447 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10448 wxString *arg2 = 0 ;
10449 bool arg3 = (bool) false ;
10450 void *argp1 = 0 ;
10451 int res1 = 0 ;
10452 bool temp2 = false ;
10453 bool val3 ;
10454 int ecode3 = 0 ;
10455 PyObject * obj0 = 0 ;
10456 PyObject * obj1 = 0 ;
10457 PyObject * obj2 = 0 ;
10458 char * kwnames[] = {
10459 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10460 };
10461
10462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10464 if (!SWIG_IsOK(res1)) {
10465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10466 }
10467 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10468 {
10469 arg2 = wxString_in_helper(obj1);
10470 if (arg2 == NULL) SWIG_fail;
10471 temp2 = true;
10472 }
10473 if (obj2) {
10474 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10475 if (!SWIG_IsOK(ecode3)) {
10476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10477 }
10478 arg3 = static_cast< bool >(val3);
10479 }
10480 {
10481 PyThreadState* __tstate = wxPyBeginAllowThreads();
10482 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10483 wxPyEndAllowThreads(__tstate);
10484 if (PyErr_Occurred()) SWIG_fail;
10485 }
10486 resultobj = SWIG_Py_Void();
10487 {
10488 if (temp2)
10489 delete arg2;
10490 }
10491 return resultobj;
10492 fail:
10493 {
10494 if (temp2)
10495 delete arg2;
10496 }
10497 return NULL;
10498 }
10499
10500
10501 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10502 PyObject *resultobj = 0;
10503 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10504 wxString result;
10505 void *argp1 = 0 ;
10506 int res1 = 0 ;
10507 PyObject *swig_obj[1] ;
10508
10509 if (!args) SWIG_fail;
10510 swig_obj[0] = args;
10511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10512 if (!SWIG_IsOK(res1)) {
10513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10514 }
10515 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10516 {
10517 PyThreadState* __tstate = wxPyBeginAllowThreads();
10518 result = (arg1)->GetPath();
10519 wxPyEndAllowThreads(__tstate);
10520 if (PyErr_Occurred()) SWIG_fail;
10521 }
10522 {
10523 #if wxUSE_UNICODE
10524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10525 #else
10526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10527 #endif
10528 }
10529 return resultobj;
10530 fail:
10531 return NULL;
10532 }
10533
10534
10535 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10536 PyObject *resultobj = 0;
10537 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10538 wxString *arg2 = 0 ;
10539 wxFSFile *result = 0 ;
10540 void *argp1 = 0 ;
10541 int res1 = 0 ;
10542 bool temp2 = false ;
10543 PyObject * obj0 = 0 ;
10544 PyObject * obj1 = 0 ;
10545 char * kwnames[] = {
10546 (char *) "self",(char *) "location", NULL
10547 };
10548
10549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10553 }
10554 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10555 {
10556 arg2 = wxString_in_helper(obj1);
10557 if (arg2 == NULL) SWIG_fail;
10558 temp2 = true;
10559 }
10560 {
10561 PyThreadState* __tstate = wxPyBeginAllowThreads();
10562 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10563 wxPyEndAllowThreads(__tstate);
10564 if (PyErr_Occurred()) SWIG_fail;
10565 }
10566 {
10567 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10568 }
10569 {
10570 if (temp2)
10571 delete arg2;
10572 }
10573 return resultobj;
10574 fail:
10575 {
10576 if (temp2)
10577 delete arg2;
10578 }
10579 return NULL;
10580 }
10581
10582
10583 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10584 PyObject *resultobj = 0;
10585 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10586 wxString *arg2 = 0 ;
10587 int arg3 = (int) 0 ;
10588 wxString result;
10589 void *argp1 = 0 ;
10590 int res1 = 0 ;
10591 bool temp2 = false ;
10592 int val3 ;
10593 int ecode3 = 0 ;
10594 PyObject * obj0 = 0 ;
10595 PyObject * obj1 = 0 ;
10596 PyObject * obj2 = 0 ;
10597 char * kwnames[] = {
10598 (char *) "self",(char *) "spec",(char *) "flags", NULL
10599 };
10600
10601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10603 if (!SWIG_IsOK(res1)) {
10604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10605 }
10606 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10607 {
10608 arg2 = wxString_in_helper(obj1);
10609 if (arg2 == NULL) SWIG_fail;
10610 temp2 = true;
10611 }
10612 if (obj2) {
10613 ecode3 = SWIG_AsVal_int(obj2, &val3);
10614 if (!SWIG_IsOK(ecode3)) {
10615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10616 }
10617 arg3 = static_cast< int >(val3);
10618 }
10619 {
10620 PyThreadState* __tstate = wxPyBeginAllowThreads();
10621 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 {
10626 #if wxUSE_UNICODE
10627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10628 #else
10629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10630 #endif
10631 }
10632 {
10633 if (temp2)
10634 delete arg2;
10635 }
10636 return resultobj;
10637 fail:
10638 {
10639 if (temp2)
10640 delete arg2;
10641 }
10642 return NULL;
10643 }
10644
10645
10646 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10647 PyObject *resultobj = 0;
10648 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10649 wxString result;
10650 void *argp1 = 0 ;
10651 int res1 = 0 ;
10652 PyObject *swig_obj[1] ;
10653
10654 if (!args) SWIG_fail;
10655 swig_obj[0] = args;
10656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10657 if (!SWIG_IsOK(res1)) {
10658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10659 }
10660 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10661 {
10662 PyThreadState* __tstate = wxPyBeginAllowThreads();
10663 result = (arg1)->FindNext();
10664 wxPyEndAllowThreads(__tstate);
10665 if (PyErr_Occurred()) SWIG_fail;
10666 }
10667 {
10668 #if wxUSE_UNICODE
10669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10670 #else
10671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10672 #endif
10673 }
10674 return resultobj;
10675 fail:
10676 return NULL;
10677 }
10678
10679
10680 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj = 0;
10682 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10683 int res1 = 0 ;
10684 PyObject * obj0 = 0 ;
10685 char * kwnames[] = {
10686 (char *) "handler", NULL
10687 };
10688
10689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10690 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10691 if (!SWIG_IsOK(res1)) {
10692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10693 }
10694 {
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 wxFileSystem::AddHandler(arg1);
10697 wxPyEndAllowThreads(__tstate);
10698 if (PyErr_Occurred()) SWIG_fail;
10699 }
10700 resultobj = SWIG_Py_Void();
10701 return resultobj;
10702 fail:
10703 return NULL;
10704 }
10705
10706
10707 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10708 PyObject *resultobj = 0;
10709
10710 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10711 {
10712 PyThreadState* __tstate = wxPyBeginAllowThreads();
10713 wxFileSystem::CleanUpHandlers();
10714 wxPyEndAllowThreads(__tstate);
10715 if (PyErr_Occurred()) SWIG_fail;
10716 }
10717 resultobj = SWIG_Py_Void();
10718 return resultobj;
10719 fail:
10720 return NULL;
10721 }
10722
10723
10724 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10725 PyObject *resultobj = 0;
10726 wxString *arg1 = 0 ;
10727 wxString result;
10728 bool temp1 = false ;
10729 PyObject * obj0 = 0 ;
10730 char * kwnames[] = {
10731 (char *) "filename", NULL
10732 };
10733
10734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10735 {
10736 arg1 = wxString_in_helper(obj0);
10737 if (arg1 == NULL) SWIG_fail;
10738 temp1 = true;
10739 }
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10743 wxPyEndAllowThreads(__tstate);
10744 if (PyErr_Occurred()) SWIG_fail;
10745 }
10746 {
10747 #if wxUSE_UNICODE
10748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10749 #else
10750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10751 #endif
10752 }
10753 {
10754 if (temp1)
10755 delete arg1;
10756 }
10757 return resultobj;
10758 fail:
10759 {
10760 if (temp1)
10761 delete arg1;
10762 }
10763 return NULL;
10764 }
10765
10766
10767 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10768 PyObject *resultobj = 0;
10769 wxString *arg1 = 0 ;
10770 wxString result;
10771 bool temp1 = false ;
10772 PyObject * obj0 = 0 ;
10773 char * kwnames[] = {
10774 (char *) "url", NULL
10775 };
10776
10777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10778 {
10779 arg1 = wxString_in_helper(obj0);
10780 if (arg1 == NULL) SWIG_fail;
10781 temp1 = true;
10782 }
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 {
10790 #if wxUSE_UNICODE
10791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10792 #else
10793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10794 #endif
10795 }
10796 {
10797 if (temp1)
10798 delete arg1;
10799 }
10800 return resultobj;
10801 fail:
10802 {
10803 if (temp1)
10804 delete arg1;
10805 }
10806 return NULL;
10807 }
10808
10809
10810 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10811 PyObject *obj;
10812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10813 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10814 return SWIG_Py_Void();
10815 }
10816
10817 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10818 return SWIG_Python_InitShadowInstance(args);
10819 }
10820
10821 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10822 PyObject *resultobj = 0;
10823 wxInternetFSHandler *result = 0 ;
10824
10825 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10826 {
10827 PyThreadState* __tstate = wxPyBeginAllowThreads();
10828 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10829 wxPyEndAllowThreads(__tstate);
10830 if (PyErr_Occurred()) SWIG_fail;
10831 }
10832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10833 return resultobj;
10834 fail:
10835 return NULL;
10836 }
10837
10838
10839 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10840 PyObject *resultobj = 0;
10841 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10842 wxString *arg2 = 0 ;
10843 bool result;
10844 void *argp1 = 0 ;
10845 int res1 = 0 ;
10846 bool temp2 = false ;
10847 PyObject * obj0 = 0 ;
10848 PyObject * obj1 = 0 ;
10849 char * kwnames[] = {
10850 (char *) "self",(char *) "location", NULL
10851 };
10852
10853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10855 if (!SWIG_IsOK(res1)) {
10856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10857 }
10858 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10859 {
10860 arg2 = wxString_in_helper(obj1);
10861 if (arg2 == NULL) SWIG_fail;
10862 temp2 = true;
10863 }
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 {
10871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10872 }
10873 {
10874 if (temp2)
10875 delete arg2;
10876 }
10877 return resultobj;
10878 fail:
10879 {
10880 if (temp2)
10881 delete arg2;
10882 }
10883 return NULL;
10884 }
10885
10886
10887 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10888 PyObject *resultobj = 0;
10889 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10890 wxFileSystem *arg2 = 0 ;
10891 wxString *arg3 = 0 ;
10892 wxFSFile *result = 0 ;
10893 void *argp1 = 0 ;
10894 int res1 = 0 ;
10895 void *argp2 = 0 ;
10896 int res2 = 0 ;
10897 bool temp3 = false ;
10898 PyObject * obj0 = 0 ;
10899 PyObject * obj1 = 0 ;
10900 PyObject * obj2 = 0 ;
10901 char * kwnames[] = {
10902 (char *) "self",(char *) "fs",(char *) "location", NULL
10903 };
10904
10905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10909 }
10910 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10911 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10912 if (!SWIG_IsOK(res2)) {
10913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10914 }
10915 if (!argp2) {
10916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10917 }
10918 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10919 {
10920 arg3 = wxString_in_helper(obj2);
10921 if (arg3 == NULL) SWIG_fail;
10922 temp3 = true;
10923 }
10924 {
10925 PyThreadState* __tstate = wxPyBeginAllowThreads();
10926 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10927 wxPyEndAllowThreads(__tstate);
10928 if (PyErr_Occurred()) SWIG_fail;
10929 }
10930 {
10931 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10932 }
10933 {
10934 if (temp3)
10935 delete arg3;
10936 }
10937 return resultobj;
10938 fail:
10939 {
10940 if (temp3)
10941 delete arg3;
10942 }
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10948 PyObject *obj;
10949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10950 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
10951 return SWIG_Py_Void();
10952 }
10953
10954 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10955 return SWIG_Python_InitShadowInstance(args);
10956 }
10957
10958 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10959 PyObject *resultobj = 0;
10960 wxZipFSHandler *result = 0 ;
10961
10962 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 result = (wxZipFSHandler *)new wxZipFSHandler();
10966 wxPyEndAllowThreads(__tstate);
10967 if (PyErr_Occurred()) SWIG_fail;
10968 }
10969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
10970 return resultobj;
10971 fail:
10972 return NULL;
10973 }
10974
10975
10976 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10977 PyObject *resultobj = 0;
10978 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10979 wxString *arg2 = 0 ;
10980 bool result;
10981 void *argp1 = 0 ;
10982 int res1 = 0 ;
10983 bool temp2 = false ;
10984 PyObject * obj0 = 0 ;
10985 PyObject * obj1 = 0 ;
10986 char * kwnames[] = {
10987 (char *) "self",(char *) "location", NULL
10988 };
10989
10990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
10992 if (!SWIG_IsOK(res1)) {
10993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
10994 }
10995 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
10996 {
10997 arg2 = wxString_in_helper(obj1);
10998 if (arg2 == NULL) SWIG_fail;
10999 temp2 = true;
11000 }
11001 {
11002 PyThreadState* __tstate = wxPyBeginAllowThreads();
11003 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11004 wxPyEndAllowThreads(__tstate);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 {
11008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11009 }
11010 {
11011 if (temp2)
11012 delete arg2;
11013 }
11014 return resultobj;
11015 fail:
11016 {
11017 if (temp2)
11018 delete arg2;
11019 }
11020 return NULL;
11021 }
11022
11023
11024 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11025 PyObject *resultobj = 0;
11026 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11027 wxFileSystem *arg2 = 0 ;
11028 wxString *arg3 = 0 ;
11029 wxFSFile *result = 0 ;
11030 void *argp1 = 0 ;
11031 int res1 = 0 ;
11032 void *argp2 = 0 ;
11033 int res2 = 0 ;
11034 bool temp3 = false ;
11035 PyObject * obj0 = 0 ;
11036 PyObject * obj1 = 0 ;
11037 PyObject * obj2 = 0 ;
11038 char * kwnames[] = {
11039 (char *) "self",(char *) "fs",(char *) "location", NULL
11040 };
11041
11042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11044 if (!SWIG_IsOK(res1)) {
11045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11046 }
11047 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11048 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11049 if (!SWIG_IsOK(res2)) {
11050 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11051 }
11052 if (!argp2) {
11053 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11054 }
11055 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11056 {
11057 arg3 = wxString_in_helper(obj2);
11058 if (arg3 == NULL) SWIG_fail;
11059 temp3 = true;
11060 }
11061 {
11062 PyThreadState* __tstate = wxPyBeginAllowThreads();
11063 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 {
11068 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11069 }
11070 {
11071 if (temp3)
11072 delete arg3;
11073 }
11074 return resultobj;
11075 fail:
11076 {
11077 if (temp3)
11078 delete arg3;
11079 }
11080 return NULL;
11081 }
11082
11083
11084 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11085 PyObject *resultobj = 0;
11086 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11087 wxString *arg2 = 0 ;
11088 int arg3 = (int) 0 ;
11089 wxString result;
11090 void *argp1 = 0 ;
11091 int res1 = 0 ;
11092 bool temp2 = false ;
11093 int val3 ;
11094 int ecode3 = 0 ;
11095 PyObject * obj0 = 0 ;
11096 PyObject * obj1 = 0 ;
11097 PyObject * obj2 = 0 ;
11098 char * kwnames[] = {
11099 (char *) "self",(char *) "spec",(char *) "flags", NULL
11100 };
11101
11102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11104 if (!SWIG_IsOK(res1)) {
11105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11106 }
11107 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11108 {
11109 arg2 = wxString_in_helper(obj1);
11110 if (arg2 == NULL) SWIG_fail;
11111 temp2 = true;
11112 }
11113 if (obj2) {
11114 ecode3 = SWIG_AsVal_int(obj2, &val3);
11115 if (!SWIG_IsOK(ecode3)) {
11116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11117 }
11118 arg3 = static_cast< int >(val3);
11119 }
11120 {
11121 PyThreadState* __tstate = wxPyBeginAllowThreads();
11122 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11123 wxPyEndAllowThreads(__tstate);
11124 if (PyErr_Occurred()) SWIG_fail;
11125 }
11126 {
11127 #if wxUSE_UNICODE
11128 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11129 #else
11130 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11131 #endif
11132 }
11133 {
11134 if (temp2)
11135 delete arg2;
11136 }
11137 return resultobj;
11138 fail:
11139 {
11140 if (temp2)
11141 delete arg2;
11142 }
11143 return NULL;
11144 }
11145
11146
11147 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11148 PyObject *resultobj = 0;
11149 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11150 wxString result;
11151 void *argp1 = 0 ;
11152 int res1 = 0 ;
11153 PyObject *swig_obj[1] ;
11154
11155 if (!args) SWIG_fail;
11156 swig_obj[0] = args;
11157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11158 if (!SWIG_IsOK(res1)) {
11159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11160 }
11161 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11162 {
11163 PyThreadState* __tstate = wxPyBeginAllowThreads();
11164 result = (arg1)->FindNext();
11165 wxPyEndAllowThreads(__tstate);
11166 if (PyErr_Occurred()) SWIG_fail;
11167 }
11168 {
11169 #if wxUSE_UNICODE
11170 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11171 #else
11172 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11173 #endif
11174 }
11175 return resultobj;
11176 fail:
11177 return NULL;
11178 }
11179
11180
11181 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11182 PyObject *obj;
11183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11184 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11185 return SWIG_Py_Void();
11186 }
11187
11188 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11189 return SWIG_Python_InitShadowInstance(args);
11190 }
11191
11192 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11193 PyObject *resultobj = 0;
11194 wxString *arg1 = 0 ;
11195 wxImage *arg2 = 0 ;
11196 long arg3 ;
11197 bool temp1 = false ;
11198 void *argp2 = 0 ;
11199 int res2 = 0 ;
11200 long val3 ;
11201 int ecode3 = 0 ;
11202 PyObject * obj0 = 0 ;
11203 PyObject * obj1 = 0 ;
11204 PyObject * obj2 = 0 ;
11205 char * kwnames[] = {
11206 (char *) "filename",(char *) "image",(char *) "type", NULL
11207 };
11208
11209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11210 {
11211 arg1 = wxString_in_helper(obj0);
11212 if (arg1 == NULL) SWIG_fail;
11213 temp1 = true;
11214 }
11215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11216 if (!SWIG_IsOK(res2)) {
11217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11218 }
11219 if (!argp2) {
11220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11221 }
11222 arg2 = reinterpret_cast< wxImage * >(argp2);
11223 ecode3 = SWIG_AsVal_long(obj2, &val3);
11224 if (!SWIG_IsOK(ecode3)) {
11225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11226 }
11227 arg3 = static_cast< long >(val3);
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 resultobj = SWIG_Py_Void();
11235 {
11236 if (temp1)
11237 delete arg1;
11238 }
11239 return resultobj;
11240 fail:
11241 {
11242 if (temp1)
11243 delete arg1;
11244 }
11245 return NULL;
11246 }
11247
11248
11249 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11250 PyObject *resultobj = 0;
11251 wxString *arg1 = 0 ;
11252 wxBitmap *arg2 = 0 ;
11253 long arg3 ;
11254 bool temp1 = false ;
11255 void *argp2 = 0 ;
11256 int res2 = 0 ;
11257 long val3 ;
11258 int ecode3 = 0 ;
11259 PyObject * obj0 = 0 ;
11260 PyObject * obj1 = 0 ;
11261 PyObject * obj2 = 0 ;
11262 char * kwnames[] = {
11263 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11264 };
11265
11266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11267 {
11268 arg1 = wxString_in_helper(obj0);
11269 if (arg1 == NULL) SWIG_fail;
11270 temp1 = true;
11271 }
11272 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11273 if (!SWIG_IsOK(res2)) {
11274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11275 }
11276 if (!argp2) {
11277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11278 }
11279 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11280 ecode3 = SWIG_AsVal_long(obj2, &val3);
11281 if (!SWIG_IsOK(ecode3)) {
11282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11283 }
11284 arg3 = static_cast< long >(val3);
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11288 wxPyEndAllowThreads(__tstate);
11289 if (PyErr_Occurred()) SWIG_fail;
11290 }
11291 resultobj = SWIG_Py_Void();
11292 {
11293 if (temp1)
11294 delete arg1;
11295 }
11296 return resultobj;
11297 fail:
11298 {
11299 if (temp1)
11300 delete arg1;
11301 }
11302 return NULL;
11303 }
11304
11305
11306 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11307 PyObject *resultobj = 0;
11308 wxString *arg1 = 0 ;
11309 PyObject *arg2 = (PyObject *) 0 ;
11310 bool temp1 = false ;
11311 PyObject * obj0 = 0 ;
11312 PyObject * obj1 = 0 ;
11313 char * kwnames[] = {
11314 (char *) "filename",(char *) "data", NULL
11315 };
11316
11317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11318 {
11319 arg1 = wxString_in_helper(obj0);
11320 if (arg1 == NULL) SWIG_fail;
11321 temp1 = true;
11322 }
11323 arg2 = obj1;
11324 {
11325 PyThreadState* __tstate = wxPyBeginAllowThreads();
11326 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11327 wxPyEndAllowThreads(__tstate);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 }
11330 resultobj = SWIG_Py_Void();
11331 {
11332 if (temp1)
11333 delete arg1;
11334 }
11335 return resultobj;
11336 fail:
11337 {
11338 if (temp1)
11339 delete arg1;
11340 }
11341 return NULL;
11342 }
11343
11344
11345 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11346 PyObject *resultobj = 0;
11347 wxMemoryFSHandler *result = 0 ;
11348
11349 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11350 {
11351 PyThreadState* __tstate = wxPyBeginAllowThreads();
11352 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11353 wxPyEndAllowThreads(__tstate);
11354 if (PyErr_Occurred()) SWIG_fail;
11355 }
11356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj = 0;
11365 wxString *arg1 = 0 ;
11366 bool temp1 = false ;
11367 PyObject * obj0 = 0 ;
11368 char * kwnames[] = {
11369 (char *) "filename", NULL
11370 };
11371
11372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11373 {
11374 arg1 = wxString_in_helper(obj0);
11375 if (arg1 == NULL) SWIG_fail;
11376 temp1 = true;
11377 }
11378 {
11379 PyThreadState* __tstate = wxPyBeginAllowThreads();
11380 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11381 wxPyEndAllowThreads(__tstate);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 resultobj = SWIG_Py_Void();
11385 {
11386 if (temp1)
11387 delete arg1;
11388 }
11389 return resultobj;
11390 fail:
11391 {
11392 if (temp1)
11393 delete arg1;
11394 }
11395 return NULL;
11396 }
11397
11398
11399 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11400 PyObject *resultobj = 0;
11401 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11402 wxString *arg2 = 0 ;
11403 bool result;
11404 void *argp1 = 0 ;
11405 int res1 = 0 ;
11406 bool temp2 = false ;
11407 PyObject * obj0 = 0 ;
11408 PyObject * obj1 = 0 ;
11409 char * kwnames[] = {
11410 (char *) "self",(char *) "location", NULL
11411 };
11412
11413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11415 if (!SWIG_IsOK(res1)) {
11416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11417 }
11418 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11419 {
11420 arg2 = wxString_in_helper(obj1);
11421 if (arg2 == NULL) SWIG_fail;
11422 temp2 = true;
11423 }
11424 {
11425 PyThreadState* __tstate = wxPyBeginAllowThreads();
11426 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 {
11431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11432 }
11433 {
11434 if (temp2)
11435 delete arg2;
11436 }
11437 return resultobj;
11438 fail:
11439 {
11440 if (temp2)
11441 delete arg2;
11442 }
11443 return NULL;
11444 }
11445
11446
11447 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11448 PyObject *resultobj = 0;
11449 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11450 wxFileSystem *arg2 = 0 ;
11451 wxString *arg3 = 0 ;
11452 wxFSFile *result = 0 ;
11453 void *argp1 = 0 ;
11454 int res1 = 0 ;
11455 void *argp2 = 0 ;
11456 int res2 = 0 ;
11457 bool temp3 = false ;
11458 PyObject * obj0 = 0 ;
11459 PyObject * obj1 = 0 ;
11460 PyObject * obj2 = 0 ;
11461 char * kwnames[] = {
11462 (char *) "self",(char *) "fs",(char *) "location", NULL
11463 };
11464
11465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11467 if (!SWIG_IsOK(res1)) {
11468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11469 }
11470 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11471 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11472 if (!SWIG_IsOK(res2)) {
11473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11474 }
11475 if (!argp2) {
11476 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11477 }
11478 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11479 {
11480 arg3 = wxString_in_helper(obj2);
11481 if (arg3 == NULL) SWIG_fail;
11482 temp3 = true;
11483 }
11484 {
11485 PyThreadState* __tstate = wxPyBeginAllowThreads();
11486 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11487 wxPyEndAllowThreads(__tstate);
11488 if (PyErr_Occurred()) SWIG_fail;
11489 }
11490 {
11491 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11492 }
11493 {
11494 if (temp3)
11495 delete arg3;
11496 }
11497 return resultobj;
11498 fail:
11499 {
11500 if (temp3)
11501 delete arg3;
11502 }
11503 return NULL;
11504 }
11505
11506
11507 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj = 0;
11509 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11510 wxString *arg2 = 0 ;
11511 int arg3 = (int) 0 ;
11512 wxString result;
11513 void *argp1 = 0 ;
11514 int res1 = 0 ;
11515 bool temp2 = false ;
11516 int val3 ;
11517 int ecode3 = 0 ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 PyObject * obj2 = 0 ;
11521 char * kwnames[] = {
11522 (char *) "self",(char *) "spec",(char *) "flags", NULL
11523 };
11524
11525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11527 if (!SWIG_IsOK(res1)) {
11528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11529 }
11530 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11531 {
11532 arg2 = wxString_in_helper(obj1);
11533 if (arg2 == NULL) SWIG_fail;
11534 temp2 = true;
11535 }
11536 if (obj2) {
11537 ecode3 = SWIG_AsVal_int(obj2, &val3);
11538 if (!SWIG_IsOK(ecode3)) {
11539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11540 }
11541 arg3 = static_cast< int >(val3);
11542 }
11543 {
11544 PyThreadState* __tstate = wxPyBeginAllowThreads();
11545 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11546 wxPyEndAllowThreads(__tstate);
11547 if (PyErr_Occurred()) SWIG_fail;
11548 }
11549 {
11550 #if wxUSE_UNICODE
11551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11552 #else
11553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11554 #endif
11555 }
11556 {
11557 if (temp2)
11558 delete arg2;
11559 }
11560 return resultobj;
11561 fail:
11562 {
11563 if (temp2)
11564 delete arg2;
11565 }
11566 return NULL;
11567 }
11568
11569
11570 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11571 PyObject *resultobj = 0;
11572 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11573 wxString result;
11574 void *argp1 = 0 ;
11575 int res1 = 0 ;
11576 PyObject *swig_obj[1] ;
11577
11578 if (!args) SWIG_fail;
11579 swig_obj[0] = args;
11580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11581 if (!SWIG_IsOK(res1)) {
11582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11583 }
11584 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11585 {
11586 PyThreadState* __tstate = wxPyBeginAllowThreads();
11587 result = (arg1)->FindNext();
11588 wxPyEndAllowThreads(__tstate);
11589 if (PyErr_Occurred()) SWIG_fail;
11590 }
11591 {
11592 #if wxUSE_UNICODE
11593 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11594 #else
11595 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11596 #endif
11597 }
11598 return resultobj;
11599 fail:
11600 return NULL;
11601 }
11602
11603
11604 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11605 PyObject *obj;
11606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11607 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11608 return SWIG_Py_Void();
11609 }
11610
11611 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11612 return SWIG_Python_InitShadowInstance(args);
11613 }
11614
11615 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11616 PyObject *resultobj = 0;
11617 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11618 wxString result;
11619 void *argp1 = 0 ;
11620 int res1 = 0 ;
11621 PyObject *swig_obj[1] ;
11622
11623 if (!args) SWIG_fail;
11624 swig_obj[0] = args;
11625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11626 if (!SWIG_IsOK(res1)) {
11627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11628 }
11629 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11630 {
11631 PyThreadState* __tstate = wxPyBeginAllowThreads();
11632 result = (arg1)->GetName();
11633 wxPyEndAllowThreads(__tstate);
11634 if (PyErr_Occurred()) SWIG_fail;
11635 }
11636 {
11637 #if wxUSE_UNICODE
11638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11639 #else
11640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11641 #endif
11642 }
11643 return resultobj;
11644 fail:
11645 return NULL;
11646 }
11647
11648
11649 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11650 PyObject *resultobj = 0;
11651 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11652 wxString result;
11653 void *argp1 = 0 ;
11654 int res1 = 0 ;
11655 PyObject *swig_obj[1] ;
11656
11657 if (!args) SWIG_fail;
11658 swig_obj[0] = args;
11659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11660 if (!SWIG_IsOK(res1)) {
11661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11662 }
11663 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (arg1)->GetExtension();
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 {
11671 #if wxUSE_UNICODE
11672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11673 #else
11674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11675 #endif
11676 }
11677 return resultobj;
11678 fail:
11679 return NULL;
11680 }
11681
11682
11683 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11684 PyObject *resultobj = 0;
11685 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11686 long result;
11687 void *argp1 = 0 ;
11688 int res1 = 0 ;
11689 PyObject *swig_obj[1] ;
11690
11691 if (!args) SWIG_fail;
11692 swig_obj[0] = args;
11693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11694 if (!SWIG_IsOK(res1)) {
11695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11696 }
11697 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = (long)(arg1)->GetType();
11701 wxPyEndAllowThreads(__tstate);
11702 if (PyErr_Occurred()) SWIG_fail;
11703 }
11704 resultobj = SWIG_From_long(static_cast< long >(result));
11705 return resultobj;
11706 fail:
11707 return NULL;
11708 }
11709
11710
11711 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11712 PyObject *resultobj = 0;
11713 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11714 wxString result;
11715 void *argp1 = 0 ;
11716 int res1 = 0 ;
11717 PyObject *swig_obj[1] ;
11718
11719 if (!args) SWIG_fail;
11720 swig_obj[0] = args;
11721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11722 if (!SWIG_IsOK(res1)) {
11723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11724 }
11725 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11726 {
11727 PyThreadState* __tstate = wxPyBeginAllowThreads();
11728 result = (arg1)->GetMimeType();
11729 wxPyEndAllowThreads(__tstate);
11730 if (PyErr_Occurred()) SWIG_fail;
11731 }
11732 {
11733 #if wxUSE_UNICODE
11734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11735 #else
11736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11737 #endif
11738 }
11739 return resultobj;
11740 fail:
11741 return NULL;
11742 }
11743
11744
11745 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11746 PyObject *resultobj = 0;
11747 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11748 wxString *arg2 = 0 ;
11749 bool result;
11750 void *argp1 = 0 ;
11751 int res1 = 0 ;
11752 bool temp2 = false ;
11753 PyObject * obj0 = 0 ;
11754 PyObject * obj1 = 0 ;
11755 char * kwnames[] = {
11756 (char *) "self",(char *) "name", NULL
11757 };
11758
11759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11761 if (!SWIG_IsOK(res1)) {
11762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11763 }
11764 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11765 {
11766 arg2 = wxString_in_helper(obj1);
11767 if (arg2 == NULL) SWIG_fail;
11768 temp2 = true;
11769 }
11770 {
11771 PyThreadState* __tstate = wxPyBeginAllowThreads();
11772 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11773 wxPyEndAllowThreads(__tstate);
11774 if (PyErr_Occurred()) SWIG_fail;
11775 }
11776 {
11777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11778 }
11779 {
11780 if (temp2)
11781 delete arg2;
11782 }
11783 return resultobj;
11784 fail:
11785 {
11786 if (temp2)
11787 delete arg2;
11788 }
11789 return NULL;
11790 }
11791
11792
11793 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11794 PyObject *resultobj = 0;
11795 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11796 wxString *arg2 = 0 ;
11797 void *argp1 = 0 ;
11798 int res1 = 0 ;
11799 bool temp2 = false ;
11800 PyObject * obj0 = 0 ;
11801 PyObject * obj1 = 0 ;
11802 char * kwnames[] = {
11803 (char *) "self",(char *) "name", NULL
11804 };
11805
11806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11808 if (!SWIG_IsOK(res1)) {
11809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11810 }
11811 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11812 {
11813 arg2 = wxString_in_helper(obj1);
11814 if (arg2 == NULL) SWIG_fail;
11815 temp2 = true;
11816 }
11817 {
11818 PyThreadState* __tstate = wxPyBeginAllowThreads();
11819 (arg1)->SetName((wxString const &)*arg2);
11820 wxPyEndAllowThreads(__tstate);
11821 if (PyErr_Occurred()) SWIG_fail;
11822 }
11823 resultobj = SWIG_Py_Void();
11824 {
11825 if (temp2)
11826 delete arg2;
11827 }
11828 return resultobj;
11829 fail:
11830 {
11831 if (temp2)
11832 delete arg2;
11833 }
11834 return NULL;
11835 }
11836
11837
11838 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11839 PyObject *resultobj = 0;
11840 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11841 wxString *arg2 = 0 ;
11842 void *argp1 = 0 ;
11843 int res1 = 0 ;
11844 bool temp2 = false ;
11845 PyObject * obj0 = 0 ;
11846 PyObject * obj1 = 0 ;
11847 char * kwnames[] = {
11848 (char *) "self",(char *) "extension", NULL
11849 };
11850
11851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11853 if (!SWIG_IsOK(res1)) {
11854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11855 }
11856 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11857 {
11858 arg2 = wxString_in_helper(obj1);
11859 if (arg2 == NULL) SWIG_fail;
11860 temp2 = true;
11861 }
11862 {
11863 PyThreadState* __tstate = wxPyBeginAllowThreads();
11864 (arg1)->SetExtension((wxString const &)*arg2);
11865 wxPyEndAllowThreads(__tstate);
11866 if (PyErr_Occurred()) SWIG_fail;
11867 }
11868 resultobj = SWIG_Py_Void();
11869 {
11870 if (temp2)
11871 delete arg2;
11872 }
11873 return resultobj;
11874 fail:
11875 {
11876 if (temp2)
11877 delete arg2;
11878 }
11879 return NULL;
11880 }
11881
11882
11883 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11884 PyObject *resultobj = 0;
11885 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11886 long arg2 ;
11887 void *argp1 = 0 ;
11888 int res1 = 0 ;
11889 long val2 ;
11890 int ecode2 = 0 ;
11891 PyObject * obj0 = 0 ;
11892 PyObject * obj1 = 0 ;
11893 char * kwnames[] = {
11894 (char *) "self",(char *) "type", NULL
11895 };
11896
11897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11899 if (!SWIG_IsOK(res1)) {
11900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11901 }
11902 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11903 ecode2 = SWIG_AsVal_long(obj1, &val2);
11904 if (!SWIG_IsOK(ecode2)) {
11905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11906 }
11907 arg2 = static_cast< long >(val2);
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 (arg1)->SetType(arg2);
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 resultobj = SWIG_Py_Void();
11915 return resultobj;
11916 fail:
11917 return NULL;
11918 }
11919
11920
11921 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11922 PyObject *resultobj = 0;
11923 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11924 wxString *arg2 = 0 ;
11925 void *argp1 = 0 ;
11926 int res1 = 0 ;
11927 bool temp2 = false ;
11928 PyObject * obj0 = 0 ;
11929 PyObject * obj1 = 0 ;
11930 char * kwnames[] = {
11931 (char *) "self",(char *) "mimetype", NULL
11932 };
11933
11934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11936 if (!SWIG_IsOK(res1)) {
11937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11938 }
11939 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11940 {
11941 arg2 = wxString_in_helper(obj1);
11942 if (arg2 == NULL) SWIG_fail;
11943 temp2 = true;
11944 }
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 (arg1)->SetMimeType((wxString const &)*arg2);
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 resultobj = SWIG_Py_Void();
11952 {
11953 if (temp2)
11954 delete arg2;
11955 }
11956 return resultobj;
11957 fail:
11958 {
11959 if (temp2)
11960 delete arg2;
11961 }
11962 return NULL;
11963 }
11964
11965
11966 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11967 PyObject *obj;
11968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11969 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
11970 return SWIG_Py_Void();
11971 }
11972
11973 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11974 PyObject *resultobj = 0;
11975 wxPyImageHandler *result = 0 ;
11976
11977 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
11978 {
11979 PyThreadState* __tstate = wxPyBeginAllowThreads();
11980 result = (wxPyImageHandler *)new wxPyImageHandler();
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
11985 return resultobj;
11986 fail:
11987 return NULL;
11988 }
11989
11990
11991 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11992 PyObject *resultobj = 0;
11993 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
11994 PyObject *arg2 = (PyObject *) 0 ;
11995 void *argp1 = 0 ;
11996 int res1 = 0 ;
11997 PyObject * obj0 = 0 ;
11998 PyObject * obj1 = 0 ;
11999 char * kwnames[] = {
12000 (char *) "self",(char *) "self", NULL
12001 };
12002
12003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12005 if (!SWIG_IsOK(res1)) {
12006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12007 }
12008 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12009 arg2 = obj1;
12010 {
12011 PyThreadState* __tstate = wxPyBeginAllowThreads();
12012 (arg1)->_SetSelf(arg2);
12013 wxPyEndAllowThreads(__tstate);
12014 if (PyErr_Occurred()) SWIG_fail;
12015 }
12016 resultobj = SWIG_Py_Void();
12017 return resultobj;
12018 fail:
12019 return NULL;
12020 }
12021
12022
12023 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12024 PyObject *obj;
12025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12026 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12027 return SWIG_Py_Void();
12028 }
12029
12030 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12031 return SWIG_Python_InitShadowInstance(args);
12032 }
12033
12034 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12035 PyObject *resultobj = 0;
12036 wxImageHistogram *result = 0 ;
12037
12038 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 result = (wxImageHistogram *)new wxImageHistogram();
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12046 return resultobj;
12047 fail:
12048 return NULL;
12049 }
12050
12051
12052 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12053 PyObject *resultobj = 0;
12054 byte arg1 ;
12055 byte arg2 ;
12056 byte arg3 ;
12057 unsigned long result;
12058 unsigned char val1 ;
12059 int ecode1 = 0 ;
12060 unsigned char val2 ;
12061 int ecode2 = 0 ;
12062 unsigned char val3 ;
12063 int ecode3 = 0 ;
12064 PyObject * obj0 = 0 ;
12065 PyObject * obj1 = 0 ;
12066 PyObject * obj2 = 0 ;
12067 char * kwnames[] = {
12068 (char *) "r",(char *) "g",(char *) "b", NULL
12069 };
12070
12071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12072 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12073 if (!SWIG_IsOK(ecode1)) {
12074 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12075 }
12076 arg1 = static_cast< byte >(val1);
12077 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12078 if (!SWIG_IsOK(ecode2)) {
12079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12080 }
12081 arg2 = static_cast< byte >(val2);
12082 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12083 if (!SWIG_IsOK(ecode3)) {
12084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12085 }
12086 arg3 = static_cast< byte >(val3);
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12101 PyObject *resultobj = 0;
12102 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12103 byte *arg2 = (byte *) 0 ;
12104 byte *arg3 = (byte *) 0 ;
12105 byte *arg4 = (byte *) 0 ;
12106 byte arg5 = (byte) 1 ;
12107 byte arg6 = (byte) 0 ;
12108 byte arg7 = (byte) 0 ;
12109 bool result;
12110 void *argp1 = 0 ;
12111 int res1 = 0 ;
12112 byte temp2 ;
12113 int res2 = SWIG_TMPOBJ ;
12114 byte temp3 ;
12115 int res3 = SWIG_TMPOBJ ;
12116 byte temp4 ;
12117 int res4 = SWIG_TMPOBJ ;
12118 unsigned char val5 ;
12119 int ecode5 = 0 ;
12120 unsigned char val6 ;
12121 int ecode6 = 0 ;
12122 unsigned char val7 ;
12123 int ecode7 = 0 ;
12124 PyObject * obj0 = 0 ;
12125 PyObject * obj1 = 0 ;
12126 PyObject * obj2 = 0 ;
12127 PyObject * obj3 = 0 ;
12128 char * kwnames[] = {
12129 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12130 };
12131
12132 arg2 = &temp2;
12133 arg3 = &temp3;
12134 arg4 = &temp4;
12135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12137 if (!SWIG_IsOK(res1)) {
12138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12139 }
12140 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12141 if (obj1) {
12142 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12143 if (!SWIG_IsOK(ecode5)) {
12144 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12145 }
12146 arg5 = static_cast< byte >(val5);
12147 }
12148 if (obj2) {
12149 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12150 if (!SWIG_IsOK(ecode6)) {
12151 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12152 }
12153 arg6 = static_cast< byte >(val6);
12154 }
12155 if (obj3) {
12156 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12157 if (!SWIG_IsOK(ecode7)) {
12158 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12159 }
12160 arg7 = static_cast< byte >(val7);
12161 }
12162 {
12163 PyThreadState* __tstate = wxPyBeginAllowThreads();
12164 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12165 wxPyEndAllowThreads(__tstate);
12166 if (PyErr_Occurred()) SWIG_fail;
12167 }
12168 {
12169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12170 }
12171 if (SWIG_IsTmpObj(res2)) {
12172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12173 } else {
12174 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12176 }
12177 if (SWIG_IsTmpObj(res3)) {
12178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12179 } else {
12180 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12182 }
12183 if (SWIG_IsTmpObj(res4)) {
12184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12185 } else {
12186 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12188 }
12189 return resultobj;
12190 fail:
12191 return NULL;
12192 }
12193
12194
12195 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12196 PyObject *resultobj = 0;
12197 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12198 unsigned long arg2 ;
12199 unsigned long result;
12200 void *argp1 = 0 ;
12201 int res1 = 0 ;
12202 unsigned long val2 ;
12203 int ecode2 = 0 ;
12204 PyObject * obj0 = 0 ;
12205 PyObject * obj1 = 0 ;
12206 char * kwnames[] = {
12207 (char *) "self",(char *) "key", NULL
12208 };
12209
12210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12212 if (!SWIG_IsOK(res1)) {
12213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12214 }
12215 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12216 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12217 if (!SWIG_IsOK(ecode2)) {
12218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12219 }
12220 arg2 = static_cast< unsigned long >(val2);
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12228 return resultobj;
12229 fail:
12230 return NULL;
12231 }
12232
12233
12234 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12235 PyObject *resultobj = 0;
12236 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12237 byte arg2 ;
12238 byte arg3 ;
12239 byte arg4 ;
12240 unsigned long result;
12241 void *argp1 = 0 ;
12242 int res1 = 0 ;
12243 unsigned char val2 ;
12244 int ecode2 = 0 ;
12245 unsigned char val3 ;
12246 int ecode3 = 0 ;
12247 unsigned char val4 ;
12248 int ecode4 = 0 ;
12249 PyObject * obj0 = 0 ;
12250 PyObject * obj1 = 0 ;
12251 PyObject * obj2 = 0 ;
12252 PyObject * obj3 = 0 ;
12253 char * kwnames[] = {
12254 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12255 };
12256
12257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12259 if (!SWIG_IsOK(res1)) {
12260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12261 }
12262 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12263 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12264 if (!SWIG_IsOK(ecode2)) {
12265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12266 }
12267 arg2 = static_cast< byte >(val2);
12268 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12269 if (!SWIG_IsOK(ecode3)) {
12270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12271 }
12272 arg3 = static_cast< byte >(val3);
12273 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12274 if (!SWIG_IsOK(ecode4)) {
12275 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12276 }
12277 arg4 = static_cast< byte >(val4);
12278 {
12279 PyThreadState* __tstate = wxPyBeginAllowThreads();
12280 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12285 return resultobj;
12286 fail:
12287 return NULL;
12288 }
12289
12290
12291 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12292 PyObject *resultobj = 0;
12293 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12294 wxColour *arg2 = 0 ;
12295 unsigned long result;
12296 void *argp1 = 0 ;
12297 int res1 = 0 ;
12298 wxColour temp2 ;
12299 PyObject * obj0 = 0 ;
12300 PyObject * obj1 = 0 ;
12301 char * kwnames[] = {
12302 (char *) "self",(char *) "colour", NULL
12303 };
12304
12305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12307 if (!SWIG_IsOK(res1)) {
12308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12309 }
12310 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12311 {
12312 arg2 = &temp2;
12313 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12314 }
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12322 return resultobj;
12323 fail:
12324 return NULL;
12325 }
12326
12327
12328 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12329 PyObject *obj;
12330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12331 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12332 return SWIG_Py_Void();
12333 }
12334
12335 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12336 return SWIG_Python_InitShadowInstance(args);
12337 }
12338
12339 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj = 0;
12341 byte arg1 = (byte) 0 ;
12342 byte arg2 = (byte) 0 ;
12343 byte arg3 = (byte) 0 ;
12344 wxImage_RGBValue *result = 0 ;
12345 unsigned char val1 ;
12346 int ecode1 = 0 ;
12347 unsigned char val2 ;
12348 int ecode2 = 0 ;
12349 unsigned char val3 ;
12350 int ecode3 = 0 ;
12351 PyObject * obj0 = 0 ;
12352 PyObject * obj1 = 0 ;
12353 PyObject * obj2 = 0 ;
12354 char * kwnames[] = {
12355 (char *) "r",(char *) "g",(char *) "b", NULL
12356 };
12357
12358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12359 if (obj0) {
12360 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12361 if (!SWIG_IsOK(ecode1)) {
12362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12363 }
12364 arg1 = static_cast< byte >(val1);
12365 }
12366 if (obj1) {
12367 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12368 if (!SWIG_IsOK(ecode2)) {
12369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12370 }
12371 arg2 = static_cast< byte >(val2);
12372 }
12373 if (obj2) {
12374 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12375 if (!SWIG_IsOK(ecode3)) {
12376 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12377 }
12378 arg3 = static_cast< byte >(val3);
12379 }
12380 {
12381 PyThreadState* __tstate = wxPyBeginAllowThreads();
12382 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12383 wxPyEndAllowThreads(__tstate);
12384 if (PyErr_Occurred()) SWIG_fail;
12385 }
12386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12387 return resultobj;
12388 fail:
12389 return NULL;
12390 }
12391
12392
12393 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12394 PyObject *resultobj = 0;
12395 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12396 byte arg2 ;
12397 void *argp1 = 0 ;
12398 int res1 = 0 ;
12399 unsigned char val2 ;
12400 int ecode2 = 0 ;
12401 PyObject *swig_obj[2] ;
12402
12403 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12405 if (!SWIG_IsOK(res1)) {
12406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12407 }
12408 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12409 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12410 if (!SWIG_IsOK(ecode2)) {
12411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12412 }
12413 arg2 = static_cast< byte >(val2);
12414 if (arg1) (arg1)->red = arg2;
12415
12416 resultobj = SWIG_Py_Void();
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12424 PyObject *resultobj = 0;
12425 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12426 byte result;
12427 void *argp1 = 0 ;
12428 int res1 = 0 ;
12429 PyObject *swig_obj[1] ;
12430
12431 if (!args) SWIG_fail;
12432 swig_obj[0] = args;
12433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12434 if (!SWIG_IsOK(res1)) {
12435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12436 }
12437 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12438 result = (byte) ((arg1)->red);
12439 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12440 return resultobj;
12441 fail:
12442 return NULL;
12443 }
12444
12445
12446 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12447 PyObject *resultobj = 0;
12448 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12449 byte arg2 ;
12450 void *argp1 = 0 ;
12451 int res1 = 0 ;
12452 unsigned char val2 ;
12453 int ecode2 = 0 ;
12454 PyObject *swig_obj[2] ;
12455
12456 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12458 if (!SWIG_IsOK(res1)) {
12459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12460 }
12461 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12462 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12463 if (!SWIG_IsOK(ecode2)) {
12464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12465 }
12466 arg2 = static_cast< byte >(val2);
12467 if (arg1) (arg1)->green = arg2;
12468
12469 resultobj = SWIG_Py_Void();
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12477 PyObject *resultobj = 0;
12478 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12479 byte result;
12480 void *argp1 = 0 ;
12481 int res1 = 0 ;
12482 PyObject *swig_obj[1] ;
12483
12484 if (!args) SWIG_fail;
12485 swig_obj[0] = args;
12486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12487 if (!SWIG_IsOK(res1)) {
12488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12489 }
12490 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12491 result = (byte) ((arg1)->green);
12492 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12493 return resultobj;
12494 fail:
12495 return NULL;
12496 }
12497
12498
12499 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12500 PyObject *resultobj = 0;
12501 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12502 byte arg2 ;
12503 void *argp1 = 0 ;
12504 int res1 = 0 ;
12505 unsigned char val2 ;
12506 int ecode2 = 0 ;
12507 PyObject *swig_obj[2] ;
12508
12509 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12511 if (!SWIG_IsOK(res1)) {
12512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12513 }
12514 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12515 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12516 if (!SWIG_IsOK(ecode2)) {
12517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12518 }
12519 arg2 = static_cast< byte >(val2);
12520 if (arg1) (arg1)->blue = arg2;
12521
12522 resultobj = SWIG_Py_Void();
12523 return resultobj;
12524 fail:
12525 return NULL;
12526 }
12527
12528
12529 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12530 PyObject *resultobj = 0;
12531 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12532 byte result;
12533 void *argp1 = 0 ;
12534 int res1 = 0 ;
12535 PyObject *swig_obj[1] ;
12536
12537 if (!args) SWIG_fail;
12538 swig_obj[0] = args;
12539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12540 if (!SWIG_IsOK(res1)) {
12541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12542 }
12543 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12544 result = (byte) ((arg1)->blue);
12545 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12546 return resultobj;
12547 fail:
12548 return NULL;
12549 }
12550
12551
12552 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12553 PyObject *obj;
12554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12555 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12556 return SWIG_Py_Void();
12557 }
12558
12559 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12560 return SWIG_Python_InitShadowInstance(args);
12561 }
12562
12563 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj = 0;
12565 double arg1 = (double) 0.0 ;
12566 double arg2 = (double) 0.0 ;
12567 double arg3 = (double) 0.0 ;
12568 wxImage_HSVValue *result = 0 ;
12569 double val1 ;
12570 int ecode1 = 0 ;
12571 double val2 ;
12572 int ecode2 = 0 ;
12573 double val3 ;
12574 int ecode3 = 0 ;
12575 PyObject * obj0 = 0 ;
12576 PyObject * obj1 = 0 ;
12577 PyObject * obj2 = 0 ;
12578 char * kwnames[] = {
12579 (char *) "h",(char *) "s",(char *) "v", NULL
12580 };
12581
12582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12583 if (obj0) {
12584 ecode1 = SWIG_AsVal_double(obj0, &val1);
12585 if (!SWIG_IsOK(ecode1)) {
12586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12587 }
12588 arg1 = static_cast< double >(val1);
12589 }
12590 if (obj1) {
12591 ecode2 = SWIG_AsVal_double(obj1, &val2);
12592 if (!SWIG_IsOK(ecode2)) {
12593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12594 }
12595 arg2 = static_cast< double >(val2);
12596 }
12597 if (obj2) {
12598 ecode3 = SWIG_AsVal_double(obj2, &val3);
12599 if (!SWIG_IsOK(ecode3)) {
12600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12601 }
12602 arg3 = static_cast< double >(val3);
12603 }
12604 {
12605 PyThreadState* __tstate = wxPyBeginAllowThreads();
12606 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12607 wxPyEndAllowThreads(__tstate);
12608 if (PyErr_Occurred()) SWIG_fail;
12609 }
12610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12611 return resultobj;
12612 fail:
12613 return NULL;
12614 }
12615
12616
12617 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12618 PyObject *resultobj = 0;
12619 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12620 double arg2 ;
12621 void *argp1 = 0 ;
12622 int res1 = 0 ;
12623 double val2 ;
12624 int ecode2 = 0 ;
12625 PyObject *swig_obj[2] ;
12626
12627 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12629 if (!SWIG_IsOK(res1)) {
12630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12631 }
12632 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12633 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12634 if (!SWIG_IsOK(ecode2)) {
12635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12636 }
12637 arg2 = static_cast< double >(val2);
12638 if (arg1) (arg1)->hue = arg2;
12639
12640 resultobj = SWIG_Py_Void();
12641 return resultobj;
12642 fail:
12643 return NULL;
12644 }
12645
12646
12647 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12648 PyObject *resultobj = 0;
12649 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12650 double result;
12651 void *argp1 = 0 ;
12652 int res1 = 0 ;
12653 PyObject *swig_obj[1] ;
12654
12655 if (!args) SWIG_fail;
12656 swig_obj[0] = args;
12657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12658 if (!SWIG_IsOK(res1)) {
12659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12660 }
12661 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12662 result = (double) ((arg1)->hue);
12663 resultobj = SWIG_From_double(static_cast< double >(result));
12664 return resultobj;
12665 fail:
12666 return NULL;
12667 }
12668
12669
12670 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12671 PyObject *resultobj = 0;
12672 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12673 double arg2 ;
12674 void *argp1 = 0 ;
12675 int res1 = 0 ;
12676 double val2 ;
12677 int ecode2 = 0 ;
12678 PyObject *swig_obj[2] ;
12679
12680 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12682 if (!SWIG_IsOK(res1)) {
12683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12684 }
12685 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12686 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12687 if (!SWIG_IsOK(ecode2)) {
12688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12689 }
12690 arg2 = static_cast< double >(val2);
12691 if (arg1) (arg1)->saturation = arg2;
12692
12693 resultobj = SWIG_Py_Void();
12694 return resultobj;
12695 fail:
12696 return NULL;
12697 }
12698
12699
12700 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12701 PyObject *resultobj = 0;
12702 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12703 double result;
12704 void *argp1 = 0 ;
12705 int res1 = 0 ;
12706 PyObject *swig_obj[1] ;
12707
12708 if (!args) SWIG_fail;
12709 swig_obj[0] = args;
12710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12711 if (!SWIG_IsOK(res1)) {
12712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12713 }
12714 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12715 result = (double) ((arg1)->saturation);
12716 resultobj = SWIG_From_double(static_cast< double >(result));
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12724 PyObject *resultobj = 0;
12725 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12726 double arg2 ;
12727 void *argp1 = 0 ;
12728 int res1 = 0 ;
12729 double val2 ;
12730 int ecode2 = 0 ;
12731 PyObject *swig_obj[2] ;
12732
12733 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12735 if (!SWIG_IsOK(res1)) {
12736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12737 }
12738 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12739 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12740 if (!SWIG_IsOK(ecode2)) {
12741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12742 }
12743 arg2 = static_cast< double >(val2);
12744 if (arg1) (arg1)->value = arg2;
12745
12746 resultobj = SWIG_Py_Void();
12747 return resultobj;
12748 fail:
12749 return NULL;
12750 }
12751
12752
12753 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12754 PyObject *resultobj = 0;
12755 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12756 double result;
12757 void *argp1 = 0 ;
12758 int res1 = 0 ;
12759 PyObject *swig_obj[1] ;
12760
12761 if (!args) SWIG_fail;
12762 swig_obj[0] = args;
12763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12764 if (!SWIG_IsOK(res1)) {
12765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12766 }
12767 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12768 result = (double) ((arg1)->value);
12769 resultobj = SWIG_From_double(static_cast< double >(result));
12770 return resultobj;
12771 fail:
12772 return NULL;
12773 }
12774
12775
12776 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12777 PyObject *obj;
12778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12779 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12780 return SWIG_Py_Void();
12781 }
12782
12783 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12784 return SWIG_Python_InitShadowInstance(args);
12785 }
12786
12787 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12788 PyObject *resultobj = 0;
12789 wxString *arg1 = 0 ;
12790 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12791 int arg3 = (int) -1 ;
12792 wxImage *result = 0 ;
12793 bool temp1 = false ;
12794 long val2 ;
12795 int ecode2 = 0 ;
12796 int val3 ;
12797 int ecode3 = 0 ;
12798 PyObject * obj0 = 0 ;
12799 PyObject * obj1 = 0 ;
12800 PyObject * obj2 = 0 ;
12801 char * kwnames[] = {
12802 (char *) "name",(char *) "type",(char *) "index", NULL
12803 };
12804
12805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12806 {
12807 arg1 = wxString_in_helper(obj0);
12808 if (arg1 == NULL) SWIG_fail;
12809 temp1 = true;
12810 }
12811 if (obj1) {
12812 ecode2 = SWIG_AsVal_long(obj1, &val2);
12813 if (!SWIG_IsOK(ecode2)) {
12814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12815 }
12816 arg2 = static_cast< long >(val2);
12817 }
12818 if (obj2) {
12819 ecode3 = SWIG_AsVal_int(obj2, &val3);
12820 if (!SWIG_IsOK(ecode3)) {
12821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12822 }
12823 arg3 = static_cast< int >(val3);
12824 }
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12828 wxPyEndAllowThreads(__tstate);
12829 if (PyErr_Occurred()) SWIG_fail;
12830 }
12831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12832 {
12833 if (temp1)
12834 delete arg1;
12835 }
12836 return resultobj;
12837 fail:
12838 {
12839 if (temp1)
12840 delete arg1;
12841 }
12842 return NULL;
12843 }
12844
12845
12846 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12847 PyObject *resultobj = 0;
12848 wxImage *arg1 = (wxImage *) 0 ;
12849 void *argp1 = 0 ;
12850 int res1 = 0 ;
12851 PyObject *swig_obj[1] ;
12852
12853 if (!args) SWIG_fail;
12854 swig_obj[0] = args;
12855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12856 if (!SWIG_IsOK(res1)) {
12857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12858 }
12859 arg1 = reinterpret_cast< wxImage * >(argp1);
12860 {
12861 PyThreadState* __tstate = wxPyBeginAllowThreads();
12862 delete arg1;
12863
12864 wxPyEndAllowThreads(__tstate);
12865 if (PyErr_Occurred()) SWIG_fail;
12866 }
12867 resultobj = SWIG_Py_Void();
12868 return resultobj;
12869 fail:
12870 return NULL;
12871 }
12872
12873
12874 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12875 PyObject *resultobj = 0;
12876 wxString *arg1 = 0 ;
12877 wxString *arg2 = 0 ;
12878 int arg3 = (int) -1 ;
12879 wxImage *result = 0 ;
12880 bool temp1 = false ;
12881 bool temp2 = false ;
12882 int val3 ;
12883 int ecode3 = 0 ;
12884 PyObject * obj0 = 0 ;
12885 PyObject * obj1 = 0 ;
12886 PyObject * obj2 = 0 ;
12887 char * kwnames[] = {
12888 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12889 };
12890
12891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12892 {
12893 arg1 = wxString_in_helper(obj0);
12894 if (arg1 == NULL) SWIG_fail;
12895 temp1 = true;
12896 }
12897 {
12898 arg2 = wxString_in_helper(obj1);
12899 if (arg2 == NULL) SWIG_fail;
12900 temp2 = true;
12901 }
12902 if (obj2) {
12903 ecode3 = SWIG_AsVal_int(obj2, &val3);
12904 if (!SWIG_IsOK(ecode3)) {
12905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12906 }
12907 arg3 = static_cast< int >(val3);
12908 }
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12912 wxPyEndAllowThreads(__tstate);
12913 if (PyErr_Occurred()) SWIG_fail;
12914 }
12915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12916 {
12917 if (temp1)
12918 delete arg1;
12919 }
12920 {
12921 if (temp2)
12922 delete arg2;
12923 }
12924 return resultobj;
12925 fail:
12926 {
12927 if (temp1)
12928 delete arg1;
12929 }
12930 {
12931 if (temp2)
12932 delete arg2;
12933 }
12934 return NULL;
12935 }
12936
12937
12938 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12939 PyObject *resultobj = 0;
12940 wxInputStream *arg1 = 0 ;
12941 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12942 int arg3 = (int) -1 ;
12943 wxImage *result = 0 ;
12944 wxPyInputStream *temp1 ;
12945 bool created1 ;
12946 long val2 ;
12947 int ecode2 = 0 ;
12948 int val3 ;
12949 int ecode3 = 0 ;
12950 PyObject * obj0 = 0 ;
12951 PyObject * obj1 = 0 ;
12952 PyObject * obj2 = 0 ;
12953 char * kwnames[] = {
12954 (char *) "stream",(char *) "type",(char *) "index", NULL
12955 };
12956
12957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12958 {
12959 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12960 arg1 = temp1->m_wxis;
12961 created1 = false;
12962 } else {
12963 PyErr_Clear(); // clear the failure of the wxPyConvert above
12964 arg1 = wxPyCBInputStream_create(obj0, false);
12965 if (arg1 == NULL) {
12966 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12967 SWIG_fail;
12968 }
12969 created1 = true;
12970 }
12971 }
12972 if (obj1) {
12973 ecode2 = SWIG_AsVal_long(obj1, &val2);
12974 if (!SWIG_IsOK(ecode2)) {
12975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
12976 }
12977 arg2 = static_cast< long >(val2);
12978 }
12979 if (obj2) {
12980 ecode3 = SWIG_AsVal_int(obj2, &val3);
12981 if (!SWIG_IsOK(ecode3)) {
12982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
12983 }
12984 arg3 = static_cast< int >(val3);
12985 }
12986 {
12987 PyThreadState* __tstate = wxPyBeginAllowThreads();
12988 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12993 {
12994 if (created1) delete arg1;
12995 }
12996 return resultobj;
12997 fail:
12998 {
12999 if (created1) delete arg1;
13000 }
13001 return NULL;
13002 }
13003
13004
13005 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj = 0;
13007 wxInputStream *arg1 = 0 ;
13008 wxString *arg2 = 0 ;
13009 int arg3 = (int) -1 ;
13010 wxImage *result = 0 ;
13011 wxPyInputStream *temp1 ;
13012 bool created1 ;
13013 bool temp2 = false ;
13014 int val3 ;
13015 int ecode3 = 0 ;
13016 PyObject * obj0 = 0 ;
13017 PyObject * obj1 = 0 ;
13018 PyObject * obj2 = 0 ;
13019 char * kwnames[] = {
13020 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13021 };
13022
13023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13024 {
13025 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13026 arg1 = temp1->m_wxis;
13027 created1 = false;
13028 } else {
13029 PyErr_Clear(); // clear the failure of the wxPyConvert above
13030 arg1 = wxPyCBInputStream_create(obj0, false);
13031 if (arg1 == NULL) {
13032 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13033 SWIG_fail;
13034 }
13035 created1 = true;
13036 }
13037 }
13038 {
13039 arg2 = wxString_in_helper(obj1);
13040 if (arg2 == NULL) SWIG_fail;
13041 temp2 = true;
13042 }
13043 if (obj2) {
13044 ecode3 = SWIG_AsVal_int(obj2, &val3);
13045 if (!SWIG_IsOK(ecode3)) {
13046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13047 }
13048 arg3 = static_cast< int >(val3);
13049 }
13050 {
13051 PyThreadState* __tstate = wxPyBeginAllowThreads();
13052 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13053 wxPyEndAllowThreads(__tstate);
13054 if (PyErr_Occurred()) SWIG_fail;
13055 }
13056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13057 {
13058 if (created1) delete arg1;
13059 }
13060 {
13061 if (temp2)
13062 delete arg2;
13063 }
13064 return resultobj;
13065 fail:
13066 {
13067 if (created1) delete arg1;
13068 }
13069 {
13070 if (temp2)
13071 delete arg2;
13072 }
13073 return NULL;
13074 }
13075
13076
13077 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13078 PyObject *resultobj = 0;
13079 int arg1 = (int) 0 ;
13080 int arg2 = (int) 0 ;
13081 bool arg3 = (bool) true ;
13082 wxImage *result = 0 ;
13083 int val1 ;
13084 int ecode1 = 0 ;
13085 int val2 ;
13086 int ecode2 = 0 ;
13087 bool val3 ;
13088 int ecode3 = 0 ;
13089 PyObject * obj0 = 0 ;
13090 PyObject * obj1 = 0 ;
13091 PyObject * obj2 = 0 ;
13092 char * kwnames[] = {
13093 (char *) "width",(char *) "height",(char *) "clear", NULL
13094 };
13095
13096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13097 if (obj0) {
13098 ecode1 = SWIG_AsVal_int(obj0, &val1);
13099 if (!SWIG_IsOK(ecode1)) {
13100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13101 }
13102 arg1 = static_cast< int >(val1);
13103 }
13104 if (obj1) {
13105 ecode2 = SWIG_AsVal_int(obj1, &val2);
13106 if (!SWIG_IsOK(ecode2)) {
13107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13108 }
13109 arg2 = static_cast< int >(val2);
13110 }
13111 if (obj2) {
13112 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13113 if (!SWIG_IsOK(ecode3)) {
13114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13115 }
13116 arg3 = static_cast< bool >(val3);
13117 }
13118 {
13119 PyThreadState* __tstate = wxPyBeginAllowThreads();
13120 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13121 wxPyEndAllowThreads(__tstate);
13122 if (PyErr_Occurred()) SWIG_fail;
13123 }
13124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13125 return resultobj;
13126 fail:
13127 return NULL;
13128 }
13129
13130
13131 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13132 PyObject *resultobj = 0;
13133 wxBitmap *arg1 = 0 ;
13134 wxImage *result = 0 ;
13135 void *argp1 = 0 ;
13136 int res1 = 0 ;
13137 PyObject * obj0 = 0 ;
13138 char * kwnames[] = {
13139 (char *) "bitmap", NULL
13140 };
13141
13142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13143 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13144 if (!SWIG_IsOK(res1)) {
13145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13146 }
13147 if (!argp1) {
13148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13149 }
13150 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13151 {
13152 if (!wxPyCheckForApp()) SWIG_fail;
13153 PyThreadState* __tstate = wxPyBeginAllowThreads();
13154 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13159 return resultobj;
13160 fail:
13161 return NULL;
13162 }
13163
13164
13165 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13166 PyObject *resultobj = 0;
13167 int arg1 ;
13168 int arg2 ;
13169 buffer arg3 ;
13170 int arg4 ;
13171 wxImage *result = 0 ;
13172 int val1 ;
13173 int ecode1 = 0 ;
13174 int val2 ;
13175 int ecode2 = 0 ;
13176 PyObject * obj0 = 0 ;
13177 PyObject * obj1 = 0 ;
13178 PyObject * obj2 = 0 ;
13179 char * kwnames[] = {
13180 (char *) "width",(char *) "height",(char *) "data", NULL
13181 };
13182
13183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13184 ecode1 = SWIG_AsVal_int(obj0, &val1);
13185 if (!SWIG_IsOK(ecode1)) {
13186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13187 }
13188 arg1 = static_cast< int >(val1);
13189 ecode2 = SWIG_AsVal_int(obj1, &val2);
13190 if (!SWIG_IsOK(ecode2)) {
13191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13192 }
13193 arg2 = static_cast< int >(val2);
13194 {
13195 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13196 }
13197 {
13198 PyThreadState* __tstate = wxPyBeginAllowThreads();
13199 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13200 wxPyEndAllowThreads(__tstate);
13201 if (PyErr_Occurred()) SWIG_fail;
13202 }
13203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13204 return resultobj;
13205 fail:
13206 return NULL;
13207 }
13208
13209
13210 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13211 PyObject *resultobj = 0;
13212 int arg1 ;
13213 int arg2 ;
13214 buffer arg3 ;
13215 int arg4 ;
13216 buffer arg5 ;
13217 int arg6 ;
13218 wxImage *result = 0 ;
13219 int val1 ;
13220 int ecode1 = 0 ;
13221 int val2 ;
13222 int ecode2 = 0 ;
13223 PyObject * obj0 = 0 ;
13224 PyObject * obj1 = 0 ;
13225 PyObject * obj2 = 0 ;
13226 PyObject * obj3 = 0 ;
13227 char * kwnames[] = {
13228 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13229 };
13230
13231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13232 ecode1 = SWIG_AsVal_int(obj0, &val1);
13233 if (!SWIG_IsOK(ecode1)) {
13234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13235 }
13236 arg1 = static_cast< int >(val1);
13237 ecode2 = SWIG_AsVal_int(obj1, &val2);
13238 if (!SWIG_IsOK(ecode2)) {
13239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13240 }
13241 arg2 = static_cast< int >(val2);
13242 {
13243 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13244 }
13245 {
13246 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13247 }
13248 {
13249 PyThreadState* __tstate = wxPyBeginAllowThreads();
13250 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13251 wxPyEndAllowThreads(__tstate);
13252 if (PyErr_Occurred()) SWIG_fail;
13253 }
13254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13255 return resultobj;
13256 fail:
13257 return NULL;
13258 }
13259
13260
13261 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13262 PyObject *resultobj = 0;
13263 wxImage *arg1 = (wxImage *) 0 ;
13264 int arg2 ;
13265 int arg3 ;
13266 bool arg4 = (bool) true ;
13267 void *argp1 = 0 ;
13268 int res1 = 0 ;
13269 int val2 ;
13270 int ecode2 = 0 ;
13271 int val3 ;
13272 int ecode3 = 0 ;
13273 bool val4 ;
13274 int ecode4 = 0 ;
13275 PyObject * obj0 = 0 ;
13276 PyObject * obj1 = 0 ;
13277 PyObject * obj2 = 0 ;
13278 PyObject * obj3 = 0 ;
13279 char * kwnames[] = {
13280 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13281 };
13282
13283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13285 if (!SWIG_IsOK(res1)) {
13286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13287 }
13288 arg1 = reinterpret_cast< wxImage * >(argp1);
13289 ecode2 = SWIG_AsVal_int(obj1, &val2);
13290 if (!SWIG_IsOK(ecode2)) {
13291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13292 }
13293 arg2 = static_cast< int >(val2);
13294 ecode3 = SWIG_AsVal_int(obj2, &val3);
13295 if (!SWIG_IsOK(ecode3)) {
13296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13297 }
13298 arg3 = static_cast< int >(val3);
13299 if (obj3) {
13300 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13301 if (!SWIG_IsOK(ecode4)) {
13302 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13303 }
13304 arg4 = static_cast< bool >(val4);
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 (arg1)->Create(arg2,arg3,arg4);
13309 wxPyEndAllowThreads(__tstate);
13310 if (PyErr_Occurred()) SWIG_fail;
13311 }
13312 resultobj = SWIG_Py_Void();
13313 return resultobj;
13314 fail:
13315 return NULL;
13316 }
13317
13318
13319 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13320 PyObject *resultobj = 0;
13321 wxImage *arg1 = (wxImage *) 0 ;
13322 void *argp1 = 0 ;
13323 int res1 = 0 ;
13324 PyObject *swig_obj[1] ;
13325
13326 if (!args) SWIG_fail;
13327 swig_obj[0] = args;
13328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13329 if (!SWIG_IsOK(res1)) {
13330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13331 }
13332 arg1 = reinterpret_cast< wxImage * >(argp1);
13333 {
13334 PyThreadState* __tstate = wxPyBeginAllowThreads();
13335 (arg1)->Destroy();
13336 wxPyEndAllowThreads(__tstate);
13337 if (PyErr_Occurred()) SWIG_fail;
13338 }
13339 resultobj = SWIG_Py_Void();
13340 return resultobj;
13341 fail:
13342 return NULL;
13343 }
13344
13345
13346 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13347 PyObject *resultobj = 0;
13348 wxImage *arg1 = (wxImage *) 0 ;
13349 int arg2 ;
13350 int arg3 ;
13351 SwigValueWrapper<wxImage > result;
13352 void *argp1 = 0 ;
13353 int res1 = 0 ;
13354 int val2 ;
13355 int ecode2 = 0 ;
13356 int val3 ;
13357 int ecode3 = 0 ;
13358 PyObject * obj0 = 0 ;
13359 PyObject * obj1 = 0 ;
13360 PyObject * obj2 = 0 ;
13361 char * kwnames[] = {
13362 (char *) "self",(char *) "width",(char *) "height", NULL
13363 };
13364
13365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13367 if (!SWIG_IsOK(res1)) {
13368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13369 }
13370 arg1 = reinterpret_cast< wxImage * >(argp1);
13371 ecode2 = SWIG_AsVal_int(obj1, &val2);
13372 if (!SWIG_IsOK(ecode2)) {
13373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13374 }
13375 arg2 = static_cast< int >(val2);
13376 ecode3 = SWIG_AsVal_int(obj2, &val3);
13377 if (!SWIG_IsOK(ecode3)) {
13378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13379 }
13380 arg3 = static_cast< int >(val3);
13381 {
13382 PyThreadState* __tstate = wxPyBeginAllowThreads();
13383 result = (arg1)->Scale(arg2,arg3);
13384 wxPyEndAllowThreads(__tstate);
13385 if (PyErr_Occurred()) SWIG_fail;
13386 }
13387 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13388 return resultobj;
13389 fail:
13390 return NULL;
13391 }
13392
13393
13394 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13395 PyObject *resultobj = 0;
13396 wxImage *arg1 = (wxImage *) 0 ;
13397 int arg2 ;
13398 int arg3 ;
13399 SwigValueWrapper<wxImage > result;
13400 void *argp1 = 0 ;
13401 int res1 = 0 ;
13402 int val2 ;
13403 int ecode2 = 0 ;
13404 int val3 ;
13405 int ecode3 = 0 ;
13406 PyObject * obj0 = 0 ;
13407 PyObject * obj1 = 0 ;
13408 PyObject * obj2 = 0 ;
13409 char * kwnames[] = {
13410 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13411 };
13412
13413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13415 if (!SWIG_IsOK(res1)) {
13416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13417 }
13418 arg1 = reinterpret_cast< wxImage * >(argp1);
13419 ecode2 = SWIG_AsVal_int(obj1, &val2);
13420 if (!SWIG_IsOK(ecode2)) {
13421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13422 }
13423 arg2 = static_cast< int >(val2);
13424 ecode3 = SWIG_AsVal_int(obj2, &val3);
13425 if (!SWIG_IsOK(ecode3)) {
13426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13427 }
13428 arg3 = static_cast< int >(val3);
13429 {
13430 PyThreadState* __tstate = wxPyBeginAllowThreads();
13431 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13432 wxPyEndAllowThreads(__tstate);
13433 if (PyErr_Occurred()) SWIG_fail;
13434 }
13435 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13436 return resultobj;
13437 fail:
13438 return NULL;
13439 }
13440
13441
13442 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13443 PyObject *resultobj = 0;
13444 wxImage *arg1 = (wxImage *) 0 ;
13445 int arg2 ;
13446 int arg3 ;
13447 wxImage *result = 0 ;
13448 void *argp1 = 0 ;
13449 int res1 = 0 ;
13450 int val2 ;
13451 int ecode2 = 0 ;
13452 int val3 ;
13453 int ecode3 = 0 ;
13454 PyObject * obj0 = 0 ;
13455 PyObject * obj1 = 0 ;
13456 PyObject * obj2 = 0 ;
13457 char * kwnames[] = {
13458 (char *) "self",(char *) "width",(char *) "height", NULL
13459 };
13460
13461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13463 if (!SWIG_IsOK(res1)) {
13464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13465 }
13466 arg1 = reinterpret_cast< wxImage * >(argp1);
13467 ecode2 = SWIG_AsVal_int(obj1, &val2);
13468 if (!SWIG_IsOK(ecode2)) {
13469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13470 }
13471 arg2 = static_cast< int >(val2);
13472 ecode3 = SWIG_AsVal_int(obj2, &val3);
13473 if (!SWIG_IsOK(ecode3)) {
13474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13475 }
13476 arg3 = static_cast< int >(val3);
13477 {
13478 PyThreadState* __tstate = wxPyBeginAllowThreads();
13479 {
13480 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13481 result = (wxImage *) &_result_ref;
13482 }
13483 wxPyEndAllowThreads(__tstate);
13484 if (PyErr_Occurred()) SWIG_fail;
13485 }
13486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13487 return resultobj;
13488 fail:
13489 return NULL;
13490 }
13491
13492
13493 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13494 PyObject *resultobj = 0;
13495 wxImage *arg1 = (wxImage *) 0 ;
13496 wxSize *arg2 = 0 ;
13497 wxPoint *arg3 = 0 ;
13498 int arg4 = (int) -1 ;
13499 int arg5 = (int) -1 ;
13500 int arg6 = (int) -1 ;
13501 wxImage *result = 0 ;
13502 void *argp1 = 0 ;
13503 int res1 = 0 ;
13504 wxSize temp2 ;
13505 wxPoint temp3 ;
13506 int val4 ;
13507 int ecode4 = 0 ;
13508 int val5 ;
13509 int ecode5 = 0 ;
13510 int val6 ;
13511 int ecode6 = 0 ;
13512 PyObject * obj0 = 0 ;
13513 PyObject * obj1 = 0 ;
13514 PyObject * obj2 = 0 ;
13515 PyObject * obj3 = 0 ;
13516 PyObject * obj4 = 0 ;
13517 PyObject * obj5 = 0 ;
13518 char * kwnames[] = {
13519 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13520 };
13521
13522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13524 if (!SWIG_IsOK(res1)) {
13525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13526 }
13527 arg1 = reinterpret_cast< wxImage * >(argp1);
13528 {
13529 arg2 = &temp2;
13530 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13531 }
13532 {
13533 arg3 = &temp3;
13534 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13535 }
13536 if (obj3) {
13537 ecode4 = SWIG_AsVal_int(obj3, &val4);
13538 if (!SWIG_IsOK(ecode4)) {
13539 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13540 }
13541 arg4 = static_cast< int >(val4);
13542 }
13543 if (obj4) {
13544 ecode5 = SWIG_AsVal_int(obj4, &val5);
13545 if (!SWIG_IsOK(ecode5)) {
13546 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13547 }
13548 arg5 = static_cast< int >(val5);
13549 }
13550 if (obj5) {
13551 ecode6 = SWIG_AsVal_int(obj5, &val6);
13552 if (!SWIG_IsOK(ecode6)) {
13553 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13554 }
13555 arg6 = static_cast< int >(val6);
13556 }
13557 {
13558 PyThreadState* __tstate = wxPyBeginAllowThreads();
13559 {
13560 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13561 result = (wxImage *) &_result_ref;
13562 }
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj = 0;
13575 wxImage *arg1 = (wxImage *) 0 ;
13576 int arg2 ;
13577 int arg3 ;
13578 byte arg4 ;
13579 byte arg5 ;
13580 byte arg6 ;
13581 void *argp1 = 0 ;
13582 int res1 = 0 ;
13583 int val2 ;
13584 int ecode2 = 0 ;
13585 int val3 ;
13586 int ecode3 = 0 ;
13587 unsigned char val4 ;
13588 int ecode4 = 0 ;
13589 unsigned char val5 ;
13590 int ecode5 = 0 ;
13591 unsigned char val6 ;
13592 int ecode6 = 0 ;
13593 PyObject * obj0 = 0 ;
13594 PyObject * obj1 = 0 ;
13595 PyObject * obj2 = 0 ;
13596 PyObject * obj3 = 0 ;
13597 PyObject * obj4 = 0 ;
13598 PyObject * obj5 = 0 ;
13599 char * kwnames[] = {
13600 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13601 };
13602
13603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13605 if (!SWIG_IsOK(res1)) {
13606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13607 }
13608 arg1 = reinterpret_cast< wxImage * >(argp1);
13609 ecode2 = SWIG_AsVal_int(obj1, &val2);
13610 if (!SWIG_IsOK(ecode2)) {
13611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13612 }
13613 arg2 = static_cast< int >(val2);
13614 ecode3 = SWIG_AsVal_int(obj2, &val3);
13615 if (!SWIG_IsOK(ecode3)) {
13616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13617 }
13618 arg3 = static_cast< int >(val3);
13619 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13620 if (!SWIG_IsOK(ecode4)) {
13621 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13622 }
13623 arg4 = static_cast< byte >(val4);
13624 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13625 if (!SWIG_IsOK(ecode5)) {
13626 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13627 }
13628 arg5 = static_cast< byte >(val5);
13629 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13630 if (!SWIG_IsOK(ecode6)) {
13631 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13632 }
13633 arg6 = static_cast< byte >(val6);
13634 {
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 resultobj = SWIG_Py_Void();
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj = 0;
13649 wxImage *arg1 = (wxImage *) 0 ;
13650 wxRect *arg2 = 0 ;
13651 byte arg3 ;
13652 byte arg4 ;
13653 byte arg5 ;
13654 void *argp1 = 0 ;
13655 int res1 = 0 ;
13656 wxRect temp2 ;
13657 unsigned char val3 ;
13658 int ecode3 = 0 ;
13659 unsigned char val4 ;
13660 int ecode4 = 0 ;
13661 unsigned char val5 ;
13662 int ecode5 = 0 ;
13663 PyObject * obj0 = 0 ;
13664 PyObject * obj1 = 0 ;
13665 PyObject * obj2 = 0 ;
13666 PyObject * obj3 = 0 ;
13667 PyObject * obj4 = 0 ;
13668 char * kwnames[] = {
13669 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13670 };
13671
13672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13674 if (!SWIG_IsOK(res1)) {
13675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13676 }
13677 arg1 = reinterpret_cast< wxImage * >(argp1);
13678 {
13679 arg2 = &temp2;
13680 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13681 }
13682 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13683 if (!SWIG_IsOK(ecode3)) {
13684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13685 }
13686 arg3 = static_cast< byte >(val3);
13687 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13688 if (!SWIG_IsOK(ecode4)) {
13689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13690 }
13691 arg4 = static_cast< byte >(val4);
13692 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13693 if (!SWIG_IsOK(ecode5)) {
13694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13695 }
13696 arg5 = static_cast< byte >(val5);
13697 {
13698 PyThreadState* __tstate = wxPyBeginAllowThreads();
13699 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13700 wxPyEndAllowThreads(__tstate);
13701 if (PyErr_Occurred()) SWIG_fail;
13702 }
13703 resultobj = SWIG_Py_Void();
13704 return resultobj;
13705 fail:
13706 return NULL;
13707 }
13708
13709
13710 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13711 PyObject *resultobj = 0;
13712 wxImage *arg1 = (wxImage *) 0 ;
13713 int arg2 ;
13714 int arg3 ;
13715 byte result;
13716 void *argp1 = 0 ;
13717 int res1 = 0 ;
13718 int val2 ;
13719 int ecode2 = 0 ;
13720 int val3 ;
13721 int ecode3 = 0 ;
13722 PyObject * obj0 = 0 ;
13723 PyObject * obj1 = 0 ;
13724 PyObject * obj2 = 0 ;
13725 char * kwnames[] = {
13726 (char *) "self",(char *) "x",(char *) "y", NULL
13727 };
13728
13729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13731 if (!SWIG_IsOK(res1)) {
13732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13733 }
13734 arg1 = reinterpret_cast< wxImage * >(argp1);
13735 ecode2 = SWIG_AsVal_int(obj1, &val2);
13736 if (!SWIG_IsOK(ecode2)) {
13737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13738 }
13739 arg2 = static_cast< int >(val2);
13740 ecode3 = SWIG_AsVal_int(obj2, &val3);
13741 if (!SWIG_IsOK(ecode3)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13743 }
13744 arg3 = static_cast< int >(val3);
13745 {
13746 PyThreadState* __tstate = wxPyBeginAllowThreads();
13747 result = (byte)(arg1)->GetRed(arg2,arg3);
13748 wxPyEndAllowThreads(__tstate);
13749 if (PyErr_Occurred()) SWIG_fail;
13750 }
13751 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13752 return resultobj;
13753 fail:
13754 return NULL;
13755 }
13756
13757
13758 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13759 PyObject *resultobj = 0;
13760 wxImage *arg1 = (wxImage *) 0 ;
13761 int arg2 ;
13762 int arg3 ;
13763 byte result;
13764 void *argp1 = 0 ;
13765 int res1 = 0 ;
13766 int val2 ;
13767 int ecode2 = 0 ;
13768 int val3 ;
13769 int ecode3 = 0 ;
13770 PyObject * obj0 = 0 ;
13771 PyObject * obj1 = 0 ;
13772 PyObject * obj2 = 0 ;
13773 char * kwnames[] = {
13774 (char *) "self",(char *) "x",(char *) "y", NULL
13775 };
13776
13777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13779 if (!SWIG_IsOK(res1)) {
13780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13781 }
13782 arg1 = reinterpret_cast< wxImage * >(argp1);
13783 ecode2 = SWIG_AsVal_int(obj1, &val2);
13784 if (!SWIG_IsOK(ecode2)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13786 }
13787 arg2 = static_cast< int >(val2);
13788 ecode3 = SWIG_AsVal_int(obj2, &val3);
13789 if (!SWIG_IsOK(ecode3)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13791 }
13792 arg3 = static_cast< int >(val3);
13793 {
13794 PyThreadState* __tstate = wxPyBeginAllowThreads();
13795 result = (byte)(arg1)->GetGreen(arg2,arg3);
13796 wxPyEndAllowThreads(__tstate);
13797 if (PyErr_Occurred()) SWIG_fail;
13798 }
13799 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13800 return resultobj;
13801 fail:
13802 return NULL;
13803 }
13804
13805
13806 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13807 PyObject *resultobj = 0;
13808 wxImage *arg1 = (wxImage *) 0 ;
13809 int arg2 ;
13810 int arg3 ;
13811 byte result;
13812 void *argp1 = 0 ;
13813 int res1 = 0 ;
13814 int val2 ;
13815 int ecode2 = 0 ;
13816 int val3 ;
13817 int ecode3 = 0 ;
13818 PyObject * obj0 = 0 ;
13819 PyObject * obj1 = 0 ;
13820 PyObject * obj2 = 0 ;
13821 char * kwnames[] = {
13822 (char *) "self",(char *) "x",(char *) "y", NULL
13823 };
13824
13825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13827 if (!SWIG_IsOK(res1)) {
13828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13829 }
13830 arg1 = reinterpret_cast< wxImage * >(argp1);
13831 ecode2 = SWIG_AsVal_int(obj1, &val2);
13832 if (!SWIG_IsOK(ecode2)) {
13833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13834 }
13835 arg2 = static_cast< int >(val2);
13836 ecode3 = SWIG_AsVal_int(obj2, &val3);
13837 if (!SWIG_IsOK(ecode3)) {
13838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13839 }
13840 arg3 = static_cast< int >(val3);
13841 {
13842 PyThreadState* __tstate = wxPyBeginAllowThreads();
13843 result = (byte)(arg1)->GetBlue(arg2,arg3);
13844 wxPyEndAllowThreads(__tstate);
13845 if (PyErr_Occurred()) SWIG_fail;
13846 }
13847 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13848 return resultobj;
13849 fail:
13850 return NULL;
13851 }
13852
13853
13854 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13855 PyObject *resultobj = 0;
13856 wxImage *arg1 = (wxImage *) 0 ;
13857 int arg2 ;
13858 int arg3 ;
13859 byte arg4 ;
13860 void *argp1 = 0 ;
13861 int res1 = 0 ;
13862 int val2 ;
13863 int ecode2 = 0 ;
13864 int val3 ;
13865 int ecode3 = 0 ;
13866 unsigned char val4 ;
13867 int ecode4 = 0 ;
13868 PyObject * obj0 = 0 ;
13869 PyObject * obj1 = 0 ;
13870 PyObject * obj2 = 0 ;
13871 PyObject * obj3 = 0 ;
13872 char * kwnames[] = {
13873 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13874 };
13875
13876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13878 if (!SWIG_IsOK(res1)) {
13879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13880 }
13881 arg1 = reinterpret_cast< wxImage * >(argp1);
13882 ecode2 = SWIG_AsVal_int(obj1, &val2);
13883 if (!SWIG_IsOK(ecode2)) {
13884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13885 }
13886 arg2 = static_cast< int >(val2);
13887 ecode3 = SWIG_AsVal_int(obj2, &val3);
13888 if (!SWIG_IsOK(ecode3)) {
13889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13890 }
13891 arg3 = static_cast< int >(val3);
13892 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13893 if (!SWIG_IsOK(ecode4)) {
13894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13895 }
13896 arg4 = static_cast< byte >(val4);
13897 {
13898 PyThreadState* __tstate = wxPyBeginAllowThreads();
13899 (arg1)->SetAlpha(arg2,arg3,arg4);
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 resultobj = SWIG_Py_Void();
13904 return resultobj;
13905 fail:
13906 return NULL;
13907 }
13908
13909
13910 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13911 PyObject *resultobj = 0;
13912 wxImage *arg1 = (wxImage *) 0 ;
13913 int arg2 ;
13914 int arg3 ;
13915 byte result;
13916 void *argp1 = 0 ;
13917 int res1 = 0 ;
13918 int val2 ;
13919 int ecode2 = 0 ;
13920 int val3 ;
13921 int ecode3 = 0 ;
13922 PyObject * obj0 = 0 ;
13923 PyObject * obj1 = 0 ;
13924 PyObject * obj2 = 0 ;
13925 char * kwnames[] = {
13926 (char *) "self",(char *) "x",(char *) "y", NULL
13927 };
13928
13929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13931 if (!SWIG_IsOK(res1)) {
13932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13933 }
13934 arg1 = reinterpret_cast< wxImage * >(argp1);
13935 ecode2 = SWIG_AsVal_int(obj1, &val2);
13936 if (!SWIG_IsOK(ecode2)) {
13937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13938 }
13939 arg2 = static_cast< int >(val2);
13940 ecode3 = SWIG_AsVal_int(obj2, &val3);
13941 if (!SWIG_IsOK(ecode3)) {
13942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13943 }
13944 arg3 = static_cast< int >(val3);
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13959 PyObject *resultobj = 0;
13960 wxImage *arg1 = (wxImage *) 0 ;
13961 bool result;
13962 void *argp1 = 0 ;
13963 int res1 = 0 ;
13964 PyObject *swig_obj[1] ;
13965
13966 if (!args) SWIG_fail;
13967 swig_obj[0] = args;
13968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13969 if (!SWIG_IsOK(res1)) {
13970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13971 }
13972 arg1 = reinterpret_cast< wxImage * >(argp1);
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (bool)(arg1)->HasAlpha();
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 {
13980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13981 }
13982 return resultobj;
13983 fail:
13984 return NULL;
13985 }
13986
13987
13988 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13989 PyObject *resultobj = 0;
13990 wxImage *arg1 = (wxImage *) 0 ;
13991 void *argp1 = 0 ;
13992 int res1 = 0 ;
13993 PyObject *swig_obj[1] ;
13994
13995 if (!args) SWIG_fail;
13996 swig_obj[0] = args;
13997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13998 if (!SWIG_IsOK(res1)) {
13999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14000 }
14001 arg1 = reinterpret_cast< wxImage * >(argp1);
14002 {
14003 PyThreadState* __tstate = wxPyBeginAllowThreads();
14004 (arg1)->InitAlpha();
14005 wxPyEndAllowThreads(__tstate);
14006 if (PyErr_Occurred()) SWIG_fail;
14007 }
14008 resultobj = SWIG_Py_Void();
14009 return resultobj;
14010 fail:
14011 return NULL;
14012 }
14013
14014
14015 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14016 PyObject *resultobj = 0;
14017 wxImage *arg1 = (wxImage *) 0 ;
14018 int arg2 ;
14019 int arg3 ;
14020 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14021 bool result;
14022 void *argp1 = 0 ;
14023 int res1 = 0 ;
14024 int val2 ;
14025 int ecode2 = 0 ;
14026 int val3 ;
14027 int ecode3 = 0 ;
14028 unsigned char val4 ;
14029 int ecode4 = 0 ;
14030 PyObject * obj0 = 0 ;
14031 PyObject * obj1 = 0 ;
14032 PyObject * obj2 = 0 ;
14033 PyObject * obj3 = 0 ;
14034 char * kwnames[] = {
14035 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14036 };
14037
14038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14040 if (!SWIG_IsOK(res1)) {
14041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14042 }
14043 arg1 = reinterpret_cast< wxImage * >(argp1);
14044 ecode2 = SWIG_AsVal_int(obj1, &val2);
14045 if (!SWIG_IsOK(ecode2)) {
14046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14047 }
14048 arg2 = static_cast< int >(val2);
14049 ecode3 = SWIG_AsVal_int(obj2, &val3);
14050 if (!SWIG_IsOK(ecode3)) {
14051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14052 }
14053 arg3 = static_cast< int >(val3);
14054 if (obj3) {
14055 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14056 if (!SWIG_IsOK(ecode4)) {
14057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14058 }
14059 arg4 = static_cast< byte >(val4);
14060 }
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 {
14068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14069 }
14070 return resultobj;
14071 fail:
14072 return NULL;
14073 }
14074
14075
14076 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14077 PyObject *resultobj = 0;
14078 wxImage *arg1 = (wxImage *) 0 ;
14079 byte *arg2 = (byte *) 0 ;
14080 byte *arg3 = (byte *) 0 ;
14081 byte *arg4 = (byte *) 0 ;
14082 byte arg5 = (byte) 0 ;
14083 byte arg6 = (byte) 0 ;
14084 byte arg7 = (byte) 0 ;
14085 bool result;
14086 void *argp1 = 0 ;
14087 int res1 = 0 ;
14088 byte temp2 ;
14089 int res2 = SWIG_TMPOBJ ;
14090 byte temp3 ;
14091 int res3 = SWIG_TMPOBJ ;
14092 byte temp4 ;
14093 int res4 = SWIG_TMPOBJ ;
14094 unsigned char val5 ;
14095 int ecode5 = 0 ;
14096 unsigned char val6 ;
14097 int ecode6 = 0 ;
14098 unsigned char val7 ;
14099 int ecode7 = 0 ;
14100 PyObject * obj0 = 0 ;
14101 PyObject * obj1 = 0 ;
14102 PyObject * obj2 = 0 ;
14103 PyObject * obj3 = 0 ;
14104 char * kwnames[] = {
14105 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14106 };
14107
14108 arg2 = &temp2;
14109 arg3 = &temp3;
14110 arg4 = &temp4;
14111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14113 if (!SWIG_IsOK(res1)) {
14114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14115 }
14116 arg1 = reinterpret_cast< wxImage * >(argp1);
14117 if (obj1) {
14118 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14119 if (!SWIG_IsOK(ecode5)) {
14120 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14121 }
14122 arg5 = static_cast< byte >(val5);
14123 }
14124 if (obj2) {
14125 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14126 if (!SWIG_IsOK(ecode6)) {
14127 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14128 }
14129 arg6 = static_cast< byte >(val6);
14130 }
14131 if (obj3) {
14132 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14133 if (!SWIG_IsOK(ecode7)) {
14134 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14135 }
14136 arg7 = static_cast< byte >(val7);
14137 }
14138 {
14139 PyThreadState* __tstate = wxPyBeginAllowThreads();
14140 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 {
14145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14146 }
14147 if (SWIG_IsTmpObj(res2)) {
14148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14149 } else {
14150 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14152 }
14153 if (SWIG_IsTmpObj(res3)) {
14154 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14155 } else {
14156 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14157 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14158 }
14159 if (SWIG_IsTmpObj(res4)) {
14160 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14161 } else {
14162 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14163 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14164 }
14165 return resultobj;
14166 fail:
14167 return NULL;
14168 }
14169
14170
14171 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14172 PyObject *resultobj = 0;
14173 wxImage *arg1 = (wxImage *) 0 ;
14174 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14175 bool result;
14176 void *argp1 = 0 ;
14177 int res1 = 0 ;
14178 unsigned char val2 ;
14179 int ecode2 = 0 ;
14180 PyObject * obj0 = 0 ;
14181 PyObject * obj1 = 0 ;
14182 char * kwnames[] = {
14183 (char *) "self",(char *) "threshold", NULL
14184 };
14185
14186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14188 if (!SWIG_IsOK(res1)) {
14189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14190 }
14191 arg1 = reinterpret_cast< wxImage * >(argp1);
14192 if (obj1) {
14193 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14194 if (!SWIG_IsOK(ecode2)) {
14195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14196 }
14197 arg2 = static_cast< byte >(val2);
14198 }
14199 {
14200 PyThreadState* __tstate = wxPyBeginAllowThreads();
14201 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14202 wxPyEndAllowThreads(__tstate);
14203 if (PyErr_Occurred()) SWIG_fail;
14204 }
14205 {
14206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14207 }
14208 return resultobj;
14209 fail:
14210 return NULL;
14211 }
14212
14213
14214 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14215 PyObject *resultobj = 0;
14216 wxImage *arg1 = (wxImage *) 0 ;
14217 byte arg2 ;
14218 byte arg3 ;
14219 byte arg4 ;
14220 bool result;
14221 void *argp1 = 0 ;
14222 int res1 = 0 ;
14223 unsigned char val2 ;
14224 int ecode2 = 0 ;
14225 unsigned char val3 ;
14226 int ecode3 = 0 ;
14227 unsigned char val4 ;
14228 int ecode4 = 0 ;
14229 PyObject * obj0 = 0 ;
14230 PyObject * obj1 = 0 ;
14231 PyObject * obj2 = 0 ;
14232 PyObject * obj3 = 0 ;
14233 char * kwnames[] = {
14234 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14235 };
14236
14237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14239 if (!SWIG_IsOK(res1)) {
14240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14241 }
14242 arg1 = reinterpret_cast< wxImage * >(argp1);
14243 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14244 if (!SWIG_IsOK(ecode2)) {
14245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14246 }
14247 arg2 = static_cast< byte >(val2);
14248 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14249 if (!SWIG_IsOK(ecode3)) {
14250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14251 }
14252 arg3 = static_cast< byte >(val3);
14253 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14254 if (!SWIG_IsOK(ecode4)) {
14255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14256 }
14257 arg4 = static_cast< byte >(val4);
14258 {
14259 PyThreadState* __tstate = wxPyBeginAllowThreads();
14260 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14261 wxPyEndAllowThreads(__tstate);
14262 if (PyErr_Occurred()) SWIG_fail;
14263 }
14264 {
14265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14266 }
14267 return resultobj;
14268 fail:
14269 return NULL;
14270 }
14271
14272
14273 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14274 PyObject *resultobj = 0;
14275 wxImage *arg1 = (wxImage *) 0 ;
14276 wxImage *arg2 = 0 ;
14277 byte arg3 ;
14278 byte arg4 ;
14279 byte arg5 ;
14280 bool result;
14281 void *argp1 = 0 ;
14282 int res1 = 0 ;
14283 void *argp2 = 0 ;
14284 int res2 = 0 ;
14285 unsigned char val3 ;
14286 int ecode3 = 0 ;
14287 unsigned char val4 ;
14288 int ecode4 = 0 ;
14289 unsigned char val5 ;
14290 int ecode5 = 0 ;
14291 PyObject * obj0 = 0 ;
14292 PyObject * obj1 = 0 ;
14293 PyObject * obj2 = 0 ;
14294 PyObject * obj3 = 0 ;
14295 PyObject * obj4 = 0 ;
14296 char * kwnames[] = {
14297 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14298 };
14299
14300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14302 if (!SWIG_IsOK(res1)) {
14303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14304 }
14305 arg1 = reinterpret_cast< wxImage * >(argp1);
14306 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14307 if (!SWIG_IsOK(res2)) {
14308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14309 }
14310 if (!argp2) {
14311 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14312 }
14313 arg2 = reinterpret_cast< wxImage * >(argp2);
14314 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14315 if (!SWIG_IsOK(ecode3)) {
14316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14317 }
14318 arg3 = static_cast< byte >(val3);
14319 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14320 if (!SWIG_IsOK(ecode4)) {
14321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14322 }
14323 arg4 = static_cast< byte >(val4);
14324 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14325 if (!SWIG_IsOK(ecode5)) {
14326 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14327 }
14328 arg5 = static_cast< byte >(val5);
14329 {
14330 PyThreadState* __tstate = wxPyBeginAllowThreads();
14331 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14332 wxPyEndAllowThreads(__tstate);
14333 if (PyErr_Occurred()) SWIG_fail;
14334 }
14335 {
14336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14337 }
14338 return resultobj;
14339 fail:
14340 return NULL;
14341 }
14342
14343
14344 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14345 PyObject *resultobj = 0;
14346 wxString *arg1 = 0 ;
14347 bool result;
14348 bool temp1 = false ;
14349 PyObject * obj0 = 0 ;
14350 char * kwnames[] = {
14351 (char *) "filename", NULL
14352 };
14353
14354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14355 {
14356 arg1 = wxString_in_helper(obj0);
14357 if (arg1 == NULL) SWIG_fail;
14358 temp1 = true;
14359 }
14360 {
14361 PyThreadState* __tstate = wxPyBeginAllowThreads();
14362 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14363 wxPyEndAllowThreads(__tstate);
14364 if (PyErr_Occurred()) SWIG_fail;
14365 }
14366 {
14367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14368 }
14369 {
14370 if (temp1)
14371 delete arg1;
14372 }
14373 return resultobj;
14374 fail:
14375 {
14376 if (temp1)
14377 delete arg1;
14378 }
14379 return NULL;
14380 }
14381
14382
14383 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj = 0;
14385 wxString *arg1 = 0 ;
14386 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14387 int result;
14388 bool temp1 = false ;
14389 long val2 ;
14390 int ecode2 = 0 ;
14391 PyObject * obj0 = 0 ;
14392 PyObject * obj1 = 0 ;
14393 char * kwnames[] = {
14394 (char *) "filename",(char *) "type", NULL
14395 };
14396
14397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14398 {
14399 arg1 = wxString_in_helper(obj0);
14400 if (arg1 == NULL) SWIG_fail;
14401 temp1 = true;
14402 }
14403 if (obj1) {
14404 ecode2 = SWIG_AsVal_long(obj1, &val2);
14405 if (!SWIG_IsOK(ecode2)) {
14406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14407 }
14408 arg2 = static_cast< long >(val2);
14409 }
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14413 wxPyEndAllowThreads(__tstate);
14414 if (PyErr_Occurred()) SWIG_fail;
14415 }
14416 resultobj = SWIG_From_int(static_cast< int >(result));
14417 {
14418 if (temp1)
14419 delete arg1;
14420 }
14421 return resultobj;
14422 fail:
14423 {
14424 if (temp1)
14425 delete arg1;
14426 }
14427 return NULL;
14428 }
14429
14430
14431 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14432 PyObject *resultobj = 0;
14433 wxImage *arg1 = (wxImage *) 0 ;
14434 wxString *arg2 = 0 ;
14435 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14436 int arg4 = (int) -1 ;
14437 bool result;
14438 void *argp1 = 0 ;
14439 int res1 = 0 ;
14440 bool temp2 = false ;
14441 long val3 ;
14442 int ecode3 = 0 ;
14443 int val4 ;
14444 int ecode4 = 0 ;
14445 PyObject * obj0 = 0 ;
14446 PyObject * obj1 = 0 ;
14447 PyObject * obj2 = 0 ;
14448 PyObject * obj3 = 0 ;
14449 char * kwnames[] = {
14450 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14451 };
14452
14453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14455 if (!SWIG_IsOK(res1)) {
14456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14457 }
14458 arg1 = reinterpret_cast< wxImage * >(argp1);
14459 {
14460 arg2 = wxString_in_helper(obj1);
14461 if (arg2 == NULL) SWIG_fail;
14462 temp2 = true;
14463 }
14464 if (obj2) {
14465 ecode3 = SWIG_AsVal_long(obj2, &val3);
14466 if (!SWIG_IsOK(ecode3)) {
14467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14468 }
14469 arg3 = static_cast< long >(val3);
14470 }
14471 if (obj3) {
14472 ecode4 = SWIG_AsVal_int(obj3, &val4);
14473 if (!SWIG_IsOK(ecode4)) {
14474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14475 }
14476 arg4 = static_cast< int >(val4);
14477 }
14478 {
14479 PyThreadState* __tstate = wxPyBeginAllowThreads();
14480 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14481 wxPyEndAllowThreads(__tstate);
14482 if (PyErr_Occurred()) SWIG_fail;
14483 }
14484 {
14485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14486 }
14487 {
14488 if (temp2)
14489 delete arg2;
14490 }
14491 return resultobj;
14492 fail:
14493 {
14494 if (temp2)
14495 delete arg2;
14496 }
14497 return NULL;
14498 }
14499
14500
14501 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14502 PyObject *resultobj = 0;
14503 wxImage *arg1 = (wxImage *) 0 ;
14504 wxString *arg2 = 0 ;
14505 wxString *arg3 = 0 ;
14506 int arg4 = (int) -1 ;
14507 bool result;
14508 void *argp1 = 0 ;
14509 int res1 = 0 ;
14510 bool temp2 = false ;
14511 bool temp3 = false ;
14512 int val4 ;
14513 int ecode4 = 0 ;
14514 PyObject * obj0 = 0 ;
14515 PyObject * obj1 = 0 ;
14516 PyObject * obj2 = 0 ;
14517 PyObject * obj3 = 0 ;
14518 char * kwnames[] = {
14519 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14520 };
14521
14522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14524 if (!SWIG_IsOK(res1)) {
14525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14526 }
14527 arg1 = reinterpret_cast< wxImage * >(argp1);
14528 {
14529 arg2 = wxString_in_helper(obj1);
14530 if (arg2 == NULL) SWIG_fail;
14531 temp2 = true;
14532 }
14533 {
14534 arg3 = wxString_in_helper(obj2);
14535 if (arg3 == NULL) SWIG_fail;
14536 temp3 = true;
14537 }
14538 if (obj3) {
14539 ecode4 = SWIG_AsVal_int(obj3, &val4);
14540 if (!SWIG_IsOK(ecode4)) {
14541 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14542 }
14543 arg4 = static_cast< int >(val4);
14544 }
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 {
14552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14553 }
14554 {
14555 if (temp2)
14556 delete arg2;
14557 }
14558 {
14559 if (temp3)
14560 delete arg3;
14561 }
14562 return resultobj;
14563 fail:
14564 {
14565 if (temp2)
14566 delete arg2;
14567 }
14568 {
14569 if (temp3)
14570 delete arg3;
14571 }
14572 return NULL;
14573 }
14574
14575
14576 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14577 PyObject *resultobj = 0;
14578 wxImage *arg1 = (wxImage *) 0 ;
14579 wxString *arg2 = 0 ;
14580 int arg3 ;
14581 bool result;
14582 void *argp1 = 0 ;
14583 int res1 = 0 ;
14584 bool temp2 = false ;
14585 int val3 ;
14586 int ecode3 = 0 ;
14587 PyObject * obj0 = 0 ;
14588 PyObject * obj1 = 0 ;
14589 PyObject * obj2 = 0 ;
14590 char * kwnames[] = {
14591 (char *) "self",(char *) "name",(char *) "type", NULL
14592 };
14593
14594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14596 if (!SWIG_IsOK(res1)) {
14597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14598 }
14599 arg1 = reinterpret_cast< wxImage * >(argp1);
14600 {
14601 arg2 = wxString_in_helper(obj1);
14602 if (arg2 == NULL) SWIG_fail;
14603 temp2 = true;
14604 }
14605 ecode3 = SWIG_AsVal_int(obj2, &val3);
14606 if (!SWIG_IsOK(ecode3)) {
14607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14608 }
14609 arg3 = static_cast< int >(val3);
14610 {
14611 PyThreadState* __tstate = wxPyBeginAllowThreads();
14612 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14613 wxPyEndAllowThreads(__tstate);
14614 if (PyErr_Occurred()) SWIG_fail;
14615 }
14616 {
14617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14618 }
14619 {
14620 if (temp2)
14621 delete arg2;
14622 }
14623 return resultobj;
14624 fail:
14625 {
14626 if (temp2)
14627 delete arg2;
14628 }
14629 return NULL;
14630 }
14631
14632
14633 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14634 PyObject *resultobj = 0;
14635 wxImage *arg1 = (wxImage *) 0 ;
14636 wxString *arg2 = 0 ;
14637 wxString *arg3 = 0 ;
14638 bool result;
14639 void *argp1 = 0 ;
14640 int res1 = 0 ;
14641 bool temp2 = false ;
14642 bool temp3 = false ;
14643 PyObject * obj0 = 0 ;
14644 PyObject * obj1 = 0 ;
14645 PyObject * obj2 = 0 ;
14646 char * kwnames[] = {
14647 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14648 };
14649
14650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14652 if (!SWIG_IsOK(res1)) {
14653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14654 }
14655 arg1 = reinterpret_cast< wxImage * >(argp1);
14656 {
14657 arg2 = wxString_in_helper(obj1);
14658 if (arg2 == NULL) SWIG_fail;
14659 temp2 = true;
14660 }
14661 {
14662 arg3 = wxString_in_helper(obj2);
14663 if (arg3 == NULL) SWIG_fail;
14664 temp3 = true;
14665 }
14666 {
14667 PyThreadState* __tstate = wxPyBeginAllowThreads();
14668 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14669 wxPyEndAllowThreads(__tstate);
14670 if (PyErr_Occurred()) SWIG_fail;
14671 }
14672 {
14673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14674 }
14675 {
14676 if (temp2)
14677 delete arg2;
14678 }
14679 {
14680 if (temp3)
14681 delete arg3;
14682 }
14683 return resultobj;
14684 fail:
14685 {
14686 if (temp2)
14687 delete arg2;
14688 }
14689 {
14690 if (temp3)
14691 delete arg3;
14692 }
14693 return NULL;
14694 }
14695
14696
14697 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14698 PyObject *resultobj = 0;
14699 wxInputStream *arg1 = 0 ;
14700 bool result;
14701 wxPyInputStream *temp1 ;
14702 bool created1 ;
14703 PyObject * obj0 = 0 ;
14704 char * kwnames[] = {
14705 (char *) "stream", NULL
14706 };
14707
14708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14709 {
14710 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14711 arg1 = temp1->m_wxis;
14712 created1 = false;
14713 } else {
14714 PyErr_Clear(); // clear the failure of the wxPyConvert above
14715 arg1 = wxPyCBInputStream_create(obj0, false);
14716 if (arg1 == NULL) {
14717 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14718 SWIG_fail;
14719 }
14720 created1 = true;
14721 }
14722 }
14723 {
14724 PyThreadState* __tstate = wxPyBeginAllowThreads();
14725 result = (bool)wxImage::CanRead(*arg1);
14726 wxPyEndAllowThreads(__tstate);
14727 if (PyErr_Occurred()) SWIG_fail;
14728 }
14729 {
14730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14731 }
14732 {
14733 if (created1) delete arg1;
14734 }
14735 return resultobj;
14736 fail:
14737 {
14738 if (created1) delete arg1;
14739 }
14740 return NULL;
14741 }
14742
14743
14744 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14745 PyObject *resultobj = 0;
14746 wxImage *arg1 = (wxImage *) 0 ;
14747 wxInputStream *arg2 = 0 ;
14748 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14749 int arg4 = (int) -1 ;
14750 bool result;
14751 void *argp1 = 0 ;
14752 int res1 = 0 ;
14753 wxPyInputStream *temp2 ;
14754 bool created2 ;
14755 long val3 ;
14756 int ecode3 = 0 ;
14757 int val4 ;
14758 int ecode4 = 0 ;
14759 PyObject * obj0 = 0 ;
14760 PyObject * obj1 = 0 ;
14761 PyObject * obj2 = 0 ;
14762 PyObject * obj3 = 0 ;
14763 char * kwnames[] = {
14764 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14765 };
14766
14767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14769 if (!SWIG_IsOK(res1)) {
14770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14771 }
14772 arg1 = reinterpret_cast< wxImage * >(argp1);
14773 {
14774 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14775 arg2 = temp2->m_wxis;
14776 created2 = false;
14777 } else {
14778 PyErr_Clear(); // clear the failure of the wxPyConvert above
14779 arg2 = wxPyCBInputStream_create(obj1, false);
14780 if (arg2 == NULL) {
14781 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14782 SWIG_fail;
14783 }
14784 created2 = true;
14785 }
14786 }
14787 if (obj2) {
14788 ecode3 = SWIG_AsVal_long(obj2, &val3);
14789 if (!SWIG_IsOK(ecode3)) {
14790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14791 }
14792 arg3 = static_cast< long >(val3);
14793 }
14794 if (obj3) {
14795 ecode4 = SWIG_AsVal_int(obj3, &val4);
14796 if (!SWIG_IsOK(ecode4)) {
14797 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14798 }
14799 arg4 = static_cast< int >(val4);
14800 }
14801 {
14802 PyThreadState* __tstate = wxPyBeginAllowThreads();
14803 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14804 wxPyEndAllowThreads(__tstate);
14805 if (PyErr_Occurred()) SWIG_fail;
14806 }
14807 {
14808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14809 }
14810 {
14811 if (created2) delete arg2;
14812 }
14813 return resultobj;
14814 fail:
14815 {
14816 if (created2) delete arg2;
14817 }
14818 return NULL;
14819 }
14820
14821
14822 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14823 PyObject *resultobj = 0;
14824 wxImage *arg1 = (wxImage *) 0 ;
14825 wxInputStream *arg2 = 0 ;
14826 wxString *arg3 = 0 ;
14827 int arg4 = (int) -1 ;
14828 bool result;
14829 void *argp1 = 0 ;
14830 int res1 = 0 ;
14831 wxPyInputStream *temp2 ;
14832 bool created2 ;
14833 bool temp3 = false ;
14834 int val4 ;
14835 int ecode4 = 0 ;
14836 PyObject * obj0 = 0 ;
14837 PyObject * obj1 = 0 ;
14838 PyObject * obj2 = 0 ;
14839 PyObject * obj3 = 0 ;
14840 char * kwnames[] = {
14841 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14842 };
14843
14844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14846 if (!SWIG_IsOK(res1)) {
14847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14848 }
14849 arg1 = reinterpret_cast< wxImage * >(argp1);
14850 {
14851 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14852 arg2 = temp2->m_wxis;
14853 created2 = false;
14854 } else {
14855 PyErr_Clear(); // clear the failure of the wxPyConvert above
14856 arg2 = wxPyCBInputStream_create(obj1, false);
14857 if (arg2 == NULL) {
14858 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14859 SWIG_fail;
14860 }
14861 created2 = true;
14862 }
14863 }
14864 {
14865 arg3 = wxString_in_helper(obj2);
14866 if (arg3 == NULL) SWIG_fail;
14867 temp3 = true;
14868 }
14869 if (obj3) {
14870 ecode4 = SWIG_AsVal_int(obj3, &val4);
14871 if (!SWIG_IsOK(ecode4)) {
14872 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14873 }
14874 arg4 = static_cast< int >(val4);
14875 }
14876 {
14877 PyThreadState* __tstate = wxPyBeginAllowThreads();
14878 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14879 wxPyEndAllowThreads(__tstate);
14880 if (PyErr_Occurred()) SWIG_fail;
14881 }
14882 {
14883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14884 }
14885 {
14886 if (created2) delete arg2;
14887 }
14888 {
14889 if (temp3)
14890 delete arg3;
14891 }
14892 return resultobj;
14893 fail:
14894 {
14895 if (created2) delete arg2;
14896 }
14897 {
14898 if (temp3)
14899 delete arg3;
14900 }
14901 return NULL;
14902 }
14903
14904
14905 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14906 PyObject *resultobj = 0;
14907 wxImage *arg1 = (wxImage *) 0 ;
14908 bool result;
14909 void *argp1 = 0 ;
14910 int res1 = 0 ;
14911 PyObject *swig_obj[1] ;
14912
14913 if (!args) SWIG_fail;
14914 swig_obj[0] = args;
14915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14916 if (!SWIG_IsOK(res1)) {
14917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14918 }
14919 arg1 = reinterpret_cast< wxImage * >(argp1);
14920 {
14921 PyThreadState* __tstate = wxPyBeginAllowThreads();
14922 result = (bool)(arg1)->Ok();
14923 wxPyEndAllowThreads(__tstate);
14924 if (PyErr_Occurred()) SWIG_fail;
14925 }
14926 {
14927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14928 }
14929 return resultobj;
14930 fail:
14931 return NULL;
14932 }
14933
14934
14935 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14936 PyObject *resultobj = 0;
14937 wxImage *arg1 = (wxImage *) 0 ;
14938 int result;
14939 void *argp1 = 0 ;
14940 int res1 = 0 ;
14941 PyObject *swig_obj[1] ;
14942
14943 if (!args) SWIG_fail;
14944 swig_obj[0] = args;
14945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14946 if (!SWIG_IsOK(res1)) {
14947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14948 }
14949 arg1 = reinterpret_cast< wxImage * >(argp1);
14950 {
14951 PyThreadState* __tstate = wxPyBeginAllowThreads();
14952 result = (int)(arg1)->GetWidth();
14953 wxPyEndAllowThreads(__tstate);
14954 if (PyErr_Occurred()) SWIG_fail;
14955 }
14956 resultobj = SWIG_From_int(static_cast< int >(result));
14957 return resultobj;
14958 fail:
14959 return NULL;
14960 }
14961
14962
14963 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14964 PyObject *resultobj = 0;
14965 wxImage *arg1 = (wxImage *) 0 ;
14966 int result;
14967 void *argp1 = 0 ;
14968 int res1 = 0 ;
14969 PyObject *swig_obj[1] ;
14970
14971 if (!args) SWIG_fail;
14972 swig_obj[0] = args;
14973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14974 if (!SWIG_IsOK(res1)) {
14975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
14976 }
14977 arg1 = reinterpret_cast< wxImage * >(argp1);
14978 {
14979 PyThreadState* __tstate = wxPyBeginAllowThreads();
14980 result = (int)(arg1)->GetHeight();
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 resultobj = SWIG_From_int(static_cast< int >(result));
14985 return resultobj;
14986 fail:
14987 return NULL;
14988 }
14989
14990
14991 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14992 PyObject *resultobj = 0;
14993 wxImage *arg1 = (wxImage *) 0 ;
14994 wxSize result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 PyObject *swig_obj[1] ;
14998
14999 if (!args) SWIG_fail;
15000 swig_obj[0] = args;
15001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15002 if (!SWIG_IsOK(res1)) {
15003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15004 }
15005 arg1 = reinterpret_cast< wxImage * >(argp1);
15006 {
15007 PyThreadState* __tstate = wxPyBeginAllowThreads();
15008 result = wxImage_GetSize(arg1);
15009 wxPyEndAllowThreads(__tstate);
15010 if (PyErr_Occurred()) SWIG_fail;
15011 }
15012 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15013 return resultobj;
15014 fail:
15015 return NULL;
15016 }
15017
15018
15019 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15020 PyObject *resultobj = 0;
15021 wxImage *arg1 = (wxImage *) 0 ;
15022 wxRect *arg2 = 0 ;
15023 SwigValueWrapper<wxImage > result;
15024 void *argp1 = 0 ;
15025 int res1 = 0 ;
15026 wxRect temp2 ;
15027 PyObject * obj0 = 0 ;
15028 PyObject * obj1 = 0 ;
15029 char * kwnames[] = {
15030 (char *) "self",(char *) "rect", NULL
15031 };
15032
15033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15035 if (!SWIG_IsOK(res1)) {
15036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15037 }
15038 arg1 = reinterpret_cast< wxImage * >(argp1);
15039 {
15040 arg2 = &temp2;
15041 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15042 }
15043 {
15044 PyThreadState* __tstate = wxPyBeginAllowThreads();
15045 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15046 wxPyEndAllowThreads(__tstate);
15047 if (PyErr_Occurred()) SWIG_fail;
15048 }
15049 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15050 return resultobj;
15051 fail:
15052 return NULL;
15053 }
15054
15055
15056 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15057 PyObject *resultobj = 0;
15058 wxImage *arg1 = (wxImage *) 0 ;
15059 wxSize *arg2 = 0 ;
15060 wxPoint *arg3 = 0 ;
15061 int arg4 = (int) -1 ;
15062 int arg5 = (int) -1 ;
15063 int arg6 = (int) -1 ;
15064 SwigValueWrapper<wxImage > result;
15065 void *argp1 = 0 ;
15066 int res1 = 0 ;
15067 wxSize temp2 ;
15068 wxPoint temp3 ;
15069 int val4 ;
15070 int ecode4 = 0 ;
15071 int val5 ;
15072 int ecode5 = 0 ;
15073 int val6 ;
15074 int ecode6 = 0 ;
15075 PyObject * obj0 = 0 ;
15076 PyObject * obj1 = 0 ;
15077 PyObject * obj2 = 0 ;
15078 PyObject * obj3 = 0 ;
15079 PyObject * obj4 = 0 ;
15080 PyObject * obj5 = 0 ;
15081 char * kwnames[] = {
15082 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15083 };
15084
15085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15087 if (!SWIG_IsOK(res1)) {
15088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15089 }
15090 arg1 = reinterpret_cast< wxImage * >(argp1);
15091 {
15092 arg2 = &temp2;
15093 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15094 }
15095 {
15096 arg3 = &temp3;
15097 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15098 }
15099 if (obj3) {
15100 ecode4 = SWIG_AsVal_int(obj3, &val4);
15101 if (!SWIG_IsOK(ecode4)) {
15102 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15103 }
15104 arg4 = static_cast< int >(val4);
15105 }
15106 if (obj4) {
15107 ecode5 = SWIG_AsVal_int(obj4, &val5);
15108 if (!SWIG_IsOK(ecode5)) {
15109 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15110 }
15111 arg5 = static_cast< int >(val5);
15112 }
15113 if (obj5) {
15114 ecode6 = SWIG_AsVal_int(obj5, &val6);
15115 if (!SWIG_IsOK(ecode6)) {
15116 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15117 }
15118 arg6 = static_cast< int >(val6);
15119 }
15120 {
15121 PyThreadState* __tstate = wxPyBeginAllowThreads();
15122 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15127 return resultobj;
15128 fail:
15129 return NULL;
15130 }
15131
15132
15133 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15134 PyObject *resultobj = 0;
15135 wxImage *arg1 = (wxImage *) 0 ;
15136 SwigValueWrapper<wxImage > result;
15137 void *argp1 = 0 ;
15138 int res1 = 0 ;
15139 PyObject *swig_obj[1] ;
15140
15141 if (!args) SWIG_fail;
15142 swig_obj[0] = args;
15143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15144 if (!SWIG_IsOK(res1)) {
15145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15146 }
15147 arg1 = reinterpret_cast< wxImage * >(argp1);
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 result = (arg1)->Copy();
15151 wxPyEndAllowThreads(__tstate);
15152 if (PyErr_Occurred()) SWIG_fail;
15153 }
15154 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15155 return resultobj;
15156 fail:
15157 return NULL;
15158 }
15159
15160
15161 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15162 PyObject *resultobj = 0;
15163 wxImage *arg1 = (wxImage *) 0 ;
15164 wxImage *arg2 = 0 ;
15165 int arg3 ;
15166 int arg4 ;
15167 void *argp1 = 0 ;
15168 int res1 = 0 ;
15169 void *argp2 = 0 ;
15170 int res2 = 0 ;
15171 int val3 ;
15172 int ecode3 = 0 ;
15173 int val4 ;
15174 int ecode4 = 0 ;
15175 PyObject * obj0 = 0 ;
15176 PyObject * obj1 = 0 ;
15177 PyObject * obj2 = 0 ;
15178 PyObject * obj3 = 0 ;
15179 char * kwnames[] = {
15180 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15181 };
15182
15183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15185 if (!SWIG_IsOK(res1)) {
15186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15187 }
15188 arg1 = reinterpret_cast< wxImage * >(argp1);
15189 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15190 if (!SWIG_IsOK(res2)) {
15191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15192 }
15193 if (!argp2) {
15194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15195 }
15196 arg2 = reinterpret_cast< wxImage * >(argp2);
15197 ecode3 = SWIG_AsVal_int(obj2, &val3);
15198 if (!SWIG_IsOK(ecode3)) {
15199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15200 }
15201 arg3 = static_cast< int >(val3);
15202 ecode4 = SWIG_AsVal_int(obj3, &val4);
15203 if (!SWIG_IsOK(ecode4)) {
15204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15205 }
15206 arg4 = static_cast< int >(val4);
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 resultobj = SWIG_Py_Void();
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15221 PyObject *resultobj = 0;
15222 wxImage *arg1 = (wxImage *) 0 ;
15223 PyObject *result = 0 ;
15224 void *argp1 = 0 ;
15225 int res1 = 0 ;
15226 PyObject *swig_obj[1] ;
15227
15228 if (!args) SWIG_fail;
15229 swig_obj[0] = args;
15230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15231 if (!SWIG_IsOK(res1)) {
15232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15233 }
15234 arg1 = reinterpret_cast< wxImage * >(argp1);
15235 {
15236 PyThreadState* __tstate = wxPyBeginAllowThreads();
15237 result = (PyObject *)wxImage_GetData(arg1);
15238 wxPyEndAllowThreads(__tstate);
15239 if (PyErr_Occurred()) SWIG_fail;
15240 }
15241 resultobj = result;
15242 return resultobj;
15243 fail:
15244 return NULL;
15245 }
15246
15247
15248 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15249 PyObject *resultobj = 0;
15250 wxImage *arg1 = (wxImage *) 0 ;
15251 buffer arg2 ;
15252 int arg3 ;
15253 void *argp1 = 0 ;
15254 int res1 = 0 ;
15255 PyObject * obj0 = 0 ;
15256 PyObject * obj1 = 0 ;
15257 char * kwnames[] = {
15258 (char *) "self",(char *) "data", NULL
15259 };
15260
15261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15263 if (!SWIG_IsOK(res1)) {
15264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15265 }
15266 arg1 = reinterpret_cast< wxImage * >(argp1);
15267 {
15268 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15269 }
15270 {
15271 PyThreadState* __tstate = wxPyBeginAllowThreads();
15272 wxImage_SetData(arg1,arg2,arg3);
15273 wxPyEndAllowThreads(__tstate);
15274 if (PyErr_Occurred()) SWIG_fail;
15275 }
15276 resultobj = SWIG_Py_Void();
15277 return resultobj;
15278 fail:
15279 return NULL;
15280 }
15281
15282
15283 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15284 PyObject *resultobj = 0;
15285 wxImage *arg1 = (wxImage *) 0 ;
15286 PyObject *result = 0 ;
15287 void *argp1 = 0 ;
15288 int res1 = 0 ;
15289 PyObject *swig_obj[1] ;
15290
15291 if (!args) SWIG_fail;
15292 swig_obj[0] = args;
15293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15294 if (!SWIG_IsOK(res1)) {
15295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15296 }
15297 arg1 = reinterpret_cast< wxImage * >(argp1);
15298 {
15299 PyThreadState* __tstate = wxPyBeginAllowThreads();
15300 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15301 wxPyEndAllowThreads(__tstate);
15302 if (PyErr_Occurred()) SWIG_fail;
15303 }
15304 resultobj = result;
15305 return resultobj;
15306 fail:
15307 return NULL;
15308 }
15309
15310
15311 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15312 PyObject *resultobj = 0;
15313 wxImage *arg1 = (wxImage *) 0 ;
15314 buffer arg2 ;
15315 int arg3 ;
15316 void *argp1 = 0 ;
15317 int res1 = 0 ;
15318 PyObject * obj0 = 0 ;
15319 PyObject * obj1 = 0 ;
15320 char * kwnames[] = {
15321 (char *) "self",(char *) "data", NULL
15322 };
15323
15324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15326 if (!SWIG_IsOK(res1)) {
15327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15328 }
15329 arg1 = reinterpret_cast< wxImage * >(argp1);
15330 {
15331 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15332 }
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 wxImage_SetDataBuffer(arg1,arg2,arg3);
15336 wxPyEndAllowThreads(__tstate);
15337 if (PyErr_Occurred()) SWIG_fail;
15338 }
15339 resultobj = SWIG_Py_Void();
15340 return resultobj;
15341 fail:
15342 return NULL;
15343 }
15344
15345
15346 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15347 PyObject *resultobj = 0;
15348 wxImage *arg1 = (wxImage *) 0 ;
15349 PyObject *result = 0 ;
15350 void *argp1 = 0 ;
15351 int res1 = 0 ;
15352 PyObject *swig_obj[1] ;
15353
15354 if (!args) SWIG_fail;
15355 swig_obj[0] = args;
15356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15357 if (!SWIG_IsOK(res1)) {
15358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15359 }
15360 arg1 = reinterpret_cast< wxImage * >(argp1);
15361 {
15362 PyThreadState* __tstate = wxPyBeginAllowThreads();
15363 result = (PyObject *)wxImage_GetAlphaData(arg1);
15364 wxPyEndAllowThreads(__tstate);
15365 if (PyErr_Occurred()) SWIG_fail;
15366 }
15367 resultobj = result;
15368 return resultobj;
15369 fail:
15370 return NULL;
15371 }
15372
15373
15374 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15375 PyObject *resultobj = 0;
15376 wxImage *arg1 = (wxImage *) 0 ;
15377 buffer arg2 ;
15378 int arg3 ;
15379 void *argp1 = 0 ;
15380 int res1 = 0 ;
15381 PyObject * obj0 = 0 ;
15382 PyObject * obj1 = 0 ;
15383 char * kwnames[] = {
15384 (char *) "self",(char *) "alpha", NULL
15385 };
15386
15387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15389 if (!SWIG_IsOK(res1)) {
15390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15391 }
15392 arg1 = reinterpret_cast< wxImage * >(argp1);
15393 {
15394 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15395 }
15396 {
15397 PyThreadState* __tstate = wxPyBeginAllowThreads();
15398 wxImage_SetAlphaData(arg1,arg2,arg3);
15399 wxPyEndAllowThreads(__tstate);
15400 if (PyErr_Occurred()) SWIG_fail;
15401 }
15402 resultobj = SWIG_Py_Void();
15403 return resultobj;
15404 fail:
15405 return NULL;
15406 }
15407
15408
15409 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15410 PyObject *resultobj = 0;
15411 wxImage *arg1 = (wxImage *) 0 ;
15412 PyObject *result = 0 ;
15413 void *argp1 = 0 ;
15414 int res1 = 0 ;
15415 PyObject *swig_obj[1] ;
15416
15417 if (!args) SWIG_fail;
15418 swig_obj[0] = args;
15419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15420 if (!SWIG_IsOK(res1)) {
15421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15422 }
15423 arg1 = reinterpret_cast< wxImage * >(argp1);
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15427 wxPyEndAllowThreads(__tstate);
15428 if (PyErr_Occurred()) SWIG_fail;
15429 }
15430 resultobj = result;
15431 return resultobj;
15432 fail:
15433 return NULL;
15434 }
15435
15436
15437 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15438 PyObject *resultobj = 0;
15439 wxImage *arg1 = (wxImage *) 0 ;
15440 buffer arg2 ;
15441 int arg3 ;
15442 void *argp1 = 0 ;
15443 int res1 = 0 ;
15444 PyObject * obj0 = 0 ;
15445 PyObject * obj1 = 0 ;
15446 char * kwnames[] = {
15447 (char *) "self",(char *) "alpha", NULL
15448 };
15449
15450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15452 if (!SWIG_IsOK(res1)) {
15453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15454 }
15455 arg1 = reinterpret_cast< wxImage * >(argp1);
15456 {
15457 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15458 }
15459 {
15460 PyThreadState* __tstate = wxPyBeginAllowThreads();
15461 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 resultobj = SWIG_Py_Void();
15466 return resultobj;
15467 fail:
15468 return NULL;
15469 }
15470
15471
15472 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15473 PyObject *resultobj = 0;
15474 wxImage *arg1 = (wxImage *) 0 ;
15475 byte arg2 ;
15476 byte arg3 ;
15477 byte arg4 ;
15478 void *argp1 = 0 ;
15479 int res1 = 0 ;
15480 unsigned char val2 ;
15481 int ecode2 = 0 ;
15482 unsigned char val3 ;
15483 int ecode3 = 0 ;
15484 unsigned char val4 ;
15485 int ecode4 = 0 ;
15486 PyObject * obj0 = 0 ;
15487 PyObject * obj1 = 0 ;
15488 PyObject * obj2 = 0 ;
15489 PyObject * obj3 = 0 ;
15490 char * kwnames[] = {
15491 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15492 };
15493
15494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15496 if (!SWIG_IsOK(res1)) {
15497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15498 }
15499 arg1 = reinterpret_cast< wxImage * >(argp1);
15500 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15501 if (!SWIG_IsOK(ecode2)) {
15502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15503 }
15504 arg2 = static_cast< byte >(val2);
15505 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15506 if (!SWIG_IsOK(ecode3)) {
15507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15508 }
15509 arg3 = static_cast< byte >(val3);
15510 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15511 if (!SWIG_IsOK(ecode4)) {
15512 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15513 }
15514 arg4 = static_cast< byte >(val4);
15515 {
15516 PyThreadState* __tstate = wxPyBeginAllowThreads();
15517 (arg1)->SetMaskColour(arg2,arg3,arg4);
15518 wxPyEndAllowThreads(__tstate);
15519 if (PyErr_Occurred()) SWIG_fail;
15520 }
15521 resultobj = SWIG_Py_Void();
15522 return resultobj;
15523 fail:
15524 return NULL;
15525 }
15526
15527
15528 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15529 PyObject *resultobj = 0;
15530 wxImage *arg1 = (wxImage *) 0 ;
15531 byte *arg2 = (byte *) 0 ;
15532 byte *arg3 = (byte *) 0 ;
15533 byte *arg4 = (byte *) 0 ;
15534 void *argp1 = 0 ;
15535 int res1 = 0 ;
15536 byte temp2 ;
15537 int res2 = SWIG_TMPOBJ ;
15538 byte temp3 ;
15539 int res3 = SWIG_TMPOBJ ;
15540 byte temp4 ;
15541 int res4 = SWIG_TMPOBJ ;
15542 PyObject *swig_obj[1] ;
15543
15544 arg2 = &temp2;
15545 arg3 = &temp3;
15546 arg4 = &temp4;
15547 if (!args) SWIG_fail;
15548 swig_obj[0] = args;
15549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15550 if (!SWIG_IsOK(res1)) {
15551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15552 }
15553 arg1 = reinterpret_cast< wxImage * >(argp1);
15554 {
15555 PyThreadState* __tstate = wxPyBeginAllowThreads();
15556 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15557 wxPyEndAllowThreads(__tstate);
15558 if (PyErr_Occurred()) SWIG_fail;
15559 }
15560 resultobj = SWIG_Py_Void();
15561 if (SWIG_IsTmpObj(res2)) {
15562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15563 } else {
15564 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15566 }
15567 if (SWIG_IsTmpObj(res3)) {
15568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15569 } else {
15570 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15572 }
15573 if (SWIG_IsTmpObj(res4)) {
15574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15575 } else {
15576 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15578 }
15579 return resultobj;
15580 fail:
15581 return NULL;
15582 }
15583
15584
15585 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15586 PyObject *resultobj = 0;
15587 wxImage *arg1 = (wxImage *) 0 ;
15588 byte result;
15589 void *argp1 = 0 ;
15590 int res1 = 0 ;
15591 PyObject *swig_obj[1] ;
15592
15593 if (!args) SWIG_fail;
15594 swig_obj[0] = args;
15595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15596 if (!SWIG_IsOK(res1)) {
15597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15598 }
15599 arg1 = reinterpret_cast< wxImage * >(argp1);
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (byte)(arg1)->GetMaskRed();
15603 wxPyEndAllowThreads(__tstate);
15604 if (PyErr_Occurred()) SWIG_fail;
15605 }
15606 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15607 return resultobj;
15608 fail:
15609 return NULL;
15610 }
15611
15612
15613 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15614 PyObject *resultobj = 0;
15615 wxImage *arg1 = (wxImage *) 0 ;
15616 byte result;
15617 void *argp1 = 0 ;
15618 int res1 = 0 ;
15619 PyObject *swig_obj[1] ;
15620
15621 if (!args) SWIG_fail;
15622 swig_obj[0] = args;
15623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15624 if (!SWIG_IsOK(res1)) {
15625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15626 }
15627 arg1 = reinterpret_cast< wxImage * >(argp1);
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (byte)(arg1)->GetMaskGreen();
15631 wxPyEndAllowThreads(__tstate);
15632 if (PyErr_Occurred()) SWIG_fail;
15633 }
15634 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15635 return resultobj;
15636 fail:
15637 return NULL;
15638 }
15639
15640
15641 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15642 PyObject *resultobj = 0;
15643 wxImage *arg1 = (wxImage *) 0 ;
15644 byte result;
15645 void *argp1 = 0 ;
15646 int res1 = 0 ;
15647 PyObject *swig_obj[1] ;
15648
15649 if (!args) SWIG_fail;
15650 swig_obj[0] = args;
15651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15652 if (!SWIG_IsOK(res1)) {
15653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15654 }
15655 arg1 = reinterpret_cast< wxImage * >(argp1);
15656 {
15657 PyThreadState* __tstate = wxPyBeginAllowThreads();
15658 result = (byte)(arg1)->GetMaskBlue();
15659 wxPyEndAllowThreads(__tstate);
15660 if (PyErr_Occurred()) SWIG_fail;
15661 }
15662 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15663 return resultobj;
15664 fail:
15665 return NULL;
15666 }
15667
15668
15669 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15670 PyObject *resultobj = 0;
15671 wxImage *arg1 = (wxImage *) 0 ;
15672 bool arg2 = (bool) true ;
15673 void *argp1 = 0 ;
15674 int res1 = 0 ;
15675 bool val2 ;
15676 int ecode2 = 0 ;
15677 PyObject * obj0 = 0 ;
15678 PyObject * obj1 = 0 ;
15679 char * kwnames[] = {
15680 (char *) "self",(char *) "mask", NULL
15681 };
15682
15683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15685 if (!SWIG_IsOK(res1)) {
15686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15687 }
15688 arg1 = reinterpret_cast< wxImage * >(argp1);
15689 if (obj1) {
15690 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15691 if (!SWIG_IsOK(ecode2)) {
15692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15693 }
15694 arg2 = static_cast< bool >(val2);
15695 }
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 (arg1)->SetMask(arg2);
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 resultobj = SWIG_Py_Void();
15703 return resultobj;
15704 fail:
15705 return NULL;
15706 }
15707
15708
15709 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15710 PyObject *resultobj = 0;
15711 wxImage *arg1 = (wxImage *) 0 ;
15712 bool result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 PyObject *swig_obj[1] ;
15716
15717 if (!args) SWIG_fail;
15718 swig_obj[0] = args;
15719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15720 if (!SWIG_IsOK(res1)) {
15721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15722 }
15723 arg1 = reinterpret_cast< wxImage * >(argp1);
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (bool)(arg1)->HasMask();
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 {
15731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15732 }
15733 return resultobj;
15734 fail:
15735 return NULL;
15736 }
15737
15738
15739 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15740 PyObject *resultobj = 0;
15741 wxImage *arg1 = (wxImage *) 0 ;
15742 double arg2 ;
15743 wxPoint *arg3 = 0 ;
15744 bool arg4 = (bool) true ;
15745 wxPoint *arg5 = (wxPoint *) NULL ;
15746 SwigValueWrapper<wxImage > result;
15747 void *argp1 = 0 ;
15748 int res1 = 0 ;
15749 double val2 ;
15750 int ecode2 = 0 ;
15751 wxPoint temp3 ;
15752 bool val4 ;
15753 int ecode4 = 0 ;
15754 void *argp5 = 0 ;
15755 int res5 = 0 ;
15756 PyObject * obj0 = 0 ;
15757 PyObject * obj1 = 0 ;
15758 PyObject * obj2 = 0 ;
15759 PyObject * obj3 = 0 ;
15760 PyObject * obj4 = 0 ;
15761 char * kwnames[] = {
15762 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15763 };
15764
15765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15767 if (!SWIG_IsOK(res1)) {
15768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15769 }
15770 arg1 = reinterpret_cast< wxImage * >(argp1);
15771 ecode2 = SWIG_AsVal_double(obj1, &val2);
15772 if (!SWIG_IsOK(ecode2)) {
15773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15774 }
15775 arg2 = static_cast< double >(val2);
15776 {
15777 arg3 = &temp3;
15778 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15779 }
15780 if (obj3) {
15781 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15782 if (!SWIG_IsOK(ecode4)) {
15783 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15784 }
15785 arg4 = static_cast< bool >(val4);
15786 }
15787 if (obj4) {
15788 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15789 if (!SWIG_IsOK(res5)) {
15790 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15791 }
15792 arg5 = reinterpret_cast< wxPoint * >(argp5);
15793 }
15794 {
15795 PyThreadState* __tstate = wxPyBeginAllowThreads();
15796 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15797 wxPyEndAllowThreads(__tstate);
15798 if (PyErr_Occurred()) SWIG_fail;
15799 }
15800 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15801 return resultobj;
15802 fail:
15803 return NULL;
15804 }
15805
15806
15807 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15808 PyObject *resultobj = 0;
15809 wxImage *arg1 = (wxImage *) 0 ;
15810 bool arg2 = (bool) true ;
15811 SwigValueWrapper<wxImage > result;
15812 void *argp1 = 0 ;
15813 int res1 = 0 ;
15814 bool val2 ;
15815 int ecode2 = 0 ;
15816 PyObject * obj0 = 0 ;
15817 PyObject * obj1 = 0 ;
15818 char * kwnames[] = {
15819 (char *) "self",(char *) "clockwise", NULL
15820 };
15821
15822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15824 if (!SWIG_IsOK(res1)) {
15825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15826 }
15827 arg1 = reinterpret_cast< wxImage * >(argp1);
15828 if (obj1) {
15829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15830 if (!SWIG_IsOK(ecode2)) {
15831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15832 }
15833 arg2 = static_cast< bool >(val2);
15834 }
15835 {
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 result = (arg1)->Rotate90(arg2);
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj = 0;
15850 wxImage *arg1 = (wxImage *) 0 ;
15851 bool arg2 = (bool) true ;
15852 SwigValueWrapper<wxImage > result;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 bool val2 ;
15856 int ecode2 = 0 ;
15857 PyObject * obj0 = 0 ;
15858 PyObject * obj1 = 0 ;
15859 char * kwnames[] = {
15860 (char *) "self",(char *) "horizontally", NULL
15861 };
15862
15863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15865 if (!SWIG_IsOK(res1)) {
15866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15867 }
15868 arg1 = reinterpret_cast< wxImage * >(argp1);
15869 if (obj1) {
15870 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15871 if (!SWIG_IsOK(ecode2)) {
15872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15873 }
15874 arg2 = static_cast< bool >(val2);
15875 }
15876 {
15877 PyThreadState* __tstate = wxPyBeginAllowThreads();
15878 result = (arg1)->Mirror(arg2);
15879 wxPyEndAllowThreads(__tstate);
15880 if (PyErr_Occurred()) SWIG_fail;
15881 }
15882 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15883 return resultobj;
15884 fail:
15885 return NULL;
15886 }
15887
15888
15889 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15890 PyObject *resultobj = 0;
15891 wxImage *arg1 = (wxImage *) 0 ;
15892 byte arg2 ;
15893 byte arg3 ;
15894 byte arg4 ;
15895 byte arg5 ;
15896 byte arg6 ;
15897 byte arg7 ;
15898 void *argp1 = 0 ;
15899 int res1 = 0 ;
15900 unsigned char val2 ;
15901 int ecode2 = 0 ;
15902 unsigned char val3 ;
15903 int ecode3 = 0 ;
15904 unsigned char val4 ;
15905 int ecode4 = 0 ;
15906 unsigned char val5 ;
15907 int ecode5 = 0 ;
15908 unsigned char val6 ;
15909 int ecode6 = 0 ;
15910 unsigned char val7 ;
15911 int ecode7 = 0 ;
15912 PyObject * obj0 = 0 ;
15913 PyObject * obj1 = 0 ;
15914 PyObject * obj2 = 0 ;
15915 PyObject * obj3 = 0 ;
15916 PyObject * obj4 = 0 ;
15917 PyObject * obj5 = 0 ;
15918 PyObject * obj6 = 0 ;
15919 char * kwnames[] = {
15920 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15921 };
15922
15923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15925 if (!SWIG_IsOK(res1)) {
15926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15927 }
15928 arg1 = reinterpret_cast< wxImage * >(argp1);
15929 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15930 if (!SWIG_IsOK(ecode2)) {
15931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15932 }
15933 arg2 = static_cast< byte >(val2);
15934 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15935 if (!SWIG_IsOK(ecode3)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15937 }
15938 arg3 = static_cast< byte >(val3);
15939 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15940 if (!SWIG_IsOK(ecode4)) {
15941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15942 }
15943 arg4 = static_cast< byte >(val4);
15944 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15945 if (!SWIG_IsOK(ecode5)) {
15946 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15947 }
15948 arg5 = static_cast< byte >(val5);
15949 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15950 if (!SWIG_IsOK(ecode6)) {
15951 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
15952 }
15953 arg6 = static_cast< byte >(val6);
15954 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
15955 if (!SWIG_IsOK(ecode7)) {
15956 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
15957 }
15958 arg7 = static_cast< byte >(val7);
15959 {
15960 PyThreadState* __tstate = wxPyBeginAllowThreads();
15961 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
15962 wxPyEndAllowThreads(__tstate);
15963 if (PyErr_Occurred()) SWIG_fail;
15964 }
15965 resultobj = SWIG_Py_Void();
15966 return resultobj;
15967 fail:
15968 return NULL;
15969 }
15970
15971
15972 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15973 PyObject *resultobj = 0;
15974 wxImage *arg1 = (wxImage *) 0 ;
15975 double arg2 = (double) 0.299 ;
15976 double arg3 = (double) 0.587 ;
15977 double arg4 = (double) 0.114 ;
15978 SwigValueWrapper<wxImage > result;
15979 void *argp1 = 0 ;
15980 int res1 = 0 ;
15981 double val2 ;
15982 int ecode2 = 0 ;
15983 double val3 ;
15984 int ecode3 = 0 ;
15985 double val4 ;
15986 int ecode4 = 0 ;
15987 PyObject * obj0 = 0 ;
15988 PyObject * obj1 = 0 ;
15989 PyObject * obj2 = 0 ;
15990 PyObject * obj3 = 0 ;
15991 char * kwnames[] = {
15992 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
15993 };
15994
15995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15997 if (!SWIG_IsOK(res1)) {
15998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
15999 }
16000 arg1 = reinterpret_cast< wxImage * >(argp1);
16001 if (obj1) {
16002 ecode2 = SWIG_AsVal_double(obj1, &val2);
16003 if (!SWIG_IsOK(ecode2)) {
16004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16005 }
16006 arg2 = static_cast< double >(val2);
16007 }
16008 if (obj2) {
16009 ecode3 = SWIG_AsVal_double(obj2, &val3);
16010 if (!SWIG_IsOK(ecode3)) {
16011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16012 }
16013 arg3 = static_cast< double >(val3);
16014 }
16015 if (obj3) {
16016 ecode4 = SWIG_AsVal_double(obj3, &val4);
16017 if (!SWIG_IsOK(ecode4)) {
16018 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16019 }
16020 arg4 = static_cast< double >(val4);
16021 }
16022 {
16023 PyThreadState* __tstate = wxPyBeginAllowThreads();
16024 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16025 wxPyEndAllowThreads(__tstate);
16026 if (PyErr_Occurred()) SWIG_fail;
16027 }
16028 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16029 return resultobj;
16030 fail:
16031 return NULL;
16032 }
16033
16034
16035 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16036 PyObject *resultobj = 0;
16037 wxImage *arg1 = (wxImage *) 0 ;
16038 byte arg2 ;
16039 byte arg3 ;
16040 byte arg4 ;
16041 SwigValueWrapper<wxImage > result;
16042 void *argp1 = 0 ;
16043 int res1 = 0 ;
16044 unsigned char val2 ;
16045 int ecode2 = 0 ;
16046 unsigned char val3 ;
16047 int ecode3 = 0 ;
16048 unsigned char val4 ;
16049 int ecode4 = 0 ;
16050 PyObject * obj0 = 0 ;
16051 PyObject * obj1 = 0 ;
16052 PyObject * obj2 = 0 ;
16053 PyObject * obj3 = 0 ;
16054 char * kwnames[] = {
16055 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16056 };
16057
16058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16060 if (!SWIG_IsOK(res1)) {
16061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16062 }
16063 arg1 = reinterpret_cast< wxImage * >(argp1);
16064 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16065 if (!SWIG_IsOK(ecode2)) {
16066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16067 }
16068 arg2 = static_cast< byte >(val2);
16069 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16070 if (!SWIG_IsOK(ecode3)) {
16071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16072 }
16073 arg3 = static_cast< byte >(val3);
16074 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16075 if (!SWIG_IsOK(ecode4)) {
16076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16077 }
16078 arg4 = static_cast< byte >(val4);
16079 {
16080 PyThreadState* __tstate = wxPyBeginAllowThreads();
16081 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
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_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16093 PyObject *resultobj = 0;
16094 wxImage *arg1 = (wxImage *) 0 ;
16095 wxString *arg2 = 0 ;
16096 wxString *arg3 = 0 ;
16097 void *argp1 = 0 ;
16098 int res1 = 0 ;
16099 bool temp2 = false ;
16100 bool temp3 = false ;
16101 PyObject * obj0 = 0 ;
16102 PyObject * obj1 = 0 ;
16103 PyObject * obj2 = 0 ;
16104 char * kwnames[] = {
16105 (char *) "self",(char *) "name",(char *) "value", NULL
16106 };
16107
16108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16110 if (!SWIG_IsOK(res1)) {
16111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16112 }
16113 arg1 = reinterpret_cast< wxImage * >(argp1);
16114 {
16115 arg2 = wxString_in_helper(obj1);
16116 if (arg2 == NULL) SWIG_fail;
16117 temp2 = true;
16118 }
16119 {
16120 arg3 = wxString_in_helper(obj2);
16121 if (arg3 == NULL) SWIG_fail;
16122 temp3 = true;
16123 }
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 resultobj = SWIG_Py_Void();
16131 {
16132 if (temp2)
16133 delete arg2;
16134 }
16135 {
16136 if (temp3)
16137 delete arg3;
16138 }
16139 return resultobj;
16140 fail:
16141 {
16142 if (temp2)
16143 delete arg2;
16144 }
16145 {
16146 if (temp3)
16147 delete arg3;
16148 }
16149 return NULL;
16150 }
16151
16152
16153 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16154 PyObject *resultobj = 0;
16155 wxImage *arg1 = (wxImage *) 0 ;
16156 wxString *arg2 = 0 ;
16157 int arg3 ;
16158 void *argp1 = 0 ;
16159 int res1 = 0 ;
16160 bool temp2 = false ;
16161 int val3 ;
16162 int ecode3 = 0 ;
16163 PyObject * obj0 = 0 ;
16164 PyObject * obj1 = 0 ;
16165 PyObject * obj2 = 0 ;
16166 char * kwnames[] = {
16167 (char *) "self",(char *) "name",(char *) "value", NULL
16168 };
16169
16170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16172 if (!SWIG_IsOK(res1)) {
16173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16174 }
16175 arg1 = reinterpret_cast< wxImage * >(argp1);
16176 {
16177 arg2 = wxString_in_helper(obj1);
16178 if (arg2 == NULL) SWIG_fail;
16179 temp2 = true;
16180 }
16181 ecode3 = SWIG_AsVal_int(obj2, &val3);
16182 if (!SWIG_IsOK(ecode3)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16184 }
16185 arg3 = static_cast< int >(val3);
16186 {
16187 PyThreadState* __tstate = wxPyBeginAllowThreads();
16188 (arg1)->SetOption((wxString const &)*arg2,arg3);
16189 wxPyEndAllowThreads(__tstate);
16190 if (PyErr_Occurred()) SWIG_fail;
16191 }
16192 resultobj = SWIG_Py_Void();
16193 {
16194 if (temp2)
16195 delete arg2;
16196 }
16197 return resultobj;
16198 fail:
16199 {
16200 if (temp2)
16201 delete arg2;
16202 }
16203 return NULL;
16204 }
16205
16206
16207 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16208 PyObject *resultobj = 0;
16209 wxImage *arg1 = (wxImage *) 0 ;
16210 wxString *arg2 = 0 ;
16211 wxString result;
16212 void *argp1 = 0 ;
16213 int res1 = 0 ;
16214 bool temp2 = false ;
16215 PyObject * obj0 = 0 ;
16216 PyObject * obj1 = 0 ;
16217 char * kwnames[] = {
16218 (char *) "self",(char *) "name", NULL
16219 };
16220
16221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16223 if (!SWIG_IsOK(res1)) {
16224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16225 }
16226 arg1 = reinterpret_cast< wxImage * >(argp1);
16227 {
16228 arg2 = wxString_in_helper(obj1);
16229 if (arg2 == NULL) SWIG_fail;
16230 temp2 = true;
16231 }
16232 {
16233 PyThreadState* __tstate = wxPyBeginAllowThreads();
16234 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16235 wxPyEndAllowThreads(__tstate);
16236 if (PyErr_Occurred()) SWIG_fail;
16237 }
16238 {
16239 #if wxUSE_UNICODE
16240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16241 #else
16242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16243 #endif
16244 }
16245 {
16246 if (temp2)
16247 delete arg2;
16248 }
16249 return resultobj;
16250 fail:
16251 {
16252 if (temp2)
16253 delete arg2;
16254 }
16255 return NULL;
16256 }
16257
16258
16259 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16260 PyObject *resultobj = 0;
16261 wxImage *arg1 = (wxImage *) 0 ;
16262 wxString *arg2 = 0 ;
16263 int result;
16264 void *argp1 = 0 ;
16265 int res1 = 0 ;
16266 bool temp2 = false ;
16267 PyObject * obj0 = 0 ;
16268 PyObject * obj1 = 0 ;
16269 char * kwnames[] = {
16270 (char *) "self",(char *) "name", NULL
16271 };
16272
16273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16275 if (!SWIG_IsOK(res1)) {
16276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16277 }
16278 arg1 = reinterpret_cast< wxImage * >(argp1);
16279 {
16280 arg2 = wxString_in_helper(obj1);
16281 if (arg2 == NULL) SWIG_fail;
16282 temp2 = true;
16283 }
16284 {
16285 PyThreadState* __tstate = wxPyBeginAllowThreads();
16286 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16287 wxPyEndAllowThreads(__tstate);
16288 if (PyErr_Occurred()) SWIG_fail;
16289 }
16290 resultobj = SWIG_From_int(static_cast< int >(result));
16291 {
16292 if (temp2)
16293 delete arg2;
16294 }
16295 return resultobj;
16296 fail:
16297 {
16298 if (temp2)
16299 delete arg2;
16300 }
16301 return NULL;
16302 }
16303
16304
16305 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16306 PyObject *resultobj = 0;
16307 wxImage *arg1 = (wxImage *) 0 ;
16308 wxString *arg2 = 0 ;
16309 bool result;
16310 void *argp1 = 0 ;
16311 int res1 = 0 ;
16312 bool temp2 = false ;
16313 PyObject * obj0 = 0 ;
16314 PyObject * obj1 = 0 ;
16315 char * kwnames[] = {
16316 (char *) "self",(char *) "name", NULL
16317 };
16318
16319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16321 if (!SWIG_IsOK(res1)) {
16322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16323 }
16324 arg1 = reinterpret_cast< wxImage * >(argp1);
16325 {
16326 arg2 = wxString_in_helper(obj1);
16327 if (arg2 == NULL) SWIG_fail;
16328 temp2 = true;
16329 }
16330 {
16331 PyThreadState* __tstate = wxPyBeginAllowThreads();
16332 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16333 wxPyEndAllowThreads(__tstate);
16334 if (PyErr_Occurred()) SWIG_fail;
16335 }
16336 {
16337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16338 }
16339 {
16340 if (temp2)
16341 delete arg2;
16342 }
16343 return resultobj;
16344 fail:
16345 {
16346 if (temp2)
16347 delete arg2;
16348 }
16349 return NULL;
16350 }
16351
16352
16353 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16354 PyObject *resultobj = 0;
16355 wxImage *arg1 = (wxImage *) 0 ;
16356 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16357 unsigned long result;
16358 void *argp1 = 0 ;
16359 int res1 = 0 ;
16360 unsigned long val2 ;
16361 int ecode2 = 0 ;
16362 PyObject * obj0 = 0 ;
16363 PyObject * obj1 = 0 ;
16364 char * kwnames[] = {
16365 (char *) "self",(char *) "stopafter", NULL
16366 };
16367
16368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16370 if (!SWIG_IsOK(res1)) {
16371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16372 }
16373 arg1 = reinterpret_cast< wxImage * >(argp1);
16374 if (obj1) {
16375 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16376 if (!SWIG_IsOK(ecode2)) {
16377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16378 }
16379 arg2 = static_cast< unsigned long >(val2);
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (unsigned long)(arg1)->CountColours(arg2);
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16388 return resultobj;
16389 fail:
16390 return NULL;
16391 }
16392
16393
16394 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16395 PyObject *resultobj = 0;
16396 wxImage *arg1 = (wxImage *) 0 ;
16397 wxImageHistogram *arg2 = 0 ;
16398 unsigned long result;
16399 void *argp1 = 0 ;
16400 int res1 = 0 ;
16401 void *argp2 = 0 ;
16402 int res2 = 0 ;
16403 PyObject * obj0 = 0 ;
16404 PyObject * obj1 = 0 ;
16405 char * kwnames[] = {
16406 (char *) "self",(char *) "h", NULL
16407 };
16408
16409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16411 if (!SWIG_IsOK(res1)) {
16412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16413 }
16414 arg1 = reinterpret_cast< wxImage * >(argp1);
16415 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16416 if (!SWIG_IsOK(res2)) {
16417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16418 }
16419 if (!argp2) {
16420 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16421 }
16422 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16423 {
16424 PyThreadState* __tstate = wxPyBeginAllowThreads();
16425 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16426 wxPyEndAllowThreads(__tstate);
16427 if (PyErr_Occurred()) SWIG_fail;
16428 }
16429 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16430 return resultobj;
16431 fail:
16432 return NULL;
16433 }
16434
16435
16436 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16437 PyObject *resultobj = 0;
16438 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16439 void *argp1 = 0 ;
16440 int res1 = 0 ;
16441 PyObject * obj0 = 0 ;
16442 char * kwnames[] = {
16443 (char *) "handler", NULL
16444 };
16445
16446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16448 if (!SWIG_IsOK(res1)) {
16449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16450 }
16451 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16452 {
16453 PyThreadState* __tstate = wxPyBeginAllowThreads();
16454 wxImage::AddHandler(arg1);
16455 wxPyEndAllowThreads(__tstate);
16456 if (PyErr_Occurred()) SWIG_fail;
16457 }
16458 resultobj = SWIG_Py_Void();
16459 return resultobj;
16460 fail:
16461 return NULL;
16462 }
16463
16464
16465 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj = 0;
16467 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16468 void *argp1 = 0 ;
16469 int res1 = 0 ;
16470 PyObject * obj0 = 0 ;
16471 char * kwnames[] = {
16472 (char *) "handler", NULL
16473 };
16474
16475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16477 if (!SWIG_IsOK(res1)) {
16478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16479 }
16480 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16481 {
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 wxImage::InsertHandler(arg1);
16484 wxPyEndAllowThreads(__tstate);
16485 if (PyErr_Occurred()) SWIG_fail;
16486 }
16487 resultobj = SWIG_Py_Void();
16488 return resultobj;
16489 fail:
16490 return NULL;
16491 }
16492
16493
16494 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16495 PyObject *resultobj = 0;
16496 wxString *arg1 = 0 ;
16497 bool result;
16498 bool temp1 = false ;
16499 PyObject * obj0 = 0 ;
16500 char * kwnames[] = {
16501 (char *) "name", NULL
16502 };
16503
16504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16505 {
16506 arg1 = wxString_in_helper(obj0);
16507 if (arg1 == NULL) SWIG_fail;
16508 temp1 = true;
16509 }
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 {
16517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16518 }
16519 {
16520 if (temp1)
16521 delete arg1;
16522 }
16523 return resultobj;
16524 fail:
16525 {
16526 if (temp1)
16527 delete arg1;
16528 }
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16534 PyObject *resultobj = 0;
16535 PyObject *result = 0 ;
16536
16537 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16538 {
16539 PyThreadState* __tstate = wxPyBeginAllowThreads();
16540 result = (PyObject *)wxImage_GetHandlers();
16541 wxPyEndAllowThreads(__tstate);
16542 if (PyErr_Occurred()) SWIG_fail;
16543 }
16544 resultobj = result;
16545 return resultobj;
16546 fail:
16547 return NULL;
16548 }
16549
16550
16551 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16552 PyObject *resultobj = 0;
16553 wxString result;
16554
16555 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16556 {
16557 PyThreadState* __tstate = wxPyBeginAllowThreads();
16558 result = wxImage::GetImageExtWildcard();
16559 wxPyEndAllowThreads(__tstate);
16560 if (PyErr_Occurred()) SWIG_fail;
16561 }
16562 {
16563 #if wxUSE_UNICODE
16564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16565 #else
16566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16567 #endif
16568 }
16569 return resultobj;
16570 fail:
16571 return NULL;
16572 }
16573
16574
16575 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16576 PyObject *resultobj = 0;
16577 wxImage *arg1 = (wxImage *) 0 ;
16578 int arg2 = (int) -1 ;
16579 wxBitmap result;
16580 void *argp1 = 0 ;
16581 int res1 = 0 ;
16582 int val2 ;
16583 int ecode2 = 0 ;
16584 PyObject * obj0 = 0 ;
16585 PyObject * obj1 = 0 ;
16586 char * kwnames[] = {
16587 (char *) "self",(char *) "depth", NULL
16588 };
16589
16590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16592 if (!SWIG_IsOK(res1)) {
16593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16594 }
16595 arg1 = reinterpret_cast< wxImage * >(argp1);
16596 if (obj1) {
16597 ecode2 = SWIG_AsVal_int(obj1, &val2);
16598 if (!SWIG_IsOK(ecode2)) {
16599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16600 }
16601 arg2 = static_cast< int >(val2);
16602 }
16603 {
16604 if (!wxPyCheckForApp()) SWIG_fail;
16605 PyThreadState* __tstate = wxPyBeginAllowThreads();
16606 result = wxImage_ConvertToBitmap(arg1,arg2);
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16611 return resultobj;
16612 fail:
16613 return NULL;
16614 }
16615
16616
16617 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16618 PyObject *resultobj = 0;
16619 wxImage *arg1 = (wxImage *) 0 ;
16620 byte arg2 ;
16621 byte arg3 ;
16622 byte arg4 ;
16623 wxBitmap result;
16624 void *argp1 = 0 ;
16625 int res1 = 0 ;
16626 unsigned char val2 ;
16627 int ecode2 = 0 ;
16628 unsigned char val3 ;
16629 int ecode3 = 0 ;
16630 unsigned char val4 ;
16631 int ecode4 = 0 ;
16632 PyObject * obj0 = 0 ;
16633 PyObject * obj1 = 0 ;
16634 PyObject * obj2 = 0 ;
16635 PyObject * obj3 = 0 ;
16636 char * kwnames[] = {
16637 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16638 };
16639
16640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16642 if (!SWIG_IsOK(res1)) {
16643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16644 }
16645 arg1 = reinterpret_cast< wxImage * >(argp1);
16646 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16647 if (!SWIG_IsOK(ecode2)) {
16648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16649 }
16650 arg2 = static_cast< byte >(val2);
16651 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16652 if (!SWIG_IsOK(ecode3)) {
16653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16654 }
16655 arg3 = static_cast< byte >(val3);
16656 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16657 if (!SWIG_IsOK(ecode4)) {
16658 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16659 }
16660 arg4 = static_cast< byte >(val4);
16661 {
16662 if (!wxPyCheckForApp()) SWIG_fail;
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16665 wxPyEndAllowThreads(__tstate);
16666 if (PyErr_Occurred()) SWIG_fail;
16667 }
16668 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16669 return resultobj;
16670 fail:
16671 return NULL;
16672 }
16673
16674
16675 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16676 PyObject *resultobj = 0;
16677 wxImage *arg1 = (wxImage *) 0 ;
16678 double arg2 ;
16679 void *argp1 = 0 ;
16680 int res1 = 0 ;
16681 double val2 ;
16682 int ecode2 = 0 ;
16683 PyObject * obj0 = 0 ;
16684 PyObject * obj1 = 0 ;
16685 char * kwnames[] = {
16686 (char *) "self",(char *) "angle", NULL
16687 };
16688
16689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16691 if (!SWIG_IsOK(res1)) {
16692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16693 }
16694 arg1 = reinterpret_cast< wxImage * >(argp1);
16695 ecode2 = SWIG_AsVal_double(obj1, &val2);
16696 if (!SWIG_IsOK(ecode2)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16698 }
16699 arg2 = static_cast< double >(val2);
16700 {
16701 PyThreadState* __tstate = wxPyBeginAllowThreads();
16702 (arg1)->RotateHue(arg2);
16703 wxPyEndAllowThreads(__tstate);
16704 if (PyErr_Occurred()) SWIG_fail;
16705 }
16706 resultobj = SWIG_Py_Void();
16707 return resultobj;
16708 fail:
16709 return NULL;
16710 }
16711
16712
16713 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16714 PyObject *resultobj = 0;
16715 wxImage_RGBValue arg1 ;
16716 wxImage_HSVValue result;
16717 void *argp1 ;
16718 int res1 = 0 ;
16719 PyObject * obj0 = 0 ;
16720 char * kwnames[] = {
16721 (char *) "rgb", NULL
16722 };
16723
16724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16725 {
16726 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16727 if (!SWIG_IsOK(res1)) {
16728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16729 }
16730 if (!argp1) {
16731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16732 } else {
16733 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16734 arg1 = *temp;
16735 if (SWIG_IsNewObj(res1)) delete temp;
16736 }
16737 }
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 result = wxImage::RGBtoHSV(arg1);
16741 wxPyEndAllowThreads(__tstate);
16742 if (PyErr_Occurred()) SWIG_fail;
16743 }
16744 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16745 return resultobj;
16746 fail:
16747 return NULL;
16748 }
16749
16750
16751 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16752 PyObject *resultobj = 0;
16753 wxImage_HSVValue arg1 ;
16754 wxImage_RGBValue result;
16755 void *argp1 ;
16756 int res1 = 0 ;
16757 PyObject * obj0 = 0 ;
16758 char * kwnames[] = {
16759 (char *) "hsv", NULL
16760 };
16761
16762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16763 {
16764 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16765 if (!SWIG_IsOK(res1)) {
16766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16767 }
16768 if (!argp1) {
16769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16770 } else {
16771 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16772 arg1 = *temp;
16773 if (SWIG_IsNewObj(res1)) delete temp;
16774 }
16775 }
16776 {
16777 PyThreadState* __tstate = wxPyBeginAllowThreads();
16778 result = wxImage::HSVtoRGB(arg1);
16779 wxPyEndAllowThreads(__tstate);
16780 if (PyErr_Occurred()) SWIG_fail;
16781 }
16782 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16783 return resultobj;
16784 fail:
16785 return NULL;
16786 }
16787
16788
16789 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16790 PyObject *obj;
16791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16792 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16793 return SWIG_Py_Void();
16794 }
16795
16796 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16797 return SWIG_Python_InitShadowInstance(args);
16798 }
16799
16800 SWIGINTERN int NullImage_set(PyObject *) {
16801 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16802 return 1;
16803 }
16804
16805
16806 SWIGINTERN PyObject *NullImage_get(void) {
16807 PyObject *pyobj = 0;
16808
16809 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16810 return pyobj;
16811 }
16812
16813
16814 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16815 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16816 return 1;
16817 }
16818
16819
16820 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16821 PyObject *pyobj = 0;
16822
16823 {
16824 #if wxUSE_UNICODE
16825 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16826 #else
16827 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16828 #endif
16829 }
16830 return pyobj;
16831 }
16832
16833
16834 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16835 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16836 return 1;
16837 }
16838
16839
16840 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16841 PyObject *pyobj = 0;
16842
16843 {
16844 #if wxUSE_UNICODE
16845 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16846 #else
16847 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16848 #endif
16849 }
16850 return pyobj;
16851 }
16852
16853
16854 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16855 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16856 return 1;
16857 }
16858
16859
16860 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16861 PyObject *pyobj = 0;
16862
16863 {
16864 #if wxUSE_UNICODE
16865 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16866 #else
16867 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16868 #endif
16869 }
16870 return pyobj;
16871 }
16872
16873
16874 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16875 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16876 return 1;
16877 }
16878
16879
16880 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16881 PyObject *pyobj = 0;
16882
16883 {
16884 #if wxUSE_UNICODE
16885 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16886 #else
16887 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16888 #endif
16889 }
16890 return pyobj;
16891 }
16892
16893
16894 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16895 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16896 return 1;
16897 }
16898
16899
16900 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16901 PyObject *pyobj = 0;
16902
16903 {
16904 #if wxUSE_UNICODE
16905 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16906 #else
16907 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16908 #endif
16909 }
16910 return pyobj;
16911 }
16912
16913
16914 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16915 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16916 return 1;
16917 }
16918
16919
16920 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16921 PyObject *pyobj = 0;
16922
16923 {
16924 #if wxUSE_UNICODE
16925 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16926 #else
16927 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16928 #endif
16929 }
16930 return pyobj;
16931 }
16932
16933
16934 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16935 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16936 return 1;
16937 }
16938
16939
16940 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16941 PyObject *pyobj = 0;
16942
16943 {
16944 #if wxUSE_UNICODE
16945 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16946 #else
16947 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16948 #endif
16949 }
16950 return pyobj;
16951 }
16952
16953
16954 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
16955 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
16956 return 1;
16957 }
16958
16959
16960 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
16961 PyObject *pyobj = 0;
16962
16963 {
16964 #if wxUSE_UNICODE
16965 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16966 #else
16967 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16968 #endif
16969 }
16970 return pyobj;
16971 }
16972
16973
16974 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
16975 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
16976 return 1;
16977 }
16978
16979
16980 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
16981 PyObject *pyobj = 0;
16982
16983 {
16984 #if wxUSE_UNICODE
16985 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16986 #else
16987 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16988 #endif
16989 }
16990 return pyobj;
16991 }
16992
16993
16994 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
16995 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
16996 return 1;
16997 }
16998
16999
17000 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17001 PyObject *pyobj = 0;
17002
17003 {
17004 #if wxUSE_UNICODE
17005 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17006 #else
17007 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17008 #endif
17009 }
17010 return pyobj;
17011 }
17012
17013
17014 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17015 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17016 return 1;
17017 }
17018
17019
17020 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17021 PyObject *pyobj = 0;
17022
17023 {
17024 #if wxUSE_UNICODE
17025 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17026 #else
17027 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17028 #endif
17029 }
17030 return pyobj;
17031 }
17032
17033
17034 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17035 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17036 return 1;
17037 }
17038
17039
17040 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17041 PyObject *pyobj = 0;
17042
17043 {
17044 #if wxUSE_UNICODE
17045 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17046 #else
17047 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17048 #endif
17049 }
17050 return pyobj;
17051 }
17052
17053
17054 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17055 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17056 return 1;
17057 }
17058
17059
17060 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17061 PyObject *pyobj = 0;
17062
17063 {
17064 #if wxUSE_UNICODE
17065 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17066 #else
17067 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17068 #endif
17069 }
17070 return pyobj;
17071 }
17072
17073
17074 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17075 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17076 return 1;
17077 }
17078
17079
17080 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17081 PyObject *pyobj = 0;
17082
17083 {
17084 #if wxUSE_UNICODE
17085 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17086 #else
17087 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17088 #endif
17089 }
17090 return pyobj;
17091 }
17092
17093
17094 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17095 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17096 return 1;
17097 }
17098
17099
17100 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17101 PyObject *pyobj = 0;
17102
17103 {
17104 #if wxUSE_UNICODE
17105 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17106 #else
17107 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17108 #endif
17109 }
17110 return pyobj;
17111 }
17112
17113
17114 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17115 PyObject *resultobj = 0;
17116 wxBMPHandler *result = 0 ;
17117
17118 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17119 {
17120 PyThreadState* __tstate = wxPyBeginAllowThreads();
17121 result = (wxBMPHandler *)new wxBMPHandler();
17122 wxPyEndAllowThreads(__tstate);
17123 if (PyErr_Occurred()) SWIG_fail;
17124 }
17125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17126 return resultobj;
17127 fail:
17128 return NULL;
17129 }
17130
17131
17132 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17133 PyObject *obj;
17134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17135 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17136 return SWIG_Py_Void();
17137 }
17138
17139 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17140 return SWIG_Python_InitShadowInstance(args);
17141 }
17142
17143 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17144 PyObject *resultobj = 0;
17145 wxICOHandler *result = 0 ;
17146
17147 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17148 {
17149 PyThreadState* __tstate = wxPyBeginAllowThreads();
17150 result = (wxICOHandler *)new wxICOHandler();
17151 wxPyEndAllowThreads(__tstate);
17152 if (PyErr_Occurred()) SWIG_fail;
17153 }
17154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17155 return resultobj;
17156 fail:
17157 return NULL;
17158 }
17159
17160
17161 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17162 PyObject *obj;
17163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17164 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17165 return SWIG_Py_Void();
17166 }
17167
17168 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17169 return SWIG_Python_InitShadowInstance(args);
17170 }
17171
17172 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17173 PyObject *resultobj = 0;
17174 wxCURHandler *result = 0 ;
17175
17176 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17177 {
17178 PyThreadState* __tstate = wxPyBeginAllowThreads();
17179 result = (wxCURHandler *)new wxCURHandler();
17180 wxPyEndAllowThreads(__tstate);
17181 if (PyErr_Occurred()) SWIG_fail;
17182 }
17183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17184 return resultobj;
17185 fail:
17186 return NULL;
17187 }
17188
17189
17190 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17191 PyObject *obj;
17192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17193 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17194 return SWIG_Py_Void();
17195 }
17196
17197 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17198 return SWIG_Python_InitShadowInstance(args);
17199 }
17200
17201 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17202 PyObject *resultobj = 0;
17203 wxANIHandler *result = 0 ;
17204
17205 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17206 {
17207 PyThreadState* __tstate = wxPyBeginAllowThreads();
17208 result = (wxANIHandler *)new wxANIHandler();
17209 wxPyEndAllowThreads(__tstate);
17210 if (PyErr_Occurred()) SWIG_fail;
17211 }
17212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17213 return resultobj;
17214 fail:
17215 return NULL;
17216 }
17217
17218
17219 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17220 PyObject *obj;
17221 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17222 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17223 return SWIG_Py_Void();
17224 }
17225
17226 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17227 return SWIG_Python_InitShadowInstance(args);
17228 }
17229
17230 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17231 PyObject *resultobj = 0;
17232 wxPNGHandler *result = 0 ;
17233
17234 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17235 {
17236 PyThreadState* __tstate = wxPyBeginAllowThreads();
17237 result = (wxPNGHandler *)new wxPNGHandler();
17238 wxPyEndAllowThreads(__tstate);
17239 if (PyErr_Occurred()) SWIG_fail;
17240 }
17241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17242 return resultobj;
17243 fail:
17244 return NULL;
17245 }
17246
17247
17248 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17249 PyObject *obj;
17250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17251 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17252 return SWIG_Py_Void();
17253 }
17254
17255 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17256 return SWIG_Python_InitShadowInstance(args);
17257 }
17258
17259 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17260 PyObject *resultobj = 0;
17261 wxGIFHandler *result = 0 ;
17262
17263 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17264 {
17265 PyThreadState* __tstate = wxPyBeginAllowThreads();
17266 result = (wxGIFHandler *)new wxGIFHandler();
17267 wxPyEndAllowThreads(__tstate);
17268 if (PyErr_Occurred()) SWIG_fail;
17269 }
17270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17271 return resultobj;
17272 fail:
17273 return NULL;
17274 }
17275
17276
17277 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17278 PyObject *obj;
17279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17280 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17281 return SWIG_Py_Void();
17282 }
17283
17284 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17285 return SWIG_Python_InitShadowInstance(args);
17286 }
17287
17288 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17289 PyObject *resultobj = 0;
17290 wxPCXHandler *result = 0 ;
17291
17292 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17293 {
17294 PyThreadState* __tstate = wxPyBeginAllowThreads();
17295 result = (wxPCXHandler *)new wxPCXHandler();
17296 wxPyEndAllowThreads(__tstate);
17297 if (PyErr_Occurred()) SWIG_fail;
17298 }
17299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17300 return resultobj;
17301 fail:
17302 return NULL;
17303 }
17304
17305
17306 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17307 PyObject *obj;
17308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17309 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17310 return SWIG_Py_Void();
17311 }
17312
17313 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17314 return SWIG_Python_InitShadowInstance(args);
17315 }
17316
17317 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17318 PyObject *resultobj = 0;
17319 wxJPEGHandler *result = 0 ;
17320
17321 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17322 {
17323 PyThreadState* __tstate = wxPyBeginAllowThreads();
17324 result = (wxJPEGHandler *)new wxJPEGHandler();
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 PyObject *obj;
17337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17338 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17339 return SWIG_Py_Void();
17340 }
17341
17342 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17343 return SWIG_Python_InitShadowInstance(args);
17344 }
17345
17346 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17347 PyObject *resultobj = 0;
17348 wxPNMHandler *result = 0 ;
17349
17350 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (wxPNMHandler *)new wxPNMHandler();
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17358 return resultobj;
17359 fail:
17360 return NULL;
17361 }
17362
17363
17364 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17365 PyObject *obj;
17366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17367 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17368 return SWIG_Py_Void();
17369 }
17370
17371 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17372 return SWIG_Python_InitShadowInstance(args);
17373 }
17374
17375 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17376 PyObject *resultobj = 0;
17377 wxXPMHandler *result = 0 ;
17378
17379 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17380 {
17381 PyThreadState* __tstate = wxPyBeginAllowThreads();
17382 result = (wxXPMHandler *)new wxXPMHandler();
17383 wxPyEndAllowThreads(__tstate);
17384 if (PyErr_Occurred()) SWIG_fail;
17385 }
17386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17387 return resultobj;
17388 fail:
17389 return NULL;
17390 }
17391
17392
17393 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17394 PyObject *obj;
17395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17396 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17397 return SWIG_Py_Void();
17398 }
17399
17400 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17401 return SWIG_Python_InitShadowInstance(args);
17402 }
17403
17404 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17405 PyObject *resultobj = 0;
17406 wxTIFFHandler *result = 0 ;
17407
17408 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17409 {
17410 PyThreadState* __tstate = wxPyBeginAllowThreads();
17411 result = (wxTIFFHandler *)new wxTIFFHandler();
17412 wxPyEndAllowThreads(__tstate);
17413 if (PyErr_Occurred()) SWIG_fail;
17414 }
17415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17416 return resultobj;
17417 fail:
17418 return NULL;
17419 }
17420
17421
17422 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17423 PyObject *obj;
17424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17425 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17426 return SWIG_Py_Void();
17427 }
17428
17429 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17430 return SWIG_Python_InitShadowInstance(args);
17431 }
17432
17433 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17434 PyObject *resultobj = 0;
17435 wxImage *arg1 = 0 ;
17436 wxImage *arg2 = 0 ;
17437 int arg3 = (int) 236 ;
17438 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17439 bool result;
17440 void *argp1 = 0 ;
17441 int res1 = 0 ;
17442 void *argp2 = 0 ;
17443 int res2 = 0 ;
17444 int val3 ;
17445 int ecode3 = 0 ;
17446 int val4 ;
17447 int ecode4 = 0 ;
17448 PyObject * obj0 = 0 ;
17449 PyObject * obj1 = 0 ;
17450 PyObject * obj2 = 0 ;
17451 PyObject * obj3 = 0 ;
17452 char * kwnames[] = {
17453 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17454 };
17455
17456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17457 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17458 if (!SWIG_IsOK(res1)) {
17459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17460 }
17461 if (!argp1) {
17462 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17463 }
17464 arg1 = reinterpret_cast< wxImage * >(argp1);
17465 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17466 if (!SWIG_IsOK(res2)) {
17467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17468 }
17469 if (!argp2) {
17470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17471 }
17472 arg2 = reinterpret_cast< wxImage * >(argp2);
17473 if (obj2) {
17474 ecode3 = SWIG_AsVal_int(obj2, &val3);
17475 if (!SWIG_IsOK(ecode3)) {
17476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17477 }
17478 arg3 = static_cast< int >(val3);
17479 }
17480 if (obj3) {
17481 ecode4 = SWIG_AsVal_int(obj3, &val4);
17482 if (!SWIG_IsOK(ecode4)) {
17483 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17484 }
17485 arg4 = static_cast< int >(val4);
17486 }
17487 {
17488 PyThreadState* __tstate = wxPyBeginAllowThreads();
17489 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17490 wxPyEndAllowThreads(__tstate);
17491 if (PyErr_Occurred()) SWIG_fail;
17492 }
17493 {
17494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17495 }
17496 return resultobj;
17497 fail:
17498 return NULL;
17499 }
17500
17501
17502 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17503 PyObject *obj;
17504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17505 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17506 return SWIG_Py_Void();
17507 }
17508
17509 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17510 PyObject *resultobj = 0;
17511 wxEvtHandler *result = 0 ;
17512
17513 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17514 {
17515 PyThreadState* __tstate = wxPyBeginAllowThreads();
17516 result = (wxEvtHandler *)new wxEvtHandler();
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17528 PyObject *resultobj = 0;
17529 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17530 wxEvtHandler *result = 0 ;
17531 void *argp1 = 0 ;
17532 int res1 = 0 ;
17533 PyObject *swig_obj[1] ;
17534
17535 if (!args) SWIG_fail;
17536 swig_obj[0] = args;
17537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17538 if (!SWIG_IsOK(res1)) {
17539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17540 }
17541 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17542 {
17543 PyThreadState* __tstate = wxPyBeginAllowThreads();
17544 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17545 wxPyEndAllowThreads(__tstate);
17546 if (PyErr_Occurred()) SWIG_fail;
17547 }
17548 {
17549 resultobj = wxPyMake_wxObject(result, 0);
17550 }
17551 return resultobj;
17552 fail:
17553 return NULL;
17554 }
17555
17556
17557 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17558 PyObject *resultobj = 0;
17559 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17560 wxEvtHandler *result = 0 ;
17561 void *argp1 = 0 ;
17562 int res1 = 0 ;
17563 PyObject *swig_obj[1] ;
17564
17565 if (!args) SWIG_fail;
17566 swig_obj[0] = args;
17567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17568 if (!SWIG_IsOK(res1)) {
17569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17570 }
17571 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17572 {
17573 PyThreadState* __tstate = wxPyBeginAllowThreads();
17574 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17575 wxPyEndAllowThreads(__tstate);
17576 if (PyErr_Occurred()) SWIG_fail;
17577 }
17578 {
17579 resultobj = wxPyMake_wxObject(result, 0);
17580 }
17581 return resultobj;
17582 fail:
17583 return NULL;
17584 }
17585
17586
17587 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17588 PyObject *resultobj = 0;
17589 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17590 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17591 void *argp1 = 0 ;
17592 int res1 = 0 ;
17593 void *argp2 = 0 ;
17594 int res2 = 0 ;
17595 PyObject * obj0 = 0 ;
17596 PyObject * obj1 = 0 ;
17597 char * kwnames[] = {
17598 (char *) "self",(char *) "handler", NULL
17599 };
17600
17601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17603 if (!SWIG_IsOK(res1)) {
17604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17605 }
17606 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17608 if (!SWIG_IsOK(res2)) {
17609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17610 }
17611 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17612 {
17613 PyThreadState* __tstate = wxPyBeginAllowThreads();
17614 (arg1)->SetNextHandler(arg2);
17615 wxPyEndAllowThreads(__tstate);
17616 if (PyErr_Occurred()) SWIG_fail;
17617 }
17618 resultobj = SWIG_Py_Void();
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17626 PyObject *resultobj = 0;
17627 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17628 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17629 void *argp1 = 0 ;
17630 int res1 = 0 ;
17631 void *argp2 = 0 ;
17632 int res2 = 0 ;
17633 PyObject * obj0 = 0 ;
17634 PyObject * obj1 = 0 ;
17635 char * kwnames[] = {
17636 (char *) "self",(char *) "handler", NULL
17637 };
17638
17639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17641 if (!SWIG_IsOK(res1)) {
17642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17643 }
17644 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17646 if (!SWIG_IsOK(res2)) {
17647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17648 }
17649 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 (arg1)->SetPreviousHandler(arg2);
17653 wxPyEndAllowThreads(__tstate);
17654 if (PyErr_Occurred()) SWIG_fail;
17655 }
17656 resultobj = SWIG_Py_Void();
17657 return resultobj;
17658 fail:
17659 return NULL;
17660 }
17661
17662
17663 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17664 PyObject *resultobj = 0;
17665 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17666 bool result;
17667 void *argp1 = 0 ;
17668 int res1 = 0 ;
17669 PyObject *swig_obj[1] ;
17670
17671 if (!args) SWIG_fail;
17672 swig_obj[0] = args;
17673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17674 if (!SWIG_IsOK(res1)) {
17675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17676 }
17677 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 result = (bool)(arg1)->GetEvtHandlerEnabled();
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 {
17685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17686 }
17687 return resultobj;
17688 fail:
17689 return NULL;
17690 }
17691
17692
17693 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17694 PyObject *resultobj = 0;
17695 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17696 bool arg2 ;
17697 void *argp1 = 0 ;
17698 int res1 = 0 ;
17699 bool val2 ;
17700 int ecode2 = 0 ;
17701 PyObject * obj0 = 0 ;
17702 PyObject * obj1 = 0 ;
17703 char * kwnames[] = {
17704 (char *) "self",(char *) "enabled", NULL
17705 };
17706
17707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17709 if (!SWIG_IsOK(res1)) {
17710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17711 }
17712 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17713 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17714 if (!SWIG_IsOK(ecode2)) {
17715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17716 }
17717 arg2 = static_cast< bool >(val2);
17718 {
17719 PyThreadState* __tstate = wxPyBeginAllowThreads();
17720 (arg1)->SetEvtHandlerEnabled(arg2);
17721 wxPyEndAllowThreads(__tstate);
17722 if (PyErr_Occurred()) SWIG_fail;
17723 }
17724 resultobj = SWIG_Py_Void();
17725 return resultobj;
17726 fail:
17727 return NULL;
17728 }
17729
17730
17731 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17732 PyObject *resultobj = 0;
17733 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17734 wxEvent *arg2 = 0 ;
17735 bool result;
17736 void *argp1 = 0 ;
17737 int res1 = 0 ;
17738 void *argp2 = 0 ;
17739 int res2 = 0 ;
17740 PyObject * obj0 = 0 ;
17741 PyObject * obj1 = 0 ;
17742 char * kwnames[] = {
17743 (char *) "self",(char *) "event", NULL
17744 };
17745
17746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17748 if (!SWIG_IsOK(res1)) {
17749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17750 }
17751 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17752 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17753 if (!SWIG_IsOK(res2)) {
17754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17755 }
17756 if (!argp2) {
17757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17758 }
17759 arg2 = reinterpret_cast< wxEvent * >(argp2);
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 result = (bool)(arg1)->ProcessEvent(*arg2);
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 {
17767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17768 }
17769 return resultobj;
17770 fail:
17771 return NULL;
17772 }
17773
17774
17775 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17776 PyObject *resultobj = 0;
17777 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17778 wxEvent *arg2 = 0 ;
17779 void *argp1 = 0 ;
17780 int res1 = 0 ;
17781 void *argp2 = 0 ;
17782 int res2 = 0 ;
17783 PyObject * obj0 = 0 ;
17784 PyObject * obj1 = 0 ;
17785 char * kwnames[] = {
17786 (char *) "self",(char *) "event", NULL
17787 };
17788
17789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17791 if (!SWIG_IsOK(res1)) {
17792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17793 }
17794 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17795 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17796 if (!SWIG_IsOK(res2)) {
17797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17798 }
17799 if (!argp2) {
17800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17801 }
17802 arg2 = reinterpret_cast< wxEvent * >(argp2);
17803 {
17804 PyThreadState* __tstate = wxPyBeginAllowThreads();
17805 (arg1)->AddPendingEvent(*arg2);
17806 wxPyEndAllowThreads(__tstate);
17807 if (PyErr_Occurred()) SWIG_fail;
17808 }
17809 resultobj = SWIG_Py_Void();
17810 return resultobj;
17811 fail:
17812 return NULL;
17813 }
17814
17815
17816 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17817 PyObject *resultobj = 0;
17818 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17819 void *argp1 = 0 ;
17820 int res1 = 0 ;
17821 PyObject *swig_obj[1] ;
17822
17823 if (!args) SWIG_fail;
17824 swig_obj[0] = args;
17825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17826 if (!SWIG_IsOK(res1)) {
17827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17828 }
17829 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17830 {
17831 PyThreadState* __tstate = wxPyBeginAllowThreads();
17832 (arg1)->ProcessPendingEvents();
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 resultobj = SWIG_Py_Void();
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj = 0;
17845 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17846 int arg2 ;
17847 int arg3 ;
17848 int arg4 ;
17849 PyObject *arg5 = (PyObject *) 0 ;
17850 void *argp1 = 0 ;
17851 int res1 = 0 ;
17852 int val2 ;
17853 int ecode2 = 0 ;
17854 int val3 ;
17855 int ecode3 = 0 ;
17856 int val4 ;
17857 int ecode4 = 0 ;
17858 PyObject * obj0 = 0 ;
17859 PyObject * obj1 = 0 ;
17860 PyObject * obj2 = 0 ;
17861 PyObject * obj3 = 0 ;
17862 PyObject * obj4 = 0 ;
17863 char * kwnames[] = {
17864 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17865 };
17866
17867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17869 if (!SWIG_IsOK(res1)) {
17870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17871 }
17872 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17873 ecode2 = SWIG_AsVal_int(obj1, &val2);
17874 if (!SWIG_IsOK(ecode2)) {
17875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17876 }
17877 arg2 = static_cast< int >(val2);
17878 ecode3 = SWIG_AsVal_int(obj2, &val3);
17879 if (!SWIG_IsOK(ecode3)) {
17880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17881 }
17882 arg3 = static_cast< int >(val3);
17883 ecode4 = SWIG_AsVal_int(obj3, &val4);
17884 if (!SWIG_IsOK(ecode4)) {
17885 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17886 }
17887 arg4 = static_cast< int >(val4);
17888 arg5 = obj4;
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 resultobj = SWIG_Py_Void();
17896 return resultobj;
17897 fail:
17898 return NULL;
17899 }
17900
17901
17902 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17903 PyObject *resultobj = 0;
17904 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17905 int arg2 ;
17906 int arg3 = (int) -1 ;
17907 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17908 bool result;
17909 void *argp1 = 0 ;
17910 int res1 = 0 ;
17911 int val2 ;
17912 int ecode2 = 0 ;
17913 int val3 ;
17914 int ecode3 = 0 ;
17915 int val4 ;
17916 int ecode4 = 0 ;
17917 PyObject * obj0 = 0 ;
17918 PyObject * obj1 = 0 ;
17919 PyObject * obj2 = 0 ;
17920 PyObject * obj3 = 0 ;
17921 char * kwnames[] = {
17922 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17923 };
17924
17925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17927 if (!SWIG_IsOK(res1)) {
17928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17929 }
17930 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17931 ecode2 = SWIG_AsVal_int(obj1, &val2);
17932 if (!SWIG_IsOK(ecode2)) {
17933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17934 }
17935 arg2 = static_cast< int >(val2);
17936 if (obj2) {
17937 ecode3 = SWIG_AsVal_int(obj2, &val3);
17938 if (!SWIG_IsOK(ecode3)) {
17939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17940 }
17941 arg3 = static_cast< int >(val3);
17942 }
17943 if (obj3) {
17944 ecode4 = SWIG_AsVal_int(obj3, &val4);
17945 if (!SWIG_IsOK(ecode4)) {
17946 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17947 }
17948 arg4 = static_cast< wxEventType >(val4);
17949 }
17950 {
17951 PyThreadState* __tstate = wxPyBeginAllowThreads();
17952 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
17953 wxPyEndAllowThreads(__tstate);
17954 if (PyErr_Occurred()) SWIG_fail;
17955 }
17956 {
17957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj = 0;
17967 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17968 PyObject *arg2 = (PyObject *) 0 ;
17969 bool arg3 = (bool) true ;
17970 void *argp1 = 0 ;
17971 int res1 = 0 ;
17972 bool val3 ;
17973 int ecode3 = 0 ;
17974 PyObject * obj0 = 0 ;
17975 PyObject * obj1 = 0 ;
17976 PyObject * obj2 = 0 ;
17977 char * kwnames[] = {
17978 (char *) "self",(char *) "_self",(char *) "incref", NULL
17979 };
17980
17981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17983 if (!SWIG_IsOK(res1)) {
17984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17985 }
17986 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17987 arg2 = obj1;
17988 if (obj2) {
17989 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17990 if (!SWIG_IsOK(ecode3)) {
17991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
17992 }
17993 arg3 = static_cast< bool >(val3);
17994 }
17995 {
17996 PyThreadState* __tstate = wxPyBeginAllowThreads();
17997 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
17998 wxPyEndAllowThreads(__tstate);
17999 if (PyErr_Occurred()) SWIG_fail;
18000 }
18001 resultobj = SWIG_Py_Void();
18002 return resultobj;
18003 fail:
18004 return NULL;
18005 }
18006
18007
18008 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18009 PyObject *obj;
18010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18011 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18012 return SWIG_Py_Void();
18013 }
18014
18015 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18016 return SWIG_Python_InitShadowInstance(args);
18017 }
18018
18019 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18020 PyObject *resultobj = 0;
18021 wxEventType result;
18022
18023 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18024 {
18025 PyThreadState* __tstate = wxPyBeginAllowThreads();
18026 result = (wxEventType)wxNewEventType();
18027 wxPyEndAllowThreads(__tstate);
18028 if (PyErr_Occurred()) SWIG_fail;
18029 }
18030 resultobj = SWIG_From_int(static_cast< int >(result));
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18038 PyObject *resultobj = 0;
18039 wxEvent *arg1 = (wxEvent *) 0 ;
18040 void *argp1 = 0 ;
18041 int res1 = 0 ;
18042 PyObject *swig_obj[1] ;
18043
18044 if (!args) SWIG_fail;
18045 swig_obj[0] = args;
18046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18047 if (!SWIG_IsOK(res1)) {
18048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18049 }
18050 arg1 = reinterpret_cast< wxEvent * >(argp1);
18051 {
18052 PyThreadState* __tstate = wxPyBeginAllowThreads();
18053 delete arg1;
18054
18055 wxPyEndAllowThreads(__tstate);
18056 if (PyErr_Occurred()) SWIG_fail;
18057 }
18058 resultobj = SWIG_Py_Void();
18059 return resultobj;
18060 fail:
18061 return NULL;
18062 }
18063
18064
18065 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18066 PyObject *resultobj = 0;
18067 wxEvent *arg1 = (wxEvent *) 0 ;
18068 wxEventType arg2 ;
18069 void *argp1 = 0 ;
18070 int res1 = 0 ;
18071 int val2 ;
18072 int ecode2 = 0 ;
18073 PyObject * obj0 = 0 ;
18074 PyObject * obj1 = 0 ;
18075 char * kwnames[] = {
18076 (char *) "self",(char *) "typ", NULL
18077 };
18078
18079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18081 if (!SWIG_IsOK(res1)) {
18082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18083 }
18084 arg1 = reinterpret_cast< wxEvent * >(argp1);
18085 ecode2 = SWIG_AsVal_int(obj1, &val2);
18086 if (!SWIG_IsOK(ecode2)) {
18087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18088 }
18089 arg2 = static_cast< wxEventType >(val2);
18090 {
18091 PyThreadState* __tstate = wxPyBeginAllowThreads();
18092 (arg1)->SetEventType(arg2);
18093 wxPyEndAllowThreads(__tstate);
18094 if (PyErr_Occurred()) SWIG_fail;
18095 }
18096 resultobj = SWIG_Py_Void();
18097 return resultobj;
18098 fail:
18099 return NULL;
18100 }
18101
18102
18103 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18104 PyObject *resultobj = 0;
18105 wxEvent *arg1 = (wxEvent *) 0 ;
18106 wxEventType result;
18107 void *argp1 = 0 ;
18108 int res1 = 0 ;
18109 PyObject *swig_obj[1] ;
18110
18111 if (!args) SWIG_fail;
18112 swig_obj[0] = args;
18113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18116 }
18117 arg1 = reinterpret_cast< wxEvent * >(argp1);
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 resultobj = SWIG_From_int(static_cast< int >(result));
18125 return resultobj;
18126 fail:
18127 return NULL;
18128 }
18129
18130
18131 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18132 PyObject *resultobj = 0;
18133 wxEvent *arg1 = (wxEvent *) 0 ;
18134 wxObject *result = 0 ;
18135 void *argp1 = 0 ;
18136 int res1 = 0 ;
18137 PyObject *swig_obj[1] ;
18138
18139 if (!args) SWIG_fail;
18140 swig_obj[0] = args;
18141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18142 if (!SWIG_IsOK(res1)) {
18143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18144 }
18145 arg1 = reinterpret_cast< wxEvent * >(argp1);
18146 {
18147 PyThreadState* __tstate = wxPyBeginAllowThreads();
18148 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18149 wxPyEndAllowThreads(__tstate);
18150 if (PyErr_Occurred()) SWIG_fail;
18151 }
18152 {
18153 resultobj = wxPyMake_wxObject(result, (bool)0);
18154 }
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18162 PyObject *resultobj = 0;
18163 wxEvent *arg1 = (wxEvent *) 0 ;
18164 wxObject *arg2 = (wxObject *) 0 ;
18165 void *argp1 = 0 ;
18166 int res1 = 0 ;
18167 void *argp2 = 0 ;
18168 int res2 = 0 ;
18169 PyObject * obj0 = 0 ;
18170 PyObject * obj1 = 0 ;
18171 char * kwnames[] = {
18172 (char *) "self",(char *) "obj", NULL
18173 };
18174
18175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18177 if (!SWIG_IsOK(res1)) {
18178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18179 }
18180 arg1 = reinterpret_cast< wxEvent * >(argp1);
18181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18182 if (!SWIG_IsOK(res2)) {
18183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18184 }
18185 arg2 = reinterpret_cast< wxObject * >(argp2);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 (arg1)->SetEventObject(arg2);
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = SWIG_Py_Void();
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18200 PyObject *resultobj = 0;
18201 wxEvent *arg1 = (wxEvent *) 0 ;
18202 long result;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 PyObject *swig_obj[1] ;
18206
18207 if (!args) SWIG_fail;
18208 swig_obj[0] = args;
18209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18210 if (!SWIG_IsOK(res1)) {
18211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18212 }
18213 arg1 = reinterpret_cast< wxEvent * >(argp1);
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 resultobj = SWIG_From_long(static_cast< long >(result));
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18228 PyObject *resultobj = 0;
18229 wxEvent *arg1 = (wxEvent *) 0 ;
18230 long arg2 = (long) 0 ;
18231 void *argp1 = 0 ;
18232 int res1 = 0 ;
18233 long val2 ;
18234 int ecode2 = 0 ;
18235 PyObject * obj0 = 0 ;
18236 PyObject * obj1 = 0 ;
18237 char * kwnames[] = {
18238 (char *) "self",(char *) "ts", NULL
18239 };
18240
18241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18243 if (!SWIG_IsOK(res1)) {
18244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18245 }
18246 arg1 = reinterpret_cast< wxEvent * >(argp1);
18247 if (obj1) {
18248 ecode2 = SWIG_AsVal_long(obj1, &val2);
18249 if (!SWIG_IsOK(ecode2)) {
18250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18251 }
18252 arg2 = static_cast< long >(val2);
18253 }
18254 {
18255 PyThreadState* __tstate = wxPyBeginAllowThreads();
18256 (arg1)->SetTimestamp(arg2);
18257 wxPyEndAllowThreads(__tstate);
18258 if (PyErr_Occurred()) SWIG_fail;
18259 }
18260 resultobj = SWIG_Py_Void();
18261 return resultobj;
18262 fail:
18263 return NULL;
18264 }
18265
18266
18267 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18268 PyObject *resultobj = 0;
18269 wxEvent *arg1 = (wxEvent *) 0 ;
18270 int result;
18271 void *argp1 = 0 ;
18272 int res1 = 0 ;
18273 PyObject *swig_obj[1] ;
18274
18275 if (!args) SWIG_fail;
18276 swig_obj[0] = args;
18277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18278 if (!SWIG_IsOK(res1)) {
18279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18280 }
18281 arg1 = reinterpret_cast< wxEvent * >(argp1);
18282 {
18283 PyThreadState* __tstate = wxPyBeginAllowThreads();
18284 result = (int)((wxEvent const *)arg1)->GetId();
18285 wxPyEndAllowThreads(__tstate);
18286 if (PyErr_Occurred()) SWIG_fail;
18287 }
18288 resultobj = SWIG_From_int(static_cast< int >(result));
18289 return resultobj;
18290 fail:
18291 return NULL;
18292 }
18293
18294
18295 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18296 PyObject *resultobj = 0;
18297 wxEvent *arg1 = (wxEvent *) 0 ;
18298 int arg2 ;
18299 void *argp1 = 0 ;
18300 int res1 = 0 ;
18301 int val2 ;
18302 int ecode2 = 0 ;
18303 PyObject * obj0 = 0 ;
18304 PyObject * obj1 = 0 ;
18305 char * kwnames[] = {
18306 (char *) "self",(char *) "Id", NULL
18307 };
18308
18309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18311 if (!SWIG_IsOK(res1)) {
18312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18313 }
18314 arg1 = reinterpret_cast< wxEvent * >(argp1);
18315 ecode2 = SWIG_AsVal_int(obj1, &val2);
18316 if (!SWIG_IsOK(ecode2)) {
18317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18318 }
18319 arg2 = static_cast< int >(val2);
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 (arg1)->SetId(arg2);
18323 wxPyEndAllowThreads(__tstate);
18324 if (PyErr_Occurred()) SWIG_fail;
18325 }
18326 resultobj = SWIG_Py_Void();
18327 return resultobj;
18328 fail:
18329 return NULL;
18330 }
18331
18332
18333 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18334 PyObject *resultobj = 0;
18335 wxEvent *arg1 = (wxEvent *) 0 ;
18336 bool result;
18337 void *argp1 = 0 ;
18338 int res1 = 0 ;
18339 PyObject *swig_obj[1] ;
18340
18341 if (!args) SWIG_fail;
18342 swig_obj[0] = args;
18343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18344 if (!SWIG_IsOK(res1)) {
18345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18346 }
18347 arg1 = reinterpret_cast< wxEvent * >(argp1);
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18351 wxPyEndAllowThreads(__tstate);
18352 if (PyErr_Occurred()) SWIG_fail;
18353 }
18354 {
18355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18356 }
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18364 PyObject *resultobj = 0;
18365 wxEvent *arg1 = (wxEvent *) 0 ;
18366 bool arg2 = (bool) true ;
18367 void *argp1 = 0 ;
18368 int res1 = 0 ;
18369 bool val2 ;
18370 int ecode2 = 0 ;
18371 PyObject * obj0 = 0 ;
18372 PyObject * obj1 = 0 ;
18373 char * kwnames[] = {
18374 (char *) "self",(char *) "skip", NULL
18375 };
18376
18377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18379 if (!SWIG_IsOK(res1)) {
18380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18381 }
18382 arg1 = reinterpret_cast< wxEvent * >(argp1);
18383 if (obj1) {
18384 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18385 if (!SWIG_IsOK(ecode2)) {
18386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18387 }
18388 arg2 = static_cast< bool >(val2);
18389 }
18390 {
18391 PyThreadState* __tstate = wxPyBeginAllowThreads();
18392 (arg1)->Skip(arg2);
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
18395 }
18396 resultobj = SWIG_Py_Void();
18397 return resultobj;
18398 fail:
18399 return NULL;
18400 }
18401
18402
18403 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18404 PyObject *resultobj = 0;
18405 wxEvent *arg1 = (wxEvent *) 0 ;
18406 bool result;
18407 void *argp1 = 0 ;
18408 int res1 = 0 ;
18409 PyObject *swig_obj[1] ;
18410
18411 if (!args) SWIG_fail;
18412 swig_obj[0] = args;
18413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18414 if (!SWIG_IsOK(res1)) {
18415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18416 }
18417 arg1 = reinterpret_cast< wxEvent * >(argp1);
18418 {
18419 PyThreadState* __tstate = wxPyBeginAllowThreads();
18420 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18421 wxPyEndAllowThreads(__tstate);
18422 if (PyErr_Occurred()) SWIG_fail;
18423 }
18424 {
18425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18426 }
18427 return resultobj;
18428 fail:
18429 return NULL;
18430 }
18431
18432
18433 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18434 PyObject *resultobj = 0;
18435 wxEvent *arg1 = (wxEvent *) 0 ;
18436 bool result;
18437 void *argp1 = 0 ;
18438 int res1 = 0 ;
18439 PyObject *swig_obj[1] ;
18440
18441 if (!args) SWIG_fail;
18442 swig_obj[0] = args;
18443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18444 if (!SWIG_IsOK(res1)) {
18445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18446 }
18447 arg1 = reinterpret_cast< wxEvent * >(argp1);
18448 {
18449 PyThreadState* __tstate = wxPyBeginAllowThreads();
18450 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18451 wxPyEndAllowThreads(__tstate);
18452 if (PyErr_Occurred()) SWIG_fail;
18453 }
18454 {
18455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18456 }
18457 return resultobj;
18458 fail:
18459 return NULL;
18460 }
18461
18462
18463 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18464 PyObject *resultobj = 0;
18465 wxEvent *arg1 = (wxEvent *) 0 ;
18466 int result;
18467 void *argp1 = 0 ;
18468 int res1 = 0 ;
18469 PyObject *swig_obj[1] ;
18470
18471 if (!args) SWIG_fail;
18472 swig_obj[0] = args;
18473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18474 if (!SWIG_IsOK(res1)) {
18475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18476 }
18477 arg1 = reinterpret_cast< wxEvent * >(argp1);
18478 {
18479 PyThreadState* __tstate = wxPyBeginAllowThreads();
18480 result = (int)(arg1)->StopPropagation();
18481 wxPyEndAllowThreads(__tstate);
18482 if (PyErr_Occurred()) SWIG_fail;
18483 }
18484 resultobj = SWIG_From_int(static_cast< int >(result));
18485 return resultobj;
18486 fail:
18487 return NULL;
18488 }
18489
18490
18491 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18492 PyObject *resultobj = 0;
18493 wxEvent *arg1 = (wxEvent *) 0 ;
18494 int arg2 ;
18495 void *argp1 = 0 ;
18496 int res1 = 0 ;
18497 int val2 ;
18498 int ecode2 = 0 ;
18499 PyObject * obj0 = 0 ;
18500 PyObject * obj1 = 0 ;
18501 char * kwnames[] = {
18502 (char *) "self",(char *) "propagationLevel", NULL
18503 };
18504
18505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18507 if (!SWIG_IsOK(res1)) {
18508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18509 }
18510 arg1 = reinterpret_cast< wxEvent * >(argp1);
18511 ecode2 = SWIG_AsVal_int(obj1, &val2);
18512 if (!SWIG_IsOK(ecode2)) {
18513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18514 }
18515 arg2 = static_cast< int >(val2);
18516 {
18517 PyThreadState* __tstate = wxPyBeginAllowThreads();
18518 (arg1)->ResumePropagation(arg2);
18519 wxPyEndAllowThreads(__tstate);
18520 if (PyErr_Occurred()) SWIG_fail;
18521 }
18522 resultobj = SWIG_Py_Void();
18523 return resultobj;
18524 fail:
18525 return NULL;
18526 }
18527
18528
18529 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18530 PyObject *resultobj = 0;
18531 wxEvent *arg1 = (wxEvent *) 0 ;
18532 wxEvent *result = 0 ;
18533 void *argp1 = 0 ;
18534 int res1 = 0 ;
18535 PyObject *swig_obj[1] ;
18536
18537 if (!args) SWIG_fail;
18538 swig_obj[0] = args;
18539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18540 if (!SWIG_IsOK(res1)) {
18541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18542 }
18543 arg1 = reinterpret_cast< wxEvent * >(argp1);
18544 {
18545 PyThreadState* __tstate = wxPyBeginAllowThreads();
18546 result = (wxEvent *)(arg1)->Clone();
18547 wxPyEndAllowThreads(__tstate);
18548 if (PyErr_Occurred()) SWIG_fail;
18549 }
18550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18551 return resultobj;
18552 fail:
18553 return NULL;
18554 }
18555
18556
18557 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18558 PyObject *obj;
18559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18560 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18561 return SWIG_Py_Void();
18562 }
18563
18564 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18565 PyObject *resultobj = 0;
18566 wxEvent *arg1 = 0 ;
18567 wxPropagationDisabler *result = 0 ;
18568 void *argp1 = 0 ;
18569 int res1 = 0 ;
18570 PyObject * obj0 = 0 ;
18571 char * kwnames[] = {
18572 (char *) "event", NULL
18573 };
18574
18575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18576 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18577 if (!SWIG_IsOK(res1)) {
18578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18579 }
18580 if (!argp1) {
18581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18582 }
18583 arg1 = reinterpret_cast< wxEvent * >(argp1);
18584 {
18585 PyThreadState* __tstate = wxPyBeginAllowThreads();
18586 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18587 wxPyEndAllowThreads(__tstate);
18588 if (PyErr_Occurred()) SWIG_fail;
18589 }
18590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18598 PyObject *resultobj = 0;
18599 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18600 void *argp1 = 0 ;
18601 int res1 = 0 ;
18602 PyObject *swig_obj[1] ;
18603
18604 if (!args) SWIG_fail;
18605 swig_obj[0] = args;
18606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18607 if (!SWIG_IsOK(res1)) {
18608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18609 }
18610 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 delete arg1;
18614
18615 wxPyEndAllowThreads(__tstate);
18616 if (PyErr_Occurred()) SWIG_fail;
18617 }
18618 resultobj = SWIG_Py_Void();
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18626 PyObject *obj;
18627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18628 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18629 return SWIG_Py_Void();
18630 }
18631
18632 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18633 return SWIG_Python_InitShadowInstance(args);
18634 }
18635
18636 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18637 PyObject *resultobj = 0;
18638 wxEvent *arg1 = 0 ;
18639 wxPropagateOnce *result = 0 ;
18640 void *argp1 = 0 ;
18641 int res1 = 0 ;
18642 PyObject * obj0 = 0 ;
18643 char * kwnames[] = {
18644 (char *) "event", NULL
18645 };
18646
18647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18648 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18649 if (!SWIG_IsOK(res1)) {
18650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18651 }
18652 if (!argp1) {
18653 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18654 }
18655 arg1 = reinterpret_cast< wxEvent * >(argp1);
18656 {
18657 PyThreadState* __tstate = wxPyBeginAllowThreads();
18658 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18659 wxPyEndAllowThreads(__tstate);
18660 if (PyErr_Occurred()) SWIG_fail;
18661 }
18662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18663 return resultobj;
18664 fail:
18665 return NULL;
18666 }
18667
18668
18669 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18670 PyObject *resultobj = 0;
18671 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18672 void *argp1 = 0 ;
18673 int res1 = 0 ;
18674 PyObject *swig_obj[1] ;
18675
18676 if (!args) SWIG_fail;
18677 swig_obj[0] = args;
18678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18679 if (!SWIG_IsOK(res1)) {
18680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18681 }
18682 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18683 {
18684 PyThreadState* __tstate = wxPyBeginAllowThreads();
18685 delete arg1;
18686
18687 wxPyEndAllowThreads(__tstate);
18688 if (PyErr_Occurred()) SWIG_fail;
18689 }
18690 resultobj = SWIG_Py_Void();
18691 return resultobj;
18692 fail:
18693 return NULL;
18694 }
18695
18696
18697 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18698 PyObject *obj;
18699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18700 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18701 return SWIG_Py_Void();
18702 }
18703
18704 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18705 return SWIG_Python_InitShadowInstance(args);
18706 }
18707
18708 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18709 PyObject *resultobj = 0;
18710 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18711 int arg2 = (int) 0 ;
18712 wxCommandEvent *result = 0 ;
18713 int val1 ;
18714 int ecode1 = 0 ;
18715 int val2 ;
18716 int ecode2 = 0 ;
18717 PyObject * obj0 = 0 ;
18718 PyObject * obj1 = 0 ;
18719 char * kwnames[] = {
18720 (char *) "commandType",(char *) "winid", NULL
18721 };
18722
18723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18724 if (obj0) {
18725 ecode1 = SWIG_AsVal_int(obj0, &val1);
18726 if (!SWIG_IsOK(ecode1)) {
18727 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18728 }
18729 arg1 = static_cast< wxEventType >(val1);
18730 }
18731 if (obj1) {
18732 ecode2 = SWIG_AsVal_int(obj1, &val2);
18733 if (!SWIG_IsOK(ecode2)) {
18734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18735 }
18736 arg2 = static_cast< int >(val2);
18737 }
18738 {
18739 PyThreadState* __tstate = wxPyBeginAllowThreads();
18740 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18741 wxPyEndAllowThreads(__tstate);
18742 if (PyErr_Occurred()) SWIG_fail;
18743 }
18744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18745 return resultobj;
18746 fail:
18747 return NULL;
18748 }
18749
18750
18751 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18752 PyObject *resultobj = 0;
18753 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18754 int result;
18755 void *argp1 = 0 ;
18756 int res1 = 0 ;
18757 PyObject *swig_obj[1] ;
18758
18759 if (!args) SWIG_fail;
18760 swig_obj[0] = args;
18761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18762 if (!SWIG_IsOK(res1)) {
18763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18764 }
18765 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18766 {
18767 PyThreadState* __tstate = wxPyBeginAllowThreads();
18768 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18769 wxPyEndAllowThreads(__tstate);
18770 if (PyErr_Occurred()) SWIG_fail;
18771 }
18772 resultobj = SWIG_From_int(static_cast< int >(result));
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj = 0;
18781 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18782 wxString *arg2 = 0 ;
18783 void *argp1 = 0 ;
18784 int res1 = 0 ;
18785 bool temp2 = false ;
18786 PyObject * obj0 = 0 ;
18787 PyObject * obj1 = 0 ;
18788 char * kwnames[] = {
18789 (char *) "self",(char *) "s", NULL
18790 };
18791
18792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18794 if (!SWIG_IsOK(res1)) {
18795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18796 }
18797 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18798 {
18799 arg2 = wxString_in_helper(obj1);
18800 if (arg2 == NULL) SWIG_fail;
18801 temp2 = true;
18802 }
18803 {
18804 PyThreadState* __tstate = wxPyBeginAllowThreads();
18805 (arg1)->SetString((wxString const &)*arg2);
18806 wxPyEndAllowThreads(__tstate);
18807 if (PyErr_Occurred()) SWIG_fail;
18808 }
18809 resultobj = SWIG_Py_Void();
18810 {
18811 if (temp2)
18812 delete arg2;
18813 }
18814 return resultobj;
18815 fail:
18816 {
18817 if (temp2)
18818 delete arg2;
18819 }
18820 return NULL;
18821 }
18822
18823
18824 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825 PyObject *resultobj = 0;
18826 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18827 wxString result;
18828 void *argp1 = 0 ;
18829 int res1 = 0 ;
18830 PyObject *swig_obj[1] ;
18831
18832 if (!args) SWIG_fail;
18833 swig_obj[0] = args;
18834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18835 if (!SWIG_IsOK(res1)) {
18836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18837 }
18838 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18839 {
18840 PyThreadState* __tstate = wxPyBeginAllowThreads();
18841 result = ((wxCommandEvent const *)arg1)->GetString();
18842 wxPyEndAllowThreads(__tstate);
18843 if (PyErr_Occurred()) SWIG_fail;
18844 }
18845 {
18846 #if wxUSE_UNICODE
18847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18848 #else
18849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18850 #endif
18851 }
18852 return resultobj;
18853 fail:
18854 return NULL;
18855 }
18856
18857
18858 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18859 PyObject *resultobj = 0;
18860 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18861 bool result;
18862 void *argp1 = 0 ;
18863 int res1 = 0 ;
18864 PyObject *swig_obj[1] ;
18865
18866 if (!args) SWIG_fail;
18867 swig_obj[0] = args;
18868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18869 if (!SWIG_IsOK(res1)) {
18870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18871 }
18872 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18873 {
18874 PyThreadState* __tstate = wxPyBeginAllowThreads();
18875 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18876 wxPyEndAllowThreads(__tstate);
18877 if (PyErr_Occurred()) SWIG_fail;
18878 }
18879 {
18880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18881 }
18882 return resultobj;
18883 fail:
18884 return NULL;
18885 }
18886
18887
18888 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18889 PyObject *resultobj = 0;
18890 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18891 bool result;
18892 void *argp1 = 0 ;
18893 int res1 = 0 ;
18894 PyObject *swig_obj[1] ;
18895
18896 if (!args) SWIG_fail;
18897 swig_obj[0] = args;
18898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18899 if (!SWIG_IsOK(res1)) {
18900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18901 }
18902 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18903 {
18904 PyThreadState* __tstate = wxPyBeginAllowThreads();
18905 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18906 wxPyEndAllowThreads(__tstate);
18907 if (PyErr_Occurred()) SWIG_fail;
18908 }
18909 {
18910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18911 }
18912 return resultobj;
18913 fail:
18914 return NULL;
18915 }
18916
18917
18918 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18919 PyObject *resultobj = 0;
18920 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18921 long arg2 ;
18922 void *argp1 = 0 ;
18923 int res1 = 0 ;
18924 long val2 ;
18925 int ecode2 = 0 ;
18926 PyObject * obj0 = 0 ;
18927 PyObject * obj1 = 0 ;
18928 char * kwnames[] = {
18929 (char *) "self",(char *) "extraLong", NULL
18930 };
18931
18932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18934 if (!SWIG_IsOK(res1)) {
18935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18936 }
18937 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18938 ecode2 = SWIG_AsVal_long(obj1, &val2);
18939 if (!SWIG_IsOK(ecode2)) {
18940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18941 }
18942 arg2 = static_cast< long >(val2);
18943 {
18944 PyThreadState* __tstate = wxPyBeginAllowThreads();
18945 (arg1)->SetExtraLong(arg2);
18946 wxPyEndAllowThreads(__tstate);
18947 if (PyErr_Occurred()) SWIG_fail;
18948 }
18949 resultobj = SWIG_Py_Void();
18950 return resultobj;
18951 fail:
18952 return NULL;
18953 }
18954
18955
18956 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18957 PyObject *resultobj = 0;
18958 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18959 long result;
18960 void *argp1 = 0 ;
18961 int res1 = 0 ;
18962 PyObject *swig_obj[1] ;
18963
18964 if (!args) SWIG_fail;
18965 swig_obj[0] = args;
18966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18967 if (!SWIG_IsOK(res1)) {
18968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18969 }
18970 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 resultobj = SWIG_From_long(static_cast< long >(result));
18978 return resultobj;
18979 fail:
18980 return NULL;
18981 }
18982
18983
18984 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18985 PyObject *resultobj = 0;
18986 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18987 int arg2 ;
18988 void *argp1 = 0 ;
18989 int res1 = 0 ;
18990 int val2 ;
18991 int ecode2 = 0 ;
18992 PyObject * obj0 = 0 ;
18993 PyObject * obj1 = 0 ;
18994 char * kwnames[] = {
18995 (char *) "self",(char *) "i", NULL
18996 };
18997
18998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
18999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19000 if (!SWIG_IsOK(res1)) {
19001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19002 }
19003 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19004 ecode2 = SWIG_AsVal_int(obj1, &val2);
19005 if (!SWIG_IsOK(ecode2)) {
19006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19007 }
19008 arg2 = static_cast< int >(val2);
19009 {
19010 PyThreadState* __tstate = wxPyBeginAllowThreads();
19011 (arg1)->SetInt(arg2);
19012 wxPyEndAllowThreads(__tstate);
19013 if (PyErr_Occurred()) SWIG_fail;
19014 }
19015 resultobj = SWIG_Py_Void();
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19023 PyObject *resultobj = 0;
19024 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19025 long result;
19026 void *argp1 = 0 ;
19027 int res1 = 0 ;
19028 PyObject *swig_obj[1] ;
19029
19030 if (!args) SWIG_fail;
19031 swig_obj[0] = args;
19032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19033 if (!SWIG_IsOK(res1)) {
19034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19035 }
19036 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 resultobj = SWIG_From_long(static_cast< long >(result));
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19051 PyObject *resultobj = 0;
19052 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19053 PyObject *result = 0 ;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 PyObject *swig_obj[1] ;
19057
19058 if (!args) SWIG_fail;
19059 swig_obj[0] = args;
19060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19061 if (!SWIG_IsOK(res1)) {
19062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19063 }
19064 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19065 {
19066 PyThreadState* __tstate = wxPyBeginAllowThreads();
19067 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19068 wxPyEndAllowThreads(__tstate);
19069 if (PyErr_Occurred()) SWIG_fail;
19070 }
19071 resultobj = result;
19072 return resultobj;
19073 fail:
19074 return NULL;
19075 }
19076
19077
19078 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19079 PyObject *resultobj = 0;
19080 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19081 PyObject *arg2 = (PyObject *) 0 ;
19082 void *argp1 = 0 ;
19083 int res1 = 0 ;
19084 PyObject * obj0 = 0 ;
19085 PyObject * obj1 = 0 ;
19086 char * kwnames[] = {
19087 (char *) "self",(char *) "clientData", NULL
19088 };
19089
19090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19092 if (!SWIG_IsOK(res1)) {
19093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19094 }
19095 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19096 arg2 = obj1;
19097 {
19098 PyThreadState* __tstate = wxPyBeginAllowThreads();
19099 wxCommandEvent_SetClientData(arg1,arg2);
19100 wxPyEndAllowThreads(__tstate);
19101 if (PyErr_Occurred()) SWIG_fail;
19102 }
19103 resultobj = SWIG_Py_Void();
19104 return resultobj;
19105 fail:
19106 return NULL;
19107 }
19108
19109
19110 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19111 PyObject *resultobj = 0;
19112 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19113 wxEvent *result = 0 ;
19114 void *argp1 = 0 ;
19115 int res1 = 0 ;
19116 PyObject *swig_obj[1] ;
19117
19118 if (!args) SWIG_fail;
19119 swig_obj[0] = args;
19120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19121 if (!SWIG_IsOK(res1)) {
19122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19123 }
19124 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19125 {
19126 PyThreadState* __tstate = wxPyBeginAllowThreads();
19127 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19128 wxPyEndAllowThreads(__tstate);
19129 if (PyErr_Occurred()) SWIG_fail;
19130 }
19131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19132 return resultobj;
19133 fail:
19134 return NULL;
19135 }
19136
19137
19138 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19139 PyObject *obj;
19140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19141 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19142 return SWIG_Py_Void();
19143 }
19144
19145 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19146 return SWIG_Python_InitShadowInstance(args);
19147 }
19148
19149 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj = 0;
19151 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19152 int arg2 = (int) 0 ;
19153 wxNotifyEvent *result = 0 ;
19154 int val1 ;
19155 int ecode1 = 0 ;
19156 int val2 ;
19157 int ecode2 = 0 ;
19158 PyObject * obj0 = 0 ;
19159 PyObject * obj1 = 0 ;
19160 char * kwnames[] = {
19161 (char *) "commandType",(char *) "winid", NULL
19162 };
19163
19164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19165 if (obj0) {
19166 ecode1 = SWIG_AsVal_int(obj0, &val1);
19167 if (!SWIG_IsOK(ecode1)) {
19168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19169 }
19170 arg1 = static_cast< wxEventType >(val1);
19171 }
19172 if (obj1) {
19173 ecode2 = SWIG_AsVal_int(obj1, &val2);
19174 if (!SWIG_IsOK(ecode2)) {
19175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19176 }
19177 arg2 = static_cast< int >(val2);
19178 }
19179 {
19180 PyThreadState* __tstate = wxPyBeginAllowThreads();
19181 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19182 wxPyEndAllowThreads(__tstate);
19183 if (PyErr_Occurred()) SWIG_fail;
19184 }
19185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19186 return resultobj;
19187 fail:
19188 return NULL;
19189 }
19190
19191
19192 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19193 PyObject *resultobj = 0;
19194 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19195 void *argp1 = 0 ;
19196 int res1 = 0 ;
19197 PyObject *swig_obj[1] ;
19198
19199 if (!args) SWIG_fail;
19200 swig_obj[0] = args;
19201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19202 if (!SWIG_IsOK(res1)) {
19203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19204 }
19205 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19206 {
19207 PyThreadState* __tstate = wxPyBeginAllowThreads();
19208 (arg1)->Veto();
19209 wxPyEndAllowThreads(__tstate);
19210 if (PyErr_Occurred()) SWIG_fail;
19211 }
19212 resultobj = SWIG_Py_Void();
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19220 PyObject *resultobj = 0;
19221 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19222 void *argp1 = 0 ;
19223 int res1 = 0 ;
19224 PyObject *swig_obj[1] ;
19225
19226 if (!args) SWIG_fail;
19227 swig_obj[0] = args;
19228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19229 if (!SWIG_IsOK(res1)) {
19230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19231 }
19232 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 (arg1)->Allow();
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 resultobj = SWIG_Py_Void();
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19247 PyObject *resultobj = 0;
19248 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19249 bool result;
19250 void *argp1 = 0 ;
19251 int res1 = 0 ;
19252 PyObject *swig_obj[1] ;
19253
19254 if (!args) SWIG_fail;
19255 swig_obj[0] = args;
19256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19257 if (!SWIG_IsOK(res1)) {
19258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19259 }
19260 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 result = (bool)(arg1)->IsAllowed();
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 {
19268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19269 }
19270 return resultobj;
19271 fail:
19272 return NULL;
19273 }
19274
19275
19276 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19277 PyObject *obj;
19278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19279 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19280 return SWIG_Py_Void();
19281 }
19282
19283 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19284 return SWIG_Python_InitShadowInstance(args);
19285 }
19286
19287 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19288 PyObject *resultobj = 0;
19289 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19290 int arg2 = (int) 0 ;
19291 int arg3 = (int) 0 ;
19292 int arg4 = (int) 0 ;
19293 wxScrollEvent *result = 0 ;
19294 int val1 ;
19295 int ecode1 = 0 ;
19296 int val2 ;
19297 int ecode2 = 0 ;
19298 int val3 ;
19299 int ecode3 = 0 ;
19300 int val4 ;
19301 int ecode4 = 0 ;
19302 PyObject * obj0 = 0 ;
19303 PyObject * obj1 = 0 ;
19304 PyObject * obj2 = 0 ;
19305 PyObject * obj3 = 0 ;
19306 char * kwnames[] = {
19307 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19308 };
19309
19310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19311 if (obj0) {
19312 ecode1 = SWIG_AsVal_int(obj0, &val1);
19313 if (!SWIG_IsOK(ecode1)) {
19314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19315 }
19316 arg1 = static_cast< wxEventType >(val1);
19317 }
19318 if (obj1) {
19319 ecode2 = SWIG_AsVal_int(obj1, &val2);
19320 if (!SWIG_IsOK(ecode2)) {
19321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19322 }
19323 arg2 = static_cast< int >(val2);
19324 }
19325 if (obj2) {
19326 ecode3 = SWIG_AsVal_int(obj2, &val3);
19327 if (!SWIG_IsOK(ecode3)) {
19328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19329 }
19330 arg3 = static_cast< int >(val3);
19331 }
19332 if (obj3) {
19333 ecode4 = SWIG_AsVal_int(obj3, &val4);
19334 if (!SWIG_IsOK(ecode4)) {
19335 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19336 }
19337 arg4 = static_cast< int >(val4);
19338 }
19339 {
19340 PyThreadState* __tstate = wxPyBeginAllowThreads();
19341 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19342 wxPyEndAllowThreads(__tstate);
19343 if (PyErr_Occurred()) SWIG_fail;
19344 }
19345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19346 return resultobj;
19347 fail:
19348 return NULL;
19349 }
19350
19351
19352 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19353 PyObject *resultobj = 0;
19354 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19355 int result;
19356 void *argp1 = 0 ;
19357 int res1 = 0 ;
19358 PyObject *swig_obj[1] ;
19359
19360 if (!args) SWIG_fail;
19361 swig_obj[0] = args;
19362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19363 if (!SWIG_IsOK(res1)) {
19364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19365 }
19366 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19367 {
19368 PyThreadState* __tstate = wxPyBeginAllowThreads();
19369 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19370 wxPyEndAllowThreads(__tstate);
19371 if (PyErr_Occurred()) SWIG_fail;
19372 }
19373 resultobj = SWIG_From_int(static_cast< int >(result));
19374 return resultobj;
19375 fail:
19376 return NULL;
19377 }
19378
19379
19380 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19381 PyObject *resultobj = 0;
19382 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19383 int result;
19384 void *argp1 = 0 ;
19385 int res1 = 0 ;
19386 PyObject *swig_obj[1] ;
19387
19388 if (!args) SWIG_fail;
19389 swig_obj[0] = args;
19390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19391 if (!SWIG_IsOK(res1)) {
19392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19393 }
19394 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19395 {
19396 PyThreadState* __tstate = wxPyBeginAllowThreads();
19397 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19398 wxPyEndAllowThreads(__tstate);
19399 if (PyErr_Occurred()) SWIG_fail;
19400 }
19401 resultobj = SWIG_From_int(static_cast< int >(result));
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19409 PyObject *resultobj = 0;
19410 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19411 int arg2 ;
19412 void *argp1 = 0 ;
19413 int res1 = 0 ;
19414 int val2 ;
19415 int ecode2 = 0 ;
19416 PyObject * obj0 = 0 ;
19417 PyObject * obj1 = 0 ;
19418 char * kwnames[] = {
19419 (char *) "self",(char *) "orient", NULL
19420 };
19421
19422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19424 if (!SWIG_IsOK(res1)) {
19425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19426 }
19427 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19428 ecode2 = SWIG_AsVal_int(obj1, &val2);
19429 if (!SWIG_IsOK(ecode2)) {
19430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19431 }
19432 arg2 = static_cast< int >(val2);
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 (arg1)->SetOrientation(arg2);
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 resultobj = SWIG_Py_Void();
19440 return resultobj;
19441 fail:
19442 return NULL;
19443 }
19444
19445
19446 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19447 PyObject *resultobj = 0;
19448 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19449 int arg2 ;
19450 void *argp1 = 0 ;
19451 int res1 = 0 ;
19452 int val2 ;
19453 int ecode2 = 0 ;
19454 PyObject * obj0 = 0 ;
19455 PyObject * obj1 = 0 ;
19456 char * kwnames[] = {
19457 (char *) "self",(char *) "pos", NULL
19458 };
19459
19460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19462 if (!SWIG_IsOK(res1)) {
19463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19464 }
19465 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19466 ecode2 = SWIG_AsVal_int(obj1, &val2);
19467 if (!SWIG_IsOK(ecode2)) {
19468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19469 }
19470 arg2 = static_cast< int >(val2);
19471 {
19472 PyThreadState* __tstate = wxPyBeginAllowThreads();
19473 (arg1)->SetPosition(arg2);
19474 wxPyEndAllowThreads(__tstate);
19475 if (PyErr_Occurred()) SWIG_fail;
19476 }
19477 resultobj = SWIG_Py_Void();
19478 return resultobj;
19479 fail:
19480 return NULL;
19481 }
19482
19483
19484 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19485 PyObject *obj;
19486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19487 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19488 return SWIG_Py_Void();
19489 }
19490
19491 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19492 return SWIG_Python_InitShadowInstance(args);
19493 }
19494
19495 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19496 PyObject *resultobj = 0;
19497 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19498 int arg2 = (int) 0 ;
19499 int arg3 = (int) 0 ;
19500 wxScrollWinEvent *result = 0 ;
19501 int val1 ;
19502 int ecode1 = 0 ;
19503 int val2 ;
19504 int ecode2 = 0 ;
19505 int val3 ;
19506 int ecode3 = 0 ;
19507 PyObject * obj0 = 0 ;
19508 PyObject * obj1 = 0 ;
19509 PyObject * obj2 = 0 ;
19510 char * kwnames[] = {
19511 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19512 };
19513
19514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19515 if (obj0) {
19516 ecode1 = SWIG_AsVal_int(obj0, &val1);
19517 if (!SWIG_IsOK(ecode1)) {
19518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19519 }
19520 arg1 = static_cast< wxEventType >(val1);
19521 }
19522 if (obj1) {
19523 ecode2 = SWIG_AsVal_int(obj1, &val2);
19524 if (!SWIG_IsOK(ecode2)) {
19525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19526 }
19527 arg2 = static_cast< int >(val2);
19528 }
19529 if (obj2) {
19530 ecode3 = SWIG_AsVal_int(obj2, &val3);
19531 if (!SWIG_IsOK(ecode3)) {
19532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19533 }
19534 arg3 = static_cast< int >(val3);
19535 }
19536 {
19537 PyThreadState* __tstate = wxPyBeginAllowThreads();
19538 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19539 wxPyEndAllowThreads(__tstate);
19540 if (PyErr_Occurred()) SWIG_fail;
19541 }
19542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19543 return resultobj;
19544 fail:
19545 return NULL;
19546 }
19547
19548
19549 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19550 PyObject *resultobj = 0;
19551 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19552 int result;
19553 void *argp1 = 0 ;
19554 int res1 = 0 ;
19555 PyObject *swig_obj[1] ;
19556
19557 if (!args) SWIG_fail;
19558 swig_obj[0] = args;
19559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19560 if (!SWIG_IsOK(res1)) {
19561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19562 }
19563 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19564 {
19565 PyThreadState* __tstate = wxPyBeginAllowThreads();
19566 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 resultobj = SWIG_From_int(static_cast< int >(result));
19571 return resultobj;
19572 fail:
19573 return NULL;
19574 }
19575
19576
19577 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19578 PyObject *resultobj = 0;
19579 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19580 int result;
19581 void *argp1 = 0 ;
19582 int res1 = 0 ;
19583 PyObject *swig_obj[1] ;
19584
19585 if (!args) SWIG_fail;
19586 swig_obj[0] = args;
19587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19588 if (!SWIG_IsOK(res1)) {
19589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19590 }
19591 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19592 {
19593 PyThreadState* __tstate = wxPyBeginAllowThreads();
19594 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19595 wxPyEndAllowThreads(__tstate);
19596 if (PyErr_Occurred()) SWIG_fail;
19597 }
19598 resultobj = SWIG_From_int(static_cast< int >(result));
19599 return resultobj;
19600 fail:
19601 return NULL;
19602 }
19603
19604
19605 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19606 PyObject *resultobj = 0;
19607 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19608 int arg2 ;
19609 void *argp1 = 0 ;
19610 int res1 = 0 ;
19611 int val2 ;
19612 int ecode2 = 0 ;
19613 PyObject * obj0 = 0 ;
19614 PyObject * obj1 = 0 ;
19615 char * kwnames[] = {
19616 (char *) "self",(char *) "orient", NULL
19617 };
19618
19619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19621 if (!SWIG_IsOK(res1)) {
19622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19623 }
19624 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19625 ecode2 = SWIG_AsVal_int(obj1, &val2);
19626 if (!SWIG_IsOK(ecode2)) {
19627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19628 }
19629 arg2 = static_cast< int >(val2);
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 (arg1)->SetOrientation(arg2);
19633 wxPyEndAllowThreads(__tstate);
19634 if (PyErr_Occurred()) SWIG_fail;
19635 }
19636 resultobj = SWIG_Py_Void();
19637 return resultobj;
19638 fail:
19639 return NULL;
19640 }
19641
19642
19643 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19644 PyObject *resultobj = 0;
19645 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19646 int arg2 ;
19647 void *argp1 = 0 ;
19648 int res1 = 0 ;
19649 int val2 ;
19650 int ecode2 = 0 ;
19651 PyObject * obj0 = 0 ;
19652 PyObject * obj1 = 0 ;
19653 char * kwnames[] = {
19654 (char *) "self",(char *) "pos", NULL
19655 };
19656
19657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19659 if (!SWIG_IsOK(res1)) {
19660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19661 }
19662 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19663 ecode2 = SWIG_AsVal_int(obj1, &val2);
19664 if (!SWIG_IsOK(ecode2)) {
19665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19666 }
19667 arg2 = static_cast< int >(val2);
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 (arg1)->SetPosition(arg2);
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 resultobj = SWIG_Py_Void();
19675 return resultobj;
19676 fail:
19677 return NULL;
19678 }
19679
19680
19681 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19682 PyObject *obj;
19683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19684 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19685 return SWIG_Py_Void();
19686 }
19687
19688 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19689 return SWIG_Python_InitShadowInstance(args);
19690 }
19691
19692 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19693 PyObject *resultobj = 0;
19694 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19695 wxMouseEvent *result = 0 ;
19696 int val1 ;
19697 int ecode1 = 0 ;
19698 PyObject * obj0 = 0 ;
19699 char * kwnames[] = {
19700 (char *) "mouseType", NULL
19701 };
19702
19703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19704 if (obj0) {
19705 ecode1 = SWIG_AsVal_int(obj0, &val1);
19706 if (!SWIG_IsOK(ecode1)) {
19707 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19708 }
19709 arg1 = static_cast< wxEventType >(val1);
19710 }
19711 {
19712 PyThreadState* __tstate = wxPyBeginAllowThreads();
19713 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19714 wxPyEndAllowThreads(__tstate);
19715 if (PyErr_Occurred()) SWIG_fail;
19716 }
19717 {
19718 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19719 }
19720 return resultobj;
19721 fail:
19722 return NULL;
19723 }
19724
19725
19726 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19727 PyObject *resultobj = 0;
19728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19729 bool result;
19730 void *argp1 = 0 ;
19731 int res1 = 0 ;
19732 PyObject *swig_obj[1] ;
19733
19734 if (!args) SWIG_fail;
19735 swig_obj[0] = args;
19736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19737 if (!SWIG_IsOK(res1)) {
19738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19739 }
19740 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19741 {
19742 PyThreadState* __tstate = wxPyBeginAllowThreads();
19743 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19744 wxPyEndAllowThreads(__tstate);
19745 if (PyErr_Occurred()) SWIG_fail;
19746 }
19747 {
19748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19749 }
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj = 0;
19758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19759 int arg2 = (int) wxMOUSE_BTN_ANY ;
19760 bool result;
19761 void *argp1 = 0 ;
19762 int res1 = 0 ;
19763 int val2 ;
19764 int ecode2 = 0 ;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 char * kwnames[] = {
19768 (char *) "self",(char *) "but", NULL
19769 };
19770
19771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19773 if (!SWIG_IsOK(res1)) {
19774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19775 }
19776 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19777 if (obj1) {
19778 ecode2 = SWIG_AsVal_int(obj1, &val2);
19779 if (!SWIG_IsOK(ecode2)) {
19780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19781 }
19782 arg2 = static_cast< int >(val2);
19783 }
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 {
19791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19792 }
19793 return resultobj;
19794 fail:
19795 return NULL;
19796 }
19797
19798
19799 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19800 PyObject *resultobj = 0;
19801 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19802 int arg2 = (int) wxMOUSE_BTN_ANY ;
19803 bool result;
19804 void *argp1 = 0 ;
19805 int res1 = 0 ;
19806 int val2 ;
19807 int ecode2 = 0 ;
19808 PyObject * obj0 = 0 ;
19809 PyObject * obj1 = 0 ;
19810 char * kwnames[] = {
19811 (char *) "self",(char *) "but", NULL
19812 };
19813
19814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19816 if (!SWIG_IsOK(res1)) {
19817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19818 }
19819 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19820 if (obj1) {
19821 ecode2 = SWIG_AsVal_int(obj1, &val2);
19822 if (!SWIG_IsOK(ecode2)) {
19823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19824 }
19825 arg2 = static_cast< int >(val2);
19826 }
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19835 }
19836 return resultobj;
19837 fail:
19838 return NULL;
19839 }
19840
19841
19842 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19843 PyObject *resultobj = 0;
19844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19845 int arg2 = (int) wxMOUSE_BTN_ANY ;
19846 bool result;
19847 void *argp1 = 0 ;
19848 int res1 = 0 ;
19849 int val2 ;
19850 int ecode2 = 0 ;
19851 PyObject * obj0 = 0 ;
19852 PyObject * obj1 = 0 ;
19853 char * kwnames[] = {
19854 (char *) "self",(char *) "but", NULL
19855 };
19856
19857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19859 if (!SWIG_IsOK(res1)) {
19860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19861 }
19862 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19863 if (obj1) {
19864 ecode2 = SWIG_AsVal_int(obj1, &val2);
19865 if (!SWIG_IsOK(ecode2)) {
19866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19867 }
19868 arg2 = static_cast< int >(val2);
19869 }
19870 {
19871 PyThreadState* __tstate = wxPyBeginAllowThreads();
19872 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19873 wxPyEndAllowThreads(__tstate);
19874 if (PyErr_Occurred()) SWIG_fail;
19875 }
19876 {
19877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19878 }
19879 return resultobj;
19880 fail:
19881 return NULL;
19882 }
19883
19884
19885 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj = 0;
19887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19888 int arg2 ;
19889 bool result;
19890 void *argp1 = 0 ;
19891 int res1 = 0 ;
19892 int val2 ;
19893 int ecode2 = 0 ;
19894 PyObject * obj0 = 0 ;
19895 PyObject * obj1 = 0 ;
19896 char * kwnames[] = {
19897 (char *) "self",(char *) "button", NULL
19898 };
19899
19900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19902 if (!SWIG_IsOK(res1)) {
19903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19904 }
19905 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19906 ecode2 = SWIG_AsVal_int(obj1, &val2);
19907 if (!SWIG_IsOK(ecode2)) {
19908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19909 }
19910 arg2 = static_cast< int >(val2);
19911 {
19912 PyThreadState* __tstate = wxPyBeginAllowThreads();
19913 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 {
19918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19919 }
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19927 PyObject *resultobj = 0;
19928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19929 int arg2 ;
19930 bool result;
19931 void *argp1 = 0 ;
19932 int res1 = 0 ;
19933 int val2 ;
19934 int ecode2 = 0 ;
19935 PyObject * obj0 = 0 ;
19936 PyObject * obj1 = 0 ;
19937 char * kwnames[] = {
19938 (char *) "self",(char *) "but", NULL
19939 };
19940
19941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19943 if (!SWIG_IsOK(res1)) {
19944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19945 }
19946 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19947 ecode2 = SWIG_AsVal_int(obj1, &val2);
19948 if (!SWIG_IsOK(ecode2)) {
19949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19950 }
19951 arg2 = static_cast< int >(val2);
19952 {
19953 PyThreadState* __tstate = wxPyBeginAllowThreads();
19954 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
19955 wxPyEndAllowThreads(__tstate);
19956 if (PyErr_Occurred()) SWIG_fail;
19957 }
19958 {
19959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19960 }
19961 return resultobj;
19962 fail:
19963 return NULL;
19964 }
19965
19966
19967 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19968 PyObject *resultobj = 0;
19969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19970 int result;
19971 void *argp1 = 0 ;
19972 int res1 = 0 ;
19973 PyObject *swig_obj[1] ;
19974
19975 if (!args) SWIG_fail;
19976 swig_obj[0] = args;
19977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19978 if (!SWIG_IsOK(res1)) {
19979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19980 }
19981 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19982 {
19983 PyThreadState* __tstate = wxPyBeginAllowThreads();
19984 result = (int)((wxMouseEvent const *)arg1)->GetButton();
19985 wxPyEndAllowThreads(__tstate);
19986 if (PyErr_Occurred()) SWIG_fail;
19987 }
19988 resultobj = SWIG_From_int(static_cast< int >(result));
19989 return resultobj;
19990 fail:
19991 return NULL;
19992 }
19993
19994
19995 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19996 PyObject *resultobj = 0;
19997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19998 bool result;
19999 void *argp1 = 0 ;
20000 int res1 = 0 ;
20001 PyObject *swig_obj[1] ;
20002
20003 if (!args) SWIG_fail;
20004 swig_obj[0] = args;
20005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20006 if (!SWIG_IsOK(res1)) {
20007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20008 }
20009 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20010 {
20011 PyThreadState* __tstate = wxPyBeginAllowThreads();
20012 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20013 wxPyEndAllowThreads(__tstate);
20014 if (PyErr_Occurred()) SWIG_fail;
20015 }
20016 {
20017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20018 }
20019 return resultobj;
20020 fail:
20021 return NULL;
20022 }
20023
20024
20025 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20026 PyObject *resultobj = 0;
20027 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20028 bool result;
20029 void *argp1 = 0 ;
20030 int res1 = 0 ;
20031 PyObject *swig_obj[1] ;
20032
20033 if (!args) SWIG_fail;
20034 swig_obj[0] = args;
20035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20036 if (!SWIG_IsOK(res1)) {
20037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20038 }
20039 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20043 wxPyEndAllowThreads(__tstate);
20044 if (PyErr_Occurred()) SWIG_fail;
20045 }
20046 {
20047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20048 }
20049 return resultobj;
20050 fail:
20051 return NULL;
20052 }
20053
20054
20055 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20056 PyObject *resultobj = 0;
20057 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20058 bool result;
20059 void *argp1 = 0 ;
20060 int res1 = 0 ;
20061 PyObject *swig_obj[1] ;
20062
20063 if (!args) SWIG_fail;
20064 swig_obj[0] = args;
20065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20066 if (!SWIG_IsOK(res1)) {
20067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20068 }
20069 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20070 {
20071 PyThreadState* __tstate = wxPyBeginAllowThreads();
20072 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20073 wxPyEndAllowThreads(__tstate);
20074 if (PyErr_Occurred()) SWIG_fail;
20075 }
20076 {
20077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20078 }
20079 return resultobj;
20080 fail:
20081 return NULL;
20082 }
20083
20084
20085 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20086 PyObject *resultobj = 0;
20087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20088 bool result;
20089 void *argp1 = 0 ;
20090 int res1 = 0 ;
20091 PyObject *swig_obj[1] ;
20092
20093 if (!args) SWIG_fail;
20094 swig_obj[0] = args;
20095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20096 if (!SWIG_IsOK(res1)) {
20097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20098 }
20099 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20100 {
20101 PyThreadState* __tstate = wxPyBeginAllowThreads();
20102 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20103 wxPyEndAllowThreads(__tstate);
20104 if (PyErr_Occurred()) SWIG_fail;
20105 }
20106 {
20107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20108 }
20109 return resultobj;
20110 fail:
20111 return NULL;
20112 }
20113
20114
20115 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20116 PyObject *resultobj = 0;
20117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20118 bool result;
20119 void *argp1 = 0 ;
20120 int res1 = 0 ;
20121 PyObject *swig_obj[1] ;
20122
20123 if (!args) SWIG_fail;
20124 swig_obj[0] = args;
20125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20126 if (!SWIG_IsOK(res1)) {
20127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20128 }
20129 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20130 {
20131 PyThreadState* __tstate = wxPyBeginAllowThreads();
20132 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20133 wxPyEndAllowThreads(__tstate);
20134 if (PyErr_Occurred()) SWIG_fail;
20135 }
20136 {
20137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20138 }
20139 return resultobj;
20140 fail:
20141 return NULL;
20142 }
20143
20144
20145 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20146 PyObject *resultobj = 0;
20147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20148 bool result;
20149 void *argp1 = 0 ;
20150 int res1 = 0 ;
20151 PyObject *swig_obj[1] ;
20152
20153 if (!args) SWIG_fail;
20154 swig_obj[0] = args;
20155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20156 if (!SWIG_IsOK(res1)) {
20157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20158 }
20159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 {
20167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20168 }
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20176 PyObject *resultobj = 0;
20177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20178 bool result;
20179 void *argp1 = 0 ;
20180 int res1 = 0 ;
20181 PyObject *swig_obj[1] ;
20182
20183 if (!args) SWIG_fail;
20184 swig_obj[0] = args;
20185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20186 if (!SWIG_IsOK(res1)) {
20187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20188 }
20189 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20190 {
20191 PyThreadState* __tstate = wxPyBeginAllowThreads();
20192 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 {
20197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20198 }
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20206 PyObject *resultobj = 0;
20207 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20208 bool result;
20209 void *argp1 = 0 ;
20210 int res1 = 0 ;
20211 PyObject *swig_obj[1] ;
20212
20213 if (!args) SWIG_fail;
20214 swig_obj[0] = args;
20215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20216 if (!SWIG_IsOK(res1)) {
20217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20218 }
20219 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20220 {
20221 PyThreadState* __tstate = wxPyBeginAllowThreads();
20222 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 {
20227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20228 }
20229 return resultobj;
20230 fail:
20231 return NULL;
20232 }
20233
20234
20235 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20236 PyObject *resultobj = 0;
20237 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20238 bool result;
20239 void *argp1 = 0 ;
20240 int res1 = 0 ;
20241 PyObject *swig_obj[1] ;
20242
20243 if (!args) SWIG_fail;
20244 swig_obj[0] = args;
20245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20246 if (!SWIG_IsOK(res1)) {
20247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20248 }
20249 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 {
20257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20258 }
20259 return resultobj;
20260 fail:
20261 return NULL;
20262 }
20263
20264
20265 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20266 PyObject *resultobj = 0;
20267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20268 bool result;
20269 void *argp1 = 0 ;
20270 int res1 = 0 ;
20271 PyObject *swig_obj[1] ;
20272
20273 if (!args) SWIG_fail;
20274 swig_obj[0] = args;
20275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20276 if (!SWIG_IsOK(res1)) {
20277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20278 }
20279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20280 {
20281 PyThreadState* __tstate = wxPyBeginAllowThreads();
20282 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20283 wxPyEndAllowThreads(__tstate);
20284 if (PyErr_Occurred()) SWIG_fail;
20285 }
20286 {
20287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20288 }
20289 return resultobj;
20290 fail:
20291 return NULL;
20292 }
20293
20294
20295 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20296 PyObject *resultobj = 0;
20297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20298 bool result;
20299 void *argp1 = 0 ;
20300 int res1 = 0 ;
20301 PyObject *swig_obj[1] ;
20302
20303 if (!args) SWIG_fail;
20304 swig_obj[0] = args;
20305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20306 if (!SWIG_IsOK(res1)) {
20307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20308 }
20309 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20310 {
20311 PyThreadState* __tstate = wxPyBeginAllowThreads();
20312 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 {
20317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20318 }
20319 return resultobj;
20320 fail:
20321 return NULL;
20322 }
20323
20324
20325 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20326 PyObject *resultobj = 0;
20327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20328 bool result;
20329 void *argp1 = 0 ;
20330 int res1 = 0 ;
20331 PyObject *swig_obj[1] ;
20332
20333 if (!args) SWIG_fail;
20334 swig_obj[0] = args;
20335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20336 if (!SWIG_IsOK(res1)) {
20337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20338 }
20339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20340 {
20341 PyThreadState* __tstate = wxPyBeginAllowThreads();
20342 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20343 wxPyEndAllowThreads(__tstate);
20344 if (PyErr_Occurred()) SWIG_fail;
20345 }
20346 {
20347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20348 }
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20356 PyObject *resultobj = 0;
20357 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20358 bool result;
20359 void *argp1 = 0 ;
20360 int res1 = 0 ;
20361 PyObject *swig_obj[1] ;
20362
20363 if (!args) SWIG_fail;
20364 swig_obj[0] = args;
20365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20366 if (!SWIG_IsOK(res1)) {
20367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20368 }
20369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20373 wxPyEndAllowThreads(__tstate);
20374 if (PyErr_Occurred()) SWIG_fail;
20375 }
20376 {
20377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20378 }
20379 return resultobj;
20380 fail:
20381 return NULL;
20382 }
20383
20384
20385 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 PyObject *resultobj = 0;
20387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20388 bool result;
20389 void *argp1 = 0 ;
20390 int res1 = 0 ;
20391 PyObject *swig_obj[1] ;
20392
20393 if (!args) SWIG_fail;
20394 swig_obj[0] = args;
20395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20396 if (!SWIG_IsOK(res1)) {
20397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20398 }
20399 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20400 {
20401 PyThreadState* __tstate = wxPyBeginAllowThreads();
20402 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 {
20407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20408 }
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20416 PyObject *resultobj = 0;
20417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20418 bool result;
20419 void *argp1 = 0 ;
20420 int res1 = 0 ;
20421 PyObject *swig_obj[1] ;
20422
20423 if (!args) SWIG_fail;
20424 swig_obj[0] = args;
20425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20426 if (!SWIG_IsOK(res1)) {
20427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20428 }
20429 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = (bool)(arg1)->LeftIsDown();
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 {
20437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20438 }
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20448 bool result;
20449 void *argp1 = 0 ;
20450 int res1 = 0 ;
20451 PyObject *swig_obj[1] ;
20452
20453 if (!args) SWIG_fail;
20454 swig_obj[0] = args;
20455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20456 if (!SWIG_IsOK(res1)) {
20457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20458 }
20459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20460 {
20461 PyThreadState* __tstate = wxPyBeginAllowThreads();
20462 result = (bool)(arg1)->MiddleIsDown();
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 {
20467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20468 }
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20476 PyObject *resultobj = 0;
20477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20478 bool result;
20479 void *argp1 = 0 ;
20480 int res1 = 0 ;
20481 PyObject *swig_obj[1] ;
20482
20483 if (!args) SWIG_fail;
20484 swig_obj[0] = args;
20485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20486 if (!SWIG_IsOK(res1)) {
20487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20488 }
20489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20490 {
20491 PyThreadState* __tstate = wxPyBeginAllowThreads();
20492 result = (bool)(arg1)->RightIsDown();
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 {
20497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20498 }
20499 return resultobj;
20500 fail:
20501 return NULL;
20502 }
20503
20504
20505 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20506 PyObject *resultobj = 0;
20507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20508 bool result;
20509 void *argp1 = 0 ;
20510 int res1 = 0 ;
20511 PyObject *swig_obj[1] ;
20512
20513 if (!args) SWIG_fail;
20514 swig_obj[0] = args;
20515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20516 if (!SWIG_IsOK(res1)) {
20517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20518 }
20519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20520 {
20521 PyThreadState* __tstate = wxPyBeginAllowThreads();
20522 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 {
20527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20528 }
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20536 PyObject *resultobj = 0;
20537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20538 bool result;
20539 void *argp1 = 0 ;
20540 int res1 = 0 ;
20541 PyObject *swig_obj[1] ;
20542
20543 if (!args) SWIG_fail;
20544 swig_obj[0] = args;
20545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20546 if (!SWIG_IsOK(res1)) {
20547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20548 }
20549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20550 {
20551 PyThreadState* __tstate = wxPyBeginAllowThreads();
20552 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 {
20557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20558 }
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20566 PyObject *resultobj = 0;
20567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20568 bool result;
20569 void *argp1 = 0 ;
20570 int res1 = 0 ;
20571 PyObject *swig_obj[1] ;
20572
20573 if (!args) SWIG_fail;
20574 swig_obj[0] = args;
20575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20576 if (!SWIG_IsOK(res1)) {
20577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20578 }
20579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20588 }
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20596 PyObject *resultobj = 0;
20597 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20598 bool result;
20599 void *argp1 = 0 ;
20600 int res1 = 0 ;
20601 PyObject *swig_obj[1] ;
20602
20603 if (!args) SWIG_fail;
20604 swig_obj[0] = args;
20605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20608 }
20609 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 {
20617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20618 }
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20626 PyObject *resultobj = 0;
20627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20628 wxPoint result;
20629 void *argp1 = 0 ;
20630 int res1 = 0 ;
20631 PyObject *swig_obj[1] ;
20632
20633 if (!args) SWIG_fail;
20634 swig_obj[0] = args;
20635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20636 if (!SWIG_IsOK(res1)) {
20637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20638 }
20639 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 result = (arg1)->GetPosition();
20643 wxPyEndAllowThreads(__tstate);
20644 if (PyErr_Occurred()) SWIG_fail;
20645 }
20646 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20647 return resultobj;
20648 fail:
20649 return NULL;
20650 }
20651
20652
20653 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20654 PyObject *resultobj = 0;
20655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20656 long *arg2 = (long *) 0 ;
20657 long *arg3 = (long *) 0 ;
20658 void *argp1 = 0 ;
20659 int res1 = 0 ;
20660 long temp2 ;
20661 int res2 = SWIG_TMPOBJ ;
20662 long temp3 ;
20663 int res3 = SWIG_TMPOBJ ;
20664 PyObject *swig_obj[1] ;
20665
20666 arg2 = &temp2;
20667 arg3 = &temp3;
20668 if (!args) SWIG_fail;
20669 swig_obj[0] = args;
20670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20671 if (!SWIG_IsOK(res1)) {
20672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20673 }
20674 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20675 {
20676 PyThreadState* __tstate = wxPyBeginAllowThreads();
20677 (arg1)->GetPosition(arg2,arg3);
20678 wxPyEndAllowThreads(__tstate);
20679 if (PyErr_Occurred()) SWIG_fail;
20680 }
20681 resultobj = SWIG_Py_Void();
20682 if (SWIG_IsTmpObj(res2)) {
20683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20684 } else {
20685 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20687 }
20688 if (SWIG_IsTmpObj(res3)) {
20689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20690 } else {
20691 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20693 }
20694 return resultobj;
20695 fail:
20696 return NULL;
20697 }
20698
20699
20700 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20701 PyObject *resultobj = 0;
20702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20703 wxDC *arg2 = 0 ;
20704 wxPoint result;
20705 void *argp1 = 0 ;
20706 int res1 = 0 ;
20707 void *argp2 = 0 ;
20708 int res2 = 0 ;
20709 PyObject * obj0 = 0 ;
20710 PyObject * obj1 = 0 ;
20711 char * kwnames[] = {
20712 (char *) "self",(char *) "dc", NULL
20713 };
20714
20715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20717 if (!SWIG_IsOK(res1)) {
20718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20719 }
20720 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20722 if (!SWIG_IsOK(res2)) {
20723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20724 }
20725 if (!argp2) {
20726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20727 }
20728 arg2 = reinterpret_cast< wxDC * >(argp2);
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20736 return resultobj;
20737 fail:
20738 return NULL;
20739 }
20740
20741
20742 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20743 PyObject *resultobj = 0;
20744 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20745 int result;
20746 void *argp1 = 0 ;
20747 int res1 = 0 ;
20748 PyObject *swig_obj[1] ;
20749
20750 if (!args) SWIG_fail;
20751 swig_obj[0] = args;
20752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20753 if (!SWIG_IsOK(res1)) {
20754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20755 }
20756 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20757 {
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 result = (int)((wxMouseEvent const *)arg1)->GetX();
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 resultobj = SWIG_From_int(static_cast< int >(result));
20764 return resultobj;
20765 fail:
20766 return NULL;
20767 }
20768
20769
20770 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20771 PyObject *resultobj = 0;
20772 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20773 int result;
20774 void *argp1 = 0 ;
20775 int res1 = 0 ;
20776 PyObject *swig_obj[1] ;
20777
20778 if (!args) SWIG_fail;
20779 swig_obj[0] = args;
20780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20781 if (!SWIG_IsOK(res1)) {
20782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20783 }
20784 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (int)((wxMouseEvent const *)arg1)->GetY();
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 resultobj = SWIG_From_int(static_cast< int >(result));
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20799 PyObject *resultobj = 0;
20800 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20801 int result;
20802 void *argp1 = 0 ;
20803 int res1 = 0 ;
20804 PyObject *swig_obj[1] ;
20805
20806 if (!args) SWIG_fail;
20807 swig_obj[0] = args;
20808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20809 if (!SWIG_IsOK(res1)) {
20810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20811 }
20812 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_From_int(static_cast< int >(result));
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20827 PyObject *resultobj = 0;
20828 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20829 int result;
20830 void *argp1 = 0 ;
20831 int res1 = 0 ;
20832 PyObject *swig_obj[1] ;
20833
20834 if (!args) SWIG_fail;
20835 swig_obj[0] = args;
20836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20837 if (!SWIG_IsOK(res1)) {
20838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20839 }
20840 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20841 {
20842 PyThreadState* __tstate = wxPyBeginAllowThreads();
20843 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20844 wxPyEndAllowThreads(__tstate);
20845 if (PyErr_Occurred()) SWIG_fail;
20846 }
20847 resultobj = SWIG_From_int(static_cast< int >(result));
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20855 PyObject *resultobj = 0;
20856 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20857 int result;
20858 void *argp1 = 0 ;
20859 int res1 = 0 ;
20860 PyObject *swig_obj[1] ;
20861
20862 if (!args) SWIG_fail;
20863 swig_obj[0] = args;
20864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20865 if (!SWIG_IsOK(res1)) {
20866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20867 }
20868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20869 {
20870 PyThreadState* __tstate = wxPyBeginAllowThreads();
20871 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 resultobj = SWIG_From_int(static_cast< int >(result));
20876 return resultobj;
20877 fail:
20878 return NULL;
20879 }
20880
20881
20882 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20883 PyObject *resultobj = 0;
20884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20885 bool result;
20886 void *argp1 = 0 ;
20887 int res1 = 0 ;
20888 PyObject *swig_obj[1] ;
20889
20890 if (!args) SWIG_fail;
20891 swig_obj[0] = args;
20892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20893 if (!SWIG_IsOK(res1)) {
20894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20895 }
20896 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20897 {
20898 PyThreadState* __tstate = wxPyBeginAllowThreads();
20899 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20900 wxPyEndAllowThreads(__tstate);
20901 if (PyErr_Occurred()) SWIG_fail;
20902 }
20903 {
20904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20905 }
20906 return resultobj;
20907 fail:
20908 return NULL;
20909 }
20910
20911
20912 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20913 PyObject *resultobj = 0;
20914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20915 int arg2 ;
20916 void *argp1 = 0 ;
20917 int res1 = 0 ;
20918 int val2 ;
20919 int ecode2 = 0 ;
20920 PyObject *swig_obj[2] ;
20921
20922 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20924 if (!SWIG_IsOK(res1)) {
20925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20926 }
20927 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20928 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20929 if (!SWIG_IsOK(ecode2)) {
20930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20931 }
20932 arg2 = static_cast< int >(val2);
20933 if (arg1) (arg1)->m_x = arg2;
20934
20935 resultobj = SWIG_Py_Void();
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *resultobj = 0;
20944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20945 int result;
20946 void *argp1 = 0 ;
20947 int res1 = 0 ;
20948 PyObject *swig_obj[1] ;
20949
20950 if (!args) SWIG_fail;
20951 swig_obj[0] = args;
20952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20953 if (!SWIG_IsOK(res1)) {
20954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20955 }
20956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20957 result = (int) ((arg1)->m_x);
20958 resultobj = SWIG_From_int(static_cast< int >(result));
20959 return resultobj;
20960 fail:
20961 return NULL;
20962 }
20963
20964
20965 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20966 PyObject *resultobj = 0;
20967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20968 int arg2 ;
20969 void *argp1 = 0 ;
20970 int res1 = 0 ;
20971 int val2 ;
20972 int ecode2 = 0 ;
20973 PyObject *swig_obj[2] ;
20974
20975 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
20976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20977 if (!SWIG_IsOK(res1)) {
20978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20979 }
20980 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20981 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20982 if (!SWIG_IsOK(ecode2)) {
20983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
20984 }
20985 arg2 = static_cast< int >(val2);
20986 if (arg1) (arg1)->m_y = arg2;
20987
20988 resultobj = SWIG_Py_Void();
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20996 PyObject *resultobj = 0;
20997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20998 int result;
20999 void *argp1 = 0 ;
21000 int res1 = 0 ;
21001 PyObject *swig_obj[1] ;
21002
21003 if (!args) SWIG_fail;
21004 swig_obj[0] = args;
21005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21006 if (!SWIG_IsOK(res1)) {
21007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21008 }
21009 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21010 result = (int) ((arg1)->m_y);
21011 resultobj = SWIG_From_int(static_cast< int >(result));
21012 return resultobj;
21013 fail:
21014 return NULL;
21015 }
21016
21017
21018 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21019 PyObject *resultobj = 0;
21020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21021 bool arg2 ;
21022 void *argp1 = 0 ;
21023 int res1 = 0 ;
21024 bool val2 ;
21025 int ecode2 = 0 ;
21026 PyObject *swig_obj[2] ;
21027
21028 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21030 if (!SWIG_IsOK(res1)) {
21031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21032 }
21033 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21034 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21035 if (!SWIG_IsOK(ecode2)) {
21036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21037 }
21038 arg2 = static_cast< bool >(val2);
21039 if (arg1) (arg1)->m_leftDown = arg2;
21040
21041 resultobj = SWIG_Py_Void();
21042 return resultobj;
21043 fail:
21044 return NULL;
21045 }
21046
21047
21048 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21049 PyObject *resultobj = 0;
21050 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21051 bool result;
21052 void *argp1 = 0 ;
21053 int res1 = 0 ;
21054 PyObject *swig_obj[1] ;
21055
21056 if (!args) SWIG_fail;
21057 swig_obj[0] = args;
21058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21059 if (!SWIG_IsOK(res1)) {
21060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21061 }
21062 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21063 result = (bool) ((arg1)->m_leftDown);
21064 {
21065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21066 }
21067 return resultobj;
21068 fail:
21069 return NULL;
21070 }
21071
21072
21073 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21074 PyObject *resultobj = 0;
21075 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21076 bool arg2 ;
21077 void *argp1 = 0 ;
21078 int res1 = 0 ;
21079 bool val2 ;
21080 int ecode2 = 0 ;
21081 PyObject *swig_obj[2] ;
21082
21083 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21085 if (!SWIG_IsOK(res1)) {
21086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21087 }
21088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21089 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21090 if (!SWIG_IsOK(ecode2)) {
21091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21092 }
21093 arg2 = static_cast< bool >(val2);
21094 if (arg1) (arg1)->m_middleDown = arg2;
21095
21096 resultobj = SWIG_Py_Void();
21097 return resultobj;
21098 fail:
21099 return NULL;
21100 }
21101
21102
21103 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21104 PyObject *resultobj = 0;
21105 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21106 bool result;
21107 void *argp1 = 0 ;
21108 int res1 = 0 ;
21109 PyObject *swig_obj[1] ;
21110
21111 if (!args) SWIG_fail;
21112 swig_obj[0] = args;
21113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21116 }
21117 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21118 result = (bool) ((arg1)->m_middleDown);
21119 {
21120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21121 }
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21129 PyObject *resultobj = 0;
21130 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21131 bool arg2 ;
21132 void *argp1 = 0 ;
21133 int res1 = 0 ;
21134 bool val2 ;
21135 int ecode2 = 0 ;
21136 PyObject *swig_obj[2] ;
21137
21138 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21140 if (!SWIG_IsOK(res1)) {
21141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21142 }
21143 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21144 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21145 if (!SWIG_IsOK(ecode2)) {
21146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21147 }
21148 arg2 = static_cast< bool >(val2);
21149 if (arg1) (arg1)->m_rightDown = arg2;
21150
21151 resultobj = SWIG_Py_Void();
21152 return resultobj;
21153 fail:
21154 return NULL;
21155 }
21156
21157
21158 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21159 PyObject *resultobj = 0;
21160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21161 bool result;
21162 void *argp1 = 0 ;
21163 int res1 = 0 ;
21164 PyObject *swig_obj[1] ;
21165
21166 if (!args) SWIG_fail;
21167 swig_obj[0] = args;
21168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21169 if (!SWIG_IsOK(res1)) {
21170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21171 }
21172 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21173 result = (bool) ((arg1)->m_rightDown);
21174 {
21175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21176 }
21177 return resultobj;
21178 fail:
21179 return NULL;
21180 }
21181
21182
21183 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21184 PyObject *resultobj = 0;
21185 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21186 bool arg2 ;
21187 void *argp1 = 0 ;
21188 int res1 = 0 ;
21189 bool val2 ;
21190 int ecode2 = 0 ;
21191 PyObject *swig_obj[2] ;
21192
21193 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21195 if (!SWIG_IsOK(res1)) {
21196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21197 }
21198 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21199 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21200 if (!SWIG_IsOK(ecode2)) {
21201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21202 }
21203 arg2 = static_cast< bool >(val2);
21204 if (arg1) (arg1)->m_controlDown = arg2;
21205
21206 resultobj = SWIG_Py_Void();
21207 return resultobj;
21208 fail:
21209 return NULL;
21210 }
21211
21212
21213 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21214 PyObject *resultobj = 0;
21215 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21216 bool result;
21217 void *argp1 = 0 ;
21218 int res1 = 0 ;
21219 PyObject *swig_obj[1] ;
21220
21221 if (!args) SWIG_fail;
21222 swig_obj[0] = args;
21223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21226 }
21227 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21228 result = (bool) ((arg1)->m_controlDown);
21229 {
21230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21231 }
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21239 PyObject *resultobj = 0;
21240 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21241 bool arg2 ;
21242 void *argp1 = 0 ;
21243 int res1 = 0 ;
21244 bool val2 ;
21245 int ecode2 = 0 ;
21246 PyObject *swig_obj[2] ;
21247
21248 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21250 if (!SWIG_IsOK(res1)) {
21251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21252 }
21253 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21254 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21255 if (!SWIG_IsOK(ecode2)) {
21256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21257 }
21258 arg2 = static_cast< bool >(val2);
21259 if (arg1) (arg1)->m_shiftDown = arg2;
21260
21261 resultobj = SWIG_Py_Void();
21262 return resultobj;
21263 fail:
21264 return NULL;
21265 }
21266
21267
21268 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21269 PyObject *resultobj = 0;
21270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21271 bool result;
21272 void *argp1 = 0 ;
21273 int res1 = 0 ;
21274 PyObject *swig_obj[1] ;
21275
21276 if (!args) SWIG_fail;
21277 swig_obj[0] = args;
21278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21279 if (!SWIG_IsOK(res1)) {
21280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21281 }
21282 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21283 result = (bool) ((arg1)->m_shiftDown);
21284 {
21285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21286 }
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21294 PyObject *resultobj = 0;
21295 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21296 bool arg2 ;
21297 void *argp1 = 0 ;
21298 int res1 = 0 ;
21299 bool val2 ;
21300 int ecode2 = 0 ;
21301 PyObject *swig_obj[2] ;
21302
21303 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21305 if (!SWIG_IsOK(res1)) {
21306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21307 }
21308 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21309 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21310 if (!SWIG_IsOK(ecode2)) {
21311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21312 }
21313 arg2 = static_cast< bool >(val2);
21314 if (arg1) (arg1)->m_altDown = arg2;
21315
21316 resultobj = SWIG_Py_Void();
21317 return resultobj;
21318 fail:
21319 return NULL;
21320 }
21321
21322
21323 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21324 PyObject *resultobj = 0;
21325 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21326 bool result;
21327 void *argp1 = 0 ;
21328 int res1 = 0 ;
21329 PyObject *swig_obj[1] ;
21330
21331 if (!args) SWIG_fail;
21332 swig_obj[0] = args;
21333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21334 if (!SWIG_IsOK(res1)) {
21335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21336 }
21337 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21338 result = (bool) ((arg1)->m_altDown);
21339 {
21340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21341 }
21342 return resultobj;
21343 fail:
21344 return NULL;
21345 }
21346
21347
21348 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21349 PyObject *resultobj = 0;
21350 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21351 bool arg2 ;
21352 void *argp1 = 0 ;
21353 int res1 = 0 ;
21354 bool val2 ;
21355 int ecode2 = 0 ;
21356 PyObject *swig_obj[2] ;
21357
21358 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
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_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21362 }
21363 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21364 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21365 if (!SWIG_IsOK(ecode2)) {
21366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21367 }
21368 arg2 = static_cast< bool >(val2);
21369 if (arg1) (arg1)->m_metaDown = arg2;
21370
21371 resultobj = SWIG_Py_Void();
21372 return resultobj;
21373 fail:
21374 return NULL;
21375 }
21376
21377
21378 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21379 PyObject *resultobj = 0;
21380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21381 bool result;
21382 void *argp1 = 0 ;
21383 int res1 = 0 ;
21384 PyObject *swig_obj[1] ;
21385
21386 if (!args) SWIG_fail;
21387 swig_obj[0] = args;
21388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21389 if (!SWIG_IsOK(res1)) {
21390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21391 }
21392 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21393 result = (bool) ((arg1)->m_metaDown);
21394 {
21395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21396 }
21397 return resultobj;
21398 fail:
21399 return NULL;
21400 }
21401
21402
21403 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21404 PyObject *resultobj = 0;
21405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21406 int arg2 ;
21407 void *argp1 = 0 ;
21408 int res1 = 0 ;
21409 int val2 ;
21410 int ecode2 = 0 ;
21411 PyObject *swig_obj[2] ;
21412
21413 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
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_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21417 }
21418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21419 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21420 if (!SWIG_IsOK(ecode2)) {
21421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21422 }
21423 arg2 = static_cast< int >(val2);
21424 if (arg1) (arg1)->m_wheelRotation = arg2;
21425
21426 resultobj = SWIG_Py_Void();
21427 return resultobj;
21428 fail:
21429 return NULL;
21430 }
21431
21432
21433 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21434 PyObject *resultobj = 0;
21435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21436 int result;
21437 void *argp1 = 0 ;
21438 int res1 = 0 ;
21439 PyObject *swig_obj[1] ;
21440
21441 if (!args) SWIG_fail;
21442 swig_obj[0] = args;
21443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21444 if (!SWIG_IsOK(res1)) {
21445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21446 }
21447 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21448 result = (int) ((arg1)->m_wheelRotation);
21449 resultobj = SWIG_From_int(static_cast< int >(result));
21450 return resultobj;
21451 fail:
21452 return NULL;
21453 }
21454
21455
21456 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21457 PyObject *resultobj = 0;
21458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21459 int arg2 ;
21460 void *argp1 = 0 ;
21461 int res1 = 0 ;
21462 int val2 ;
21463 int ecode2 = 0 ;
21464 PyObject *swig_obj[2] ;
21465
21466 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21468 if (!SWIG_IsOK(res1)) {
21469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21470 }
21471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21472 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21473 if (!SWIG_IsOK(ecode2)) {
21474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21475 }
21476 arg2 = static_cast< int >(val2);
21477 if (arg1) (arg1)->m_wheelDelta = arg2;
21478
21479 resultobj = SWIG_Py_Void();
21480 return resultobj;
21481 fail:
21482 return NULL;
21483 }
21484
21485
21486 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21487 PyObject *resultobj = 0;
21488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21489 int result;
21490 void *argp1 = 0 ;
21491 int res1 = 0 ;
21492 PyObject *swig_obj[1] ;
21493
21494 if (!args) SWIG_fail;
21495 swig_obj[0] = args;
21496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21497 if (!SWIG_IsOK(res1)) {
21498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21499 }
21500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21501 result = (int) ((arg1)->m_wheelDelta);
21502 resultobj = SWIG_From_int(static_cast< int >(result));
21503 return resultobj;
21504 fail:
21505 return NULL;
21506 }
21507
21508
21509 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21510 PyObject *resultobj = 0;
21511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21512 int arg2 ;
21513 void *argp1 = 0 ;
21514 int res1 = 0 ;
21515 int val2 ;
21516 int ecode2 = 0 ;
21517 PyObject *swig_obj[2] ;
21518
21519 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21521 if (!SWIG_IsOK(res1)) {
21522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21523 }
21524 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21525 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21526 if (!SWIG_IsOK(ecode2)) {
21527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21528 }
21529 arg2 = static_cast< int >(val2);
21530 if (arg1) (arg1)->m_linesPerAction = arg2;
21531
21532 resultobj = SWIG_Py_Void();
21533 return resultobj;
21534 fail:
21535 return NULL;
21536 }
21537
21538
21539 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21540 PyObject *resultobj = 0;
21541 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21542 int result;
21543 void *argp1 = 0 ;
21544 int res1 = 0 ;
21545 PyObject *swig_obj[1] ;
21546
21547 if (!args) SWIG_fail;
21548 swig_obj[0] = args;
21549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21550 if (!SWIG_IsOK(res1)) {
21551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21552 }
21553 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21554 result = (int) ((arg1)->m_linesPerAction);
21555 resultobj = SWIG_From_int(static_cast< int >(result));
21556 return resultobj;
21557 fail:
21558 return NULL;
21559 }
21560
21561
21562 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21563 PyObject *obj;
21564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21565 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21566 return SWIG_Py_Void();
21567 }
21568
21569 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21570 return SWIG_Python_InitShadowInstance(args);
21571 }
21572
21573 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21574 PyObject *resultobj = 0;
21575 int arg1 = (int) 0 ;
21576 int arg2 = (int) 0 ;
21577 wxSetCursorEvent *result = 0 ;
21578 int val1 ;
21579 int ecode1 = 0 ;
21580 int val2 ;
21581 int ecode2 = 0 ;
21582 PyObject * obj0 = 0 ;
21583 PyObject * obj1 = 0 ;
21584 char * kwnames[] = {
21585 (char *) "x",(char *) "y", NULL
21586 };
21587
21588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21589 if (obj0) {
21590 ecode1 = SWIG_AsVal_int(obj0, &val1);
21591 if (!SWIG_IsOK(ecode1)) {
21592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21593 }
21594 arg1 = static_cast< int >(val1);
21595 }
21596 if (obj1) {
21597 ecode2 = SWIG_AsVal_int(obj1, &val2);
21598 if (!SWIG_IsOK(ecode2)) {
21599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21600 }
21601 arg2 = static_cast< int >(val2);
21602 }
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21617 PyObject *resultobj = 0;
21618 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21619 int result;
21620 void *argp1 = 0 ;
21621 int res1 = 0 ;
21622 PyObject *swig_obj[1] ;
21623
21624 if (!args) SWIG_fail;
21625 swig_obj[0] = args;
21626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21627 if (!SWIG_IsOK(res1)) {
21628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21629 }
21630 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21631 {
21632 PyThreadState* __tstate = wxPyBeginAllowThreads();
21633 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 resultobj = SWIG_From_int(static_cast< int >(result));
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21645 PyObject *resultobj = 0;
21646 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21647 int result;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 PyObject *swig_obj[1] ;
21651
21652 if (!args) SWIG_fail;
21653 swig_obj[0] = args;
21654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21655 if (!SWIG_IsOK(res1)) {
21656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21657 }
21658 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21659 {
21660 PyThreadState* __tstate = wxPyBeginAllowThreads();
21661 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21662 wxPyEndAllowThreads(__tstate);
21663 if (PyErr_Occurred()) SWIG_fail;
21664 }
21665 resultobj = SWIG_From_int(static_cast< int >(result));
21666 return resultobj;
21667 fail:
21668 return NULL;
21669 }
21670
21671
21672 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21673 PyObject *resultobj = 0;
21674 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21675 wxCursor *arg2 = 0 ;
21676 void *argp1 = 0 ;
21677 int res1 = 0 ;
21678 void *argp2 = 0 ;
21679 int res2 = 0 ;
21680 PyObject * obj0 = 0 ;
21681 PyObject * obj1 = 0 ;
21682 char * kwnames[] = {
21683 (char *) "self",(char *) "cursor", NULL
21684 };
21685
21686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21688 if (!SWIG_IsOK(res1)) {
21689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21690 }
21691 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21692 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21693 if (!SWIG_IsOK(res2)) {
21694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21695 }
21696 if (!argp2) {
21697 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21698 }
21699 arg2 = reinterpret_cast< wxCursor * >(argp2);
21700 {
21701 PyThreadState* __tstate = wxPyBeginAllowThreads();
21702 (arg1)->SetCursor((wxCursor const &)*arg2);
21703 wxPyEndAllowThreads(__tstate);
21704 if (PyErr_Occurred()) SWIG_fail;
21705 }
21706 resultobj = SWIG_Py_Void();
21707 return resultobj;
21708 fail:
21709 return NULL;
21710 }
21711
21712
21713 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21714 PyObject *resultobj = 0;
21715 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21716 wxCursor *result = 0 ;
21717 void *argp1 = 0 ;
21718 int res1 = 0 ;
21719 PyObject *swig_obj[1] ;
21720
21721 if (!args) SWIG_fail;
21722 swig_obj[0] = args;
21723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21724 if (!SWIG_IsOK(res1)) {
21725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21726 }
21727 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 {
21731 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21732 result = (wxCursor *) &_result_ref;
21733 }
21734 wxPyEndAllowThreads(__tstate);
21735 if (PyErr_Occurred()) SWIG_fail;
21736 }
21737 {
21738 wxCursor* resultptr = new wxCursor(*result);
21739 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21740 }
21741 return resultobj;
21742 fail:
21743 return NULL;
21744 }
21745
21746
21747 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21748 PyObject *resultobj = 0;
21749 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21750 bool result;
21751 void *argp1 = 0 ;
21752 int res1 = 0 ;
21753 PyObject *swig_obj[1] ;
21754
21755 if (!args) SWIG_fail;
21756 swig_obj[0] = args;
21757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21758 if (!SWIG_IsOK(res1)) {
21759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21760 }
21761 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21762 {
21763 PyThreadState* __tstate = wxPyBeginAllowThreads();
21764 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21765 wxPyEndAllowThreads(__tstate);
21766 if (PyErr_Occurred()) SWIG_fail;
21767 }
21768 {
21769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21770 }
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21778 PyObject *obj;
21779 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21780 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21781 return SWIG_Py_Void();
21782 }
21783
21784 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21785 return SWIG_Python_InitShadowInstance(args);
21786 }
21787
21788 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21789 PyObject *resultobj = 0;
21790 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21791 wxKeyEvent *result = 0 ;
21792 int val1 ;
21793 int ecode1 = 0 ;
21794 PyObject * obj0 = 0 ;
21795 char * kwnames[] = {
21796 (char *) "eventType", NULL
21797 };
21798
21799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21800 if (obj0) {
21801 ecode1 = SWIG_AsVal_int(obj0, &val1);
21802 if (!SWIG_IsOK(ecode1)) {
21803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21804 }
21805 arg1 = static_cast< wxEventType >(val1);
21806 }
21807 {
21808 PyThreadState* __tstate = wxPyBeginAllowThreads();
21809 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21810 wxPyEndAllowThreads(__tstate);
21811 if (PyErr_Occurred()) SWIG_fail;
21812 }
21813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21814 return resultobj;
21815 fail:
21816 return NULL;
21817 }
21818
21819
21820 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21821 PyObject *resultobj = 0;
21822 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21823 int result;
21824 void *argp1 = 0 ;
21825 int res1 = 0 ;
21826 PyObject *swig_obj[1] ;
21827
21828 if (!args) SWIG_fail;
21829 swig_obj[0] = args;
21830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21831 if (!SWIG_IsOK(res1)) {
21832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21833 }
21834 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21835 {
21836 PyThreadState* __tstate = wxPyBeginAllowThreads();
21837 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21838 wxPyEndAllowThreads(__tstate);
21839 if (PyErr_Occurred()) SWIG_fail;
21840 }
21841 resultobj = SWIG_From_int(static_cast< int >(result));
21842 return resultobj;
21843 fail:
21844 return NULL;
21845 }
21846
21847
21848 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21849 PyObject *resultobj = 0;
21850 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21851 bool result;
21852 void *argp1 = 0 ;
21853 int res1 = 0 ;
21854 PyObject *swig_obj[1] ;
21855
21856 if (!args) SWIG_fail;
21857 swig_obj[0] = args;
21858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21859 if (!SWIG_IsOK(res1)) {
21860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21861 }
21862 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21863 {
21864 PyThreadState* __tstate = wxPyBeginAllowThreads();
21865 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21866 wxPyEndAllowThreads(__tstate);
21867 if (PyErr_Occurred()) SWIG_fail;
21868 }
21869 {
21870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21871 }
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21879 PyObject *resultobj = 0;
21880 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21881 bool result;
21882 void *argp1 = 0 ;
21883 int res1 = 0 ;
21884 PyObject *swig_obj[1] ;
21885
21886 if (!args) SWIG_fail;
21887 swig_obj[0] = args;
21888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21889 if (!SWIG_IsOK(res1)) {
21890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21891 }
21892 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21893 {
21894 PyThreadState* __tstate = wxPyBeginAllowThreads();
21895 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21896 wxPyEndAllowThreads(__tstate);
21897 if (PyErr_Occurred()) SWIG_fail;
21898 }
21899 {
21900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21901 }
21902 return resultobj;
21903 fail:
21904 return NULL;
21905 }
21906
21907
21908 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21909 PyObject *resultobj = 0;
21910 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21911 bool result;
21912 void *argp1 = 0 ;
21913 int res1 = 0 ;
21914 PyObject *swig_obj[1] ;
21915
21916 if (!args) SWIG_fail;
21917 swig_obj[0] = args;
21918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21919 if (!SWIG_IsOK(res1)) {
21920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21921 }
21922 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21923 {
21924 PyThreadState* __tstate = wxPyBeginAllowThreads();
21925 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21926 wxPyEndAllowThreads(__tstate);
21927 if (PyErr_Occurred()) SWIG_fail;
21928 }
21929 {
21930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21931 }
21932 return resultobj;
21933 fail:
21934 return NULL;
21935 }
21936
21937
21938 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21939 PyObject *resultobj = 0;
21940 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21941 bool result;
21942 void *argp1 = 0 ;
21943 int res1 = 0 ;
21944 PyObject *swig_obj[1] ;
21945
21946 if (!args) SWIG_fail;
21947 swig_obj[0] = args;
21948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21949 if (!SWIG_IsOK(res1)) {
21950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21951 }
21952 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21953 {
21954 PyThreadState* __tstate = wxPyBeginAllowThreads();
21955 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
21956 wxPyEndAllowThreads(__tstate);
21957 if (PyErr_Occurred()) SWIG_fail;
21958 }
21959 {
21960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21961 }
21962 return resultobj;
21963 fail:
21964 return NULL;
21965 }
21966
21967
21968 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21969 PyObject *resultobj = 0;
21970 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21971 bool result;
21972 void *argp1 = 0 ;
21973 int res1 = 0 ;
21974 PyObject *swig_obj[1] ;
21975
21976 if (!args) SWIG_fail;
21977 swig_obj[0] = args;
21978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21979 if (!SWIG_IsOK(res1)) {
21980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21981 }
21982 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21983 {
21984 PyThreadState* __tstate = wxPyBeginAllowThreads();
21985 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
21986 wxPyEndAllowThreads(__tstate);
21987 if (PyErr_Occurred()) SWIG_fail;
21988 }
21989 {
21990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21991 }
21992 return resultobj;
21993 fail:
21994 return NULL;
21995 }
21996
21997
21998 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21999 PyObject *resultobj = 0;
22000 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22001 bool result;
22002 void *argp1 = 0 ;
22003 int res1 = 0 ;
22004 PyObject *swig_obj[1] ;
22005
22006 if (!args) SWIG_fail;
22007 swig_obj[0] = args;
22008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22009 if (!SWIG_IsOK(res1)) {
22010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22011 }
22012 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22013 {
22014 PyThreadState* __tstate = wxPyBeginAllowThreads();
22015 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22016 wxPyEndAllowThreads(__tstate);
22017 if (PyErr_Occurred()) SWIG_fail;
22018 }
22019 {
22020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22021 }
22022 return resultobj;
22023 fail:
22024 return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22029 PyObject *resultobj = 0;
22030 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22031 int result;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 PyObject *swig_obj[1] ;
22035
22036 if (!args) SWIG_fail;
22037 swig_obj[0] = args;
22038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22039 if (!SWIG_IsOK(res1)) {
22040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22041 }
22042 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22043 {
22044 PyThreadState* __tstate = wxPyBeginAllowThreads();
22045 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 resultobj = SWIG_From_int(static_cast< int >(result));
22050 return resultobj;
22051 fail:
22052 return NULL;
22053 }
22054
22055
22056 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22057 PyObject *resultobj = 0;
22058 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22059 int result;
22060 void *argp1 = 0 ;
22061 int res1 = 0 ;
22062 PyObject *swig_obj[1] ;
22063
22064 if (!args) SWIG_fail;
22065 swig_obj[0] = args;
22066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22067 if (!SWIG_IsOK(res1)) {
22068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22069 }
22070 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22071 {
22072 PyThreadState* __tstate = wxPyBeginAllowThreads();
22073 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22074 wxPyEndAllowThreads(__tstate);
22075 if (PyErr_Occurred()) SWIG_fail;
22076 }
22077 resultobj = SWIG_From_int(static_cast< int >(result));
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22085 PyObject *resultobj = 0;
22086 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22087 unsigned int result;
22088 void *argp1 = 0 ;
22089 int res1 = 0 ;
22090 PyObject *swig_obj[1] ;
22091
22092 if (!args) SWIG_fail;
22093 swig_obj[0] = args;
22094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22095 if (!SWIG_IsOK(res1)) {
22096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22097 }
22098 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22106 return resultobj;
22107 fail:
22108 return NULL;
22109 }
22110
22111
22112 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22113 PyObject *resultobj = 0;
22114 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22115 unsigned int result;
22116 void *argp1 = 0 ;
22117 int res1 = 0 ;
22118 PyObject *swig_obj[1] ;
22119
22120 if (!args) SWIG_fail;
22121 swig_obj[0] = args;
22122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22123 if (!SWIG_IsOK(res1)) {
22124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22125 }
22126 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22127 {
22128 PyThreadState* __tstate = wxPyBeginAllowThreads();
22129 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22130 wxPyEndAllowThreads(__tstate);
22131 if (PyErr_Occurred()) SWIG_fail;
22132 }
22133 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22134 return resultobj;
22135 fail:
22136 return NULL;
22137 }
22138
22139
22140 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22141 PyObject *resultobj = 0;
22142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22143 wxPoint result;
22144 void *argp1 = 0 ;
22145 int res1 = 0 ;
22146 PyObject *swig_obj[1] ;
22147
22148 if (!args) SWIG_fail;
22149 swig_obj[0] = args;
22150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22151 if (!SWIG_IsOK(res1)) {
22152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22153 }
22154 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22155 {
22156 PyThreadState* __tstate = wxPyBeginAllowThreads();
22157 result = (arg1)->GetPosition();
22158 wxPyEndAllowThreads(__tstate);
22159 if (PyErr_Occurred()) SWIG_fail;
22160 }
22161 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22162 return resultobj;
22163 fail:
22164 return NULL;
22165 }
22166
22167
22168 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22169 PyObject *resultobj = 0;
22170 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22171 long *arg2 = (long *) 0 ;
22172 long *arg3 = (long *) 0 ;
22173 void *argp1 = 0 ;
22174 int res1 = 0 ;
22175 long temp2 ;
22176 int res2 = SWIG_TMPOBJ ;
22177 long temp3 ;
22178 int res3 = SWIG_TMPOBJ ;
22179 PyObject *swig_obj[1] ;
22180
22181 arg2 = &temp2;
22182 arg3 = &temp3;
22183 if (!args) SWIG_fail;
22184 swig_obj[0] = args;
22185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22186 if (!SWIG_IsOK(res1)) {
22187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22188 }
22189 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 (arg1)->GetPosition(arg2,arg3);
22193 wxPyEndAllowThreads(__tstate);
22194 if (PyErr_Occurred()) SWIG_fail;
22195 }
22196 resultobj = SWIG_Py_Void();
22197 if (SWIG_IsTmpObj(res2)) {
22198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22199 } else {
22200 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22202 }
22203 if (SWIG_IsTmpObj(res3)) {
22204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22205 } else {
22206 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22208 }
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22216 PyObject *resultobj = 0;
22217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22218 int result;
22219 void *argp1 = 0 ;
22220 int res1 = 0 ;
22221 PyObject *swig_obj[1] ;
22222
22223 if (!args) SWIG_fail;
22224 swig_obj[0] = args;
22225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22226 if (!SWIG_IsOK(res1)) {
22227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22228 }
22229 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 result = (int)((wxKeyEvent const *)arg1)->GetX();
22233 wxPyEndAllowThreads(__tstate);
22234 if (PyErr_Occurred()) SWIG_fail;
22235 }
22236 resultobj = SWIG_From_int(static_cast< int >(result));
22237 return resultobj;
22238 fail:
22239 return NULL;
22240 }
22241
22242
22243 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22244 PyObject *resultobj = 0;
22245 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22246 int result;
22247 void *argp1 = 0 ;
22248 int res1 = 0 ;
22249 PyObject *swig_obj[1] ;
22250
22251 if (!args) SWIG_fail;
22252 swig_obj[0] = args;
22253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22254 if (!SWIG_IsOK(res1)) {
22255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22256 }
22257 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22258 {
22259 PyThreadState* __tstate = wxPyBeginAllowThreads();
22260 result = (int)((wxKeyEvent const *)arg1)->GetY();
22261 wxPyEndAllowThreads(__tstate);
22262 if (PyErr_Occurred()) SWIG_fail;
22263 }
22264 resultobj = SWIG_From_int(static_cast< int >(result));
22265 return resultobj;
22266 fail:
22267 return NULL;
22268 }
22269
22270
22271 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22272 PyObject *resultobj = 0;
22273 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22274 int arg2 ;
22275 void *argp1 = 0 ;
22276 int res1 = 0 ;
22277 int val2 ;
22278 int ecode2 = 0 ;
22279 PyObject *swig_obj[2] ;
22280
22281 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22283 if (!SWIG_IsOK(res1)) {
22284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22285 }
22286 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22287 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22288 if (!SWIG_IsOK(ecode2)) {
22289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22290 }
22291 arg2 = static_cast< int >(val2);
22292 if (arg1) (arg1)->m_x = arg2;
22293
22294 resultobj = SWIG_Py_Void();
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22302 PyObject *resultobj = 0;
22303 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22304 int result;
22305 void *argp1 = 0 ;
22306 int res1 = 0 ;
22307 PyObject *swig_obj[1] ;
22308
22309 if (!args) SWIG_fail;
22310 swig_obj[0] = args;
22311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22312 if (!SWIG_IsOK(res1)) {
22313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22314 }
22315 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22316 result = (int) ((arg1)->m_x);
22317 resultobj = SWIG_From_int(static_cast< int >(result));
22318 return resultobj;
22319 fail:
22320 return NULL;
22321 }
22322
22323
22324 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22325 PyObject *resultobj = 0;
22326 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22327 int arg2 ;
22328 void *argp1 = 0 ;
22329 int res1 = 0 ;
22330 int val2 ;
22331 int ecode2 = 0 ;
22332 PyObject *swig_obj[2] ;
22333
22334 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22336 if (!SWIG_IsOK(res1)) {
22337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22338 }
22339 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22340 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22341 if (!SWIG_IsOK(ecode2)) {
22342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22343 }
22344 arg2 = static_cast< int >(val2);
22345 if (arg1) (arg1)->m_y = arg2;
22346
22347 resultobj = SWIG_Py_Void();
22348 return resultobj;
22349 fail:
22350 return NULL;
22351 }
22352
22353
22354 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22355 PyObject *resultobj = 0;
22356 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22357 int result;
22358 void *argp1 = 0 ;
22359 int res1 = 0 ;
22360 PyObject *swig_obj[1] ;
22361
22362 if (!args) SWIG_fail;
22363 swig_obj[0] = args;
22364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22365 if (!SWIG_IsOK(res1)) {
22366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22367 }
22368 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22369 result = (int) ((arg1)->m_y);
22370 resultobj = SWIG_From_int(static_cast< int >(result));
22371 return resultobj;
22372 fail:
22373 return NULL;
22374 }
22375
22376
22377 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22378 PyObject *resultobj = 0;
22379 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22380 long arg2 ;
22381 void *argp1 = 0 ;
22382 int res1 = 0 ;
22383 long val2 ;
22384 int ecode2 = 0 ;
22385 PyObject *swig_obj[2] ;
22386
22387 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22389 if (!SWIG_IsOK(res1)) {
22390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22391 }
22392 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22393 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22394 if (!SWIG_IsOK(ecode2)) {
22395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22396 }
22397 arg2 = static_cast< long >(val2);
22398 if (arg1) (arg1)->m_keyCode = arg2;
22399
22400 resultobj = SWIG_Py_Void();
22401 return resultobj;
22402 fail:
22403 return NULL;
22404 }
22405
22406
22407 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22408 PyObject *resultobj = 0;
22409 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22410 long result;
22411 void *argp1 = 0 ;
22412 int res1 = 0 ;
22413 PyObject *swig_obj[1] ;
22414
22415 if (!args) SWIG_fail;
22416 swig_obj[0] = args;
22417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22418 if (!SWIG_IsOK(res1)) {
22419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22420 }
22421 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22422 result = (long) ((arg1)->m_keyCode);
22423 resultobj = SWIG_From_long(static_cast< long >(result));
22424 return resultobj;
22425 fail:
22426 return NULL;
22427 }
22428
22429
22430 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22431 PyObject *resultobj = 0;
22432 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22433 bool arg2 ;
22434 void *argp1 = 0 ;
22435 int res1 = 0 ;
22436 bool val2 ;
22437 int ecode2 = 0 ;
22438 PyObject *swig_obj[2] ;
22439
22440 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22442 if (!SWIG_IsOK(res1)) {
22443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22444 }
22445 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22446 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22447 if (!SWIG_IsOK(ecode2)) {
22448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22449 }
22450 arg2 = static_cast< bool >(val2);
22451 if (arg1) (arg1)->m_controlDown = arg2;
22452
22453 resultobj = SWIG_Py_Void();
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 PyObject *resultobj = 0;
22462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22463 bool result;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 PyObject *swig_obj[1] ;
22467
22468 if (!args) SWIG_fail;
22469 swig_obj[0] = args;
22470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22471 if (!SWIG_IsOK(res1)) {
22472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22473 }
22474 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22475 result = (bool) ((arg1)->m_controlDown);
22476 {
22477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22478 }
22479 return resultobj;
22480 fail:
22481 return NULL;
22482 }
22483
22484
22485 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22486 PyObject *resultobj = 0;
22487 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22488 bool arg2 ;
22489 void *argp1 = 0 ;
22490 int res1 = 0 ;
22491 bool val2 ;
22492 int ecode2 = 0 ;
22493 PyObject *swig_obj[2] ;
22494
22495 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22497 if (!SWIG_IsOK(res1)) {
22498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22499 }
22500 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22501 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22502 if (!SWIG_IsOK(ecode2)) {
22503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22504 }
22505 arg2 = static_cast< bool >(val2);
22506 if (arg1) (arg1)->m_shiftDown = arg2;
22507
22508 resultobj = SWIG_Py_Void();
22509 return resultobj;
22510 fail:
22511 return NULL;
22512 }
22513
22514
22515 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22516 PyObject *resultobj = 0;
22517 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22518 bool result;
22519 void *argp1 = 0 ;
22520 int res1 = 0 ;
22521 PyObject *swig_obj[1] ;
22522
22523 if (!args) SWIG_fail;
22524 swig_obj[0] = args;
22525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22526 if (!SWIG_IsOK(res1)) {
22527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22528 }
22529 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22530 result = (bool) ((arg1)->m_shiftDown);
22531 {
22532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22533 }
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22541 PyObject *resultobj = 0;
22542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22543 bool arg2 ;
22544 void *argp1 = 0 ;
22545 int res1 = 0 ;
22546 bool val2 ;
22547 int ecode2 = 0 ;
22548 PyObject *swig_obj[2] ;
22549
22550 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22552 if (!SWIG_IsOK(res1)) {
22553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22554 }
22555 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22556 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22557 if (!SWIG_IsOK(ecode2)) {
22558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22559 }
22560 arg2 = static_cast< bool >(val2);
22561 if (arg1) (arg1)->m_altDown = arg2;
22562
22563 resultobj = SWIG_Py_Void();
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22571 PyObject *resultobj = 0;
22572 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22573 bool result;
22574 void *argp1 = 0 ;
22575 int res1 = 0 ;
22576 PyObject *swig_obj[1] ;
22577
22578 if (!args) SWIG_fail;
22579 swig_obj[0] = args;
22580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22581 if (!SWIG_IsOK(res1)) {
22582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22583 }
22584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22585 result = (bool) ((arg1)->m_altDown);
22586 {
22587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22588 }
22589 return resultobj;
22590 fail:
22591 return NULL;
22592 }
22593
22594
22595 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22596 PyObject *resultobj = 0;
22597 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22598 bool arg2 ;
22599 void *argp1 = 0 ;
22600 int res1 = 0 ;
22601 bool val2 ;
22602 int ecode2 = 0 ;
22603 PyObject *swig_obj[2] ;
22604
22605 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22607 if (!SWIG_IsOK(res1)) {
22608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22609 }
22610 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22611 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22612 if (!SWIG_IsOK(ecode2)) {
22613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22614 }
22615 arg2 = static_cast< bool >(val2);
22616 if (arg1) (arg1)->m_metaDown = arg2;
22617
22618 resultobj = SWIG_Py_Void();
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22626 PyObject *resultobj = 0;
22627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22628 bool result;
22629 void *argp1 = 0 ;
22630 int res1 = 0 ;
22631 PyObject *swig_obj[1] ;
22632
22633 if (!args) SWIG_fail;
22634 swig_obj[0] = args;
22635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22638 }
22639 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22640 result = (bool) ((arg1)->m_metaDown);
22641 {
22642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22643 }
22644 return resultobj;
22645 fail:
22646 return NULL;
22647 }
22648
22649
22650 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22651 PyObject *resultobj = 0;
22652 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22653 bool arg2 ;
22654 void *argp1 = 0 ;
22655 int res1 = 0 ;
22656 bool val2 ;
22657 int ecode2 = 0 ;
22658 PyObject *swig_obj[2] ;
22659
22660 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22662 if (!SWIG_IsOK(res1)) {
22663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22664 }
22665 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22666 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22667 if (!SWIG_IsOK(ecode2)) {
22668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22669 }
22670 arg2 = static_cast< bool >(val2);
22671 if (arg1) (arg1)->m_scanCode = arg2;
22672
22673 resultobj = SWIG_Py_Void();
22674 return resultobj;
22675 fail:
22676 return NULL;
22677 }
22678
22679
22680 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22681 PyObject *resultobj = 0;
22682 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22683 bool result;
22684 void *argp1 = 0 ;
22685 int res1 = 0 ;
22686 PyObject *swig_obj[1] ;
22687
22688 if (!args) SWIG_fail;
22689 swig_obj[0] = args;
22690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22691 if (!SWIG_IsOK(res1)) {
22692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22693 }
22694 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22695 result = (bool) ((arg1)->m_scanCode);
22696 {
22697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22698 }
22699 return resultobj;
22700 fail:
22701 return NULL;
22702 }
22703
22704
22705 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22706 PyObject *resultobj = 0;
22707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22708 unsigned int arg2 ;
22709 void *argp1 = 0 ;
22710 int res1 = 0 ;
22711 unsigned int val2 ;
22712 int ecode2 = 0 ;
22713 PyObject *swig_obj[2] ;
22714
22715 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22717 if (!SWIG_IsOK(res1)) {
22718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22719 }
22720 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22721 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22722 if (!SWIG_IsOK(ecode2)) {
22723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22724 }
22725 arg2 = static_cast< unsigned int >(val2);
22726 if (arg1) (arg1)->m_rawCode = arg2;
22727
22728 resultobj = SWIG_Py_Void();
22729 return resultobj;
22730 fail:
22731 return NULL;
22732 }
22733
22734
22735 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22736 PyObject *resultobj = 0;
22737 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22738 unsigned int result;
22739 void *argp1 = 0 ;
22740 int res1 = 0 ;
22741 PyObject *swig_obj[1] ;
22742
22743 if (!args) SWIG_fail;
22744 swig_obj[0] = args;
22745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22746 if (!SWIG_IsOK(res1)) {
22747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22748 }
22749 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22750 result = (unsigned int) ((arg1)->m_rawCode);
22751 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22759 PyObject *resultobj = 0;
22760 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22761 unsigned int arg2 ;
22762 void *argp1 = 0 ;
22763 int res1 = 0 ;
22764 unsigned int val2 ;
22765 int ecode2 = 0 ;
22766 PyObject *swig_obj[2] ;
22767
22768 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22770 if (!SWIG_IsOK(res1)) {
22771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22772 }
22773 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22774 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22775 if (!SWIG_IsOK(ecode2)) {
22776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22777 }
22778 arg2 = static_cast< unsigned int >(val2);
22779 if (arg1) (arg1)->m_rawFlags = arg2;
22780
22781 resultobj = SWIG_Py_Void();
22782 return resultobj;
22783 fail:
22784 return NULL;
22785 }
22786
22787
22788 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22789 PyObject *resultobj = 0;
22790 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22791 unsigned int result;
22792 void *argp1 = 0 ;
22793 int res1 = 0 ;
22794 PyObject *swig_obj[1] ;
22795
22796 if (!args) SWIG_fail;
22797 swig_obj[0] = args;
22798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22799 if (!SWIG_IsOK(res1)) {
22800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22801 }
22802 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22803 result = (unsigned int) ((arg1)->m_rawFlags);
22804 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22805 return resultobj;
22806 fail:
22807 return NULL;
22808 }
22809
22810
22811 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22812 PyObject *obj;
22813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22814 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22815 return SWIG_Py_Void();
22816 }
22817
22818 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22819 return SWIG_Python_InitShadowInstance(args);
22820 }
22821
22822 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22823 PyObject *resultobj = 0;
22824 wxSize const &arg1_defvalue = wxDefaultSize ;
22825 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22826 int arg2 = (int) 0 ;
22827 wxSizeEvent *result = 0 ;
22828 wxSize temp1 ;
22829 int val2 ;
22830 int ecode2 = 0 ;
22831 PyObject * obj0 = 0 ;
22832 PyObject * obj1 = 0 ;
22833 char * kwnames[] = {
22834 (char *) "sz",(char *) "winid", NULL
22835 };
22836
22837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22838 if (obj0) {
22839 {
22840 arg1 = &temp1;
22841 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22842 }
22843 }
22844 if (obj1) {
22845 ecode2 = SWIG_AsVal_int(obj1, &val2);
22846 if (!SWIG_IsOK(ecode2)) {
22847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22848 }
22849 arg2 = static_cast< int >(val2);
22850 }
22851 {
22852 PyThreadState* __tstate = wxPyBeginAllowThreads();
22853 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22858 return resultobj;
22859 fail:
22860 return NULL;
22861 }
22862
22863
22864 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22865 PyObject *resultobj = 0;
22866 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22867 wxSize result;
22868 void *argp1 = 0 ;
22869 int res1 = 0 ;
22870 PyObject *swig_obj[1] ;
22871
22872 if (!args) SWIG_fail;
22873 swig_obj[0] = args;
22874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22875 if (!SWIG_IsOK(res1)) {
22876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22877 }
22878 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22879 {
22880 PyThreadState* __tstate = wxPyBeginAllowThreads();
22881 result = ((wxSizeEvent const *)arg1)->GetSize();
22882 wxPyEndAllowThreads(__tstate);
22883 if (PyErr_Occurred()) SWIG_fail;
22884 }
22885 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22886 return resultobj;
22887 fail:
22888 return NULL;
22889 }
22890
22891
22892 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22893 PyObject *resultobj = 0;
22894 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22895 wxRect result;
22896 void *argp1 = 0 ;
22897 int res1 = 0 ;
22898 PyObject *swig_obj[1] ;
22899
22900 if (!args) SWIG_fail;
22901 swig_obj[0] = args;
22902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22903 if (!SWIG_IsOK(res1)) {
22904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22905 }
22906 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22907 {
22908 PyThreadState* __tstate = wxPyBeginAllowThreads();
22909 result = ((wxSizeEvent const *)arg1)->GetRect();
22910 wxPyEndAllowThreads(__tstate);
22911 if (PyErr_Occurred()) SWIG_fail;
22912 }
22913 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22914 return resultobj;
22915 fail:
22916 return NULL;
22917 }
22918
22919
22920 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22921 PyObject *resultobj = 0;
22922 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22923 wxRect arg2 ;
22924 void *argp1 = 0 ;
22925 int res1 = 0 ;
22926 void *argp2 ;
22927 int res2 = 0 ;
22928 PyObject * obj0 = 0 ;
22929 PyObject * obj1 = 0 ;
22930 char * kwnames[] = {
22931 (char *) "self",(char *) "rect", NULL
22932 };
22933
22934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22936 if (!SWIG_IsOK(res1)) {
22937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22938 }
22939 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22940 {
22941 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22942 if (!SWIG_IsOK(res2)) {
22943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22944 }
22945 if (!argp2) {
22946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22947 } else {
22948 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22949 arg2 = *temp;
22950 if (SWIG_IsNewObj(res2)) delete temp;
22951 }
22952 }
22953 {
22954 PyThreadState* __tstate = wxPyBeginAllowThreads();
22955 (arg1)->SetRect(arg2);
22956 wxPyEndAllowThreads(__tstate);
22957 if (PyErr_Occurred()) SWIG_fail;
22958 }
22959 resultobj = SWIG_Py_Void();
22960 return resultobj;
22961 fail:
22962 return NULL;
22963 }
22964
22965
22966 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22967 PyObject *resultobj = 0;
22968 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22969 wxSize arg2 ;
22970 void *argp1 = 0 ;
22971 int res1 = 0 ;
22972 void *argp2 ;
22973 int res2 = 0 ;
22974 PyObject * obj0 = 0 ;
22975 PyObject * obj1 = 0 ;
22976 char * kwnames[] = {
22977 (char *) "self",(char *) "size", NULL
22978 };
22979
22980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22982 if (!SWIG_IsOK(res1)) {
22983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22984 }
22985 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22986 {
22987 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
22988 if (!SWIG_IsOK(res2)) {
22989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22990 }
22991 if (!argp2) {
22992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22993 } else {
22994 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
22995 arg2 = *temp;
22996 if (SWIG_IsNewObj(res2)) delete temp;
22997 }
22998 }
22999 {
23000 PyThreadState* __tstate = wxPyBeginAllowThreads();
23001 wxSizeEvent_SetSize(arg1,arg2);
23002 wxPyEndAllowThreads(__tstate);
23003 if (PyErr_Occurred()) SWIG_fail;
23004 }
23005 resultobj = SWIG_Py_Void();
23006 return resultobj;
23007 fail:
23008 return NULL;
23009 }
23010
23011
23012 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23013 PyObject *resultobj = 0;
23014 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23015 wxSize *arg2 = (wxSize *) 0 ;
23016 void *argp1 = 0 ;
23017 int res1 = 0 ;
23018 void *argp2 = 0 ;
23019 int res2 = 0 ;
23020 PyObject *swig_obj[2] ;
23021
23022 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23024 if (!SWIG_IsOK(res1)) {
23025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23026 }
23027 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23028 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23029 if (!SWIG_IsOK(res2)) {
23030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23031 }
23032 arg2 = reinterpret_cast< wxSize * >(argp2);
23033 if (arg1) (arg1)->m_size = *arg2;
23034
23035 resultobj = SWIG_Py_Void();
23036 return resultobj;
23037 fail:
23038 return NULL;
23039 }
23040
23041
23042 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23043 PyObject *resultobj = 0;
23044 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23045 wxSize *result = 0 ;
23046 void *argp1 = 0 ;
23047 int res1 = 0 ;
23048 PyObject *swig_obj[1] ;
23049
23050 if (!args) SWIG_fail;
23051 swig_obj[0] = args;
23052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23053 if (!SWIG_IsOK(res1)) {
23054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23055 }
23056 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23057 result = (wxSize *)& ((arg1)->m_size);
23058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23059 return resultobj;
23060 fail:
23061 return NULL;
23062 }
23063
23064
23065 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23066 PyObject *resultobj = 0;
23067 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23068 wxRect *arg2 = (wxRect *) 0 ;
23069 void *argp1 = 0 ;
23070 int res1 = 0 ;
23071 void *argp2 = 0 ;
23072 int res2 = 0 ;
23073 PyObject *swig_obj[2] ;
23074
23075 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23077 if (!SWIG_IsOK(res1)) {
23078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23079 }
23080 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23081 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23082 if (!SWIG_IsOK(res2)) {
23083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23084 }
23085 arg2 = reinterpret_cast< wxRect * >(argp2);
23086 if (arg1) (arg1)->m_rect = *arg2;
23087
23088 resultobj = SWIG_Py_Void();
23089 return resultobj;
23090 fail:
23091 return NULL;
23092 }
23093
23094
23095 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23096 PyObject *resultobj = 0;
23097 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23098 wxRect *result = 0 ;
23099 void *argp1 = 0 ;
23100 int res1 = 0 ;
23101 PyObject *swig_obj[1] ;
23102
23103 if (!args) SWIG_fail;
23104 swig_obj[0] = args;
23105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23106 if (!SWIG_IsOK(res1)) {
23107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23108 }
23109 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23110 result = (wxRect *)& ((arg1)->m_rect);
23111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23119 PyObject *obj;
23120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23121 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23122 return SWIG_Py_Void();
23123 }
23124
23125 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23126 return SWIG_Python_InitShadowInstance(args);
23127 }
23128
23129 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23130 PyObject *resultobj = 0;
23131 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23132 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23133 int arg2 = (int) 0 ;
23134 wxMoveEvent *result = 0 ;
23135 wxPoint temp1 ;
23136 int val2 ;
23137 int ecode2 = 0 ;
23138 PyObject * obj0 = 0 ;
23139 PyObject * obj1 = 0 ;
23140 char * kwnames[] = {
23141 (char *) "pos",(char *) "winid", NULL
23142 };
23143
23144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23145 if (obj0) {
23146 {
23147 arg1 = &temp1;
23148 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23149 }
23150 }
23151 if (obj1) {
23152 ecode2 = SWIG_AsVal_int(obj1, &val2);
23153 if (!SWIG_IsOK(ecode2)) {
23154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23155 }
23156 arg2 = static_cast< int >(val2);
23157 }
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23161 wxPyEndAllowThreads(__tstate);
23162 if (PyErr_Occurred()) SWIG_fail;
23163 }
23164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23172 PyObject *resultobj = 0;
23173 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23174 wxPoint result;
23175 void *argp1 = 0 ;
23176 int res1 = 0 ;
23177 PyObject *swig_obj[1] ;
23178
23179 if (!args) SWIG_fail;
23180 swig_obj[0] = args;
23181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23182 if (!SWIG_IsOK(res1)) {
23183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23184 }
23185 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = ((wxMoveEvent const *)arg1)->GetPosition();
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23193 return resultobj;
23194 fail:
23195 return NULL;
23196 }
23197
23198
23199 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23200 PyObject *resultobj = 0;
23201 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23202 wxRect result;
23203 void *argp1 = 0 ;
23204 int res1 = 0 ;
23205 PyObject *swig_obj[1] ;
23206
23207 if (!args) SWIG_fail;
23208 swig_obj[0] = args;
23209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23210 if (!SWIG_IsOK(res1)) {
23211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23212 }
23213 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23214 {
23215 PyThreadState* __tstate = wxPyBeginAllowThreads();
23216 result = ((wxMoveEvent const *)arg1)->GetRect();
23217 wxPyEndAllowThreads(__tstate);
23218 if (PyErr_Occurred()) SWIG_fail;
23219 }
23220 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23221 return resultobj;
23222 fail:
23223 return NULL;
23224 }
23225
23226
23227 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23228 PyObject *resultobj = 0;
23229 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23230 wxRect *arg2 = 0 ;
23231 void *argp1 = 0 ;
23232 int res1 = 0 ;
23233 wxRect temp2 ;
23234 PyObject * obj0 = 0 ;
23235 PyObject * obj1 = 0 ;
23236 char * kwnames[] = {
23237 (char *) "self",(char *) "rect", NULL
23238 };
23239
23240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23242 if (!SWIG_IsOK(res1)) {
23243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23244 }
23245 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23246 {
23247 arg2 = &temp2;
23248 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23249 }
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 (arg1)->SetRect((wxRect const &)*arg2);
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 resultobj = SWIG_Py_Void();
23257 return resultobj;
23258 fail:
23259 return NULL;
23260 }
23261
23262
23263 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23264 PyObject *resultobj = 0;
23265 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23266 wxPoint *arg2 = 0 ;
23267 void *argp1 = 0 ;
23268 int res1 = 0 ;
23269 wxPoint temp2 ;
23270 PyObject * obj0 = 0 ;
23271 PyObject * obj1 = 0 ;
23272 char * kwnames[] = {
23273 (char *) "self",(char *) "pos", NULL
23274 };
23275
23276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23278 if (!SWIG_IsOK(res1)) {
23279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23280 }
23281 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23282 {
23283 arg2 = &temp2;
23284 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23285 }
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 (arg1)->SetPosition((wxPoint const &)*arg2);
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 resultobj = SWIG_Py_Void();
23293 return resultobj;
23294 fail:
23295 return NULL;
23296 }
23297
23298
23299 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23300 PyObject *obj;
23301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23302 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23303 return SWIG_Py_Void();
23304 }
23305
23306 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23307 return SWIG_Python_InitShadowInstance(args);
23308 }
23309
23310 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23311 PyObject *resultobj = 0;
23312 int arg1 = (int) 0 ;
23313 wxPaintEvent *result = 0 ;
23314 int val1 ;
23315 int ecode1 = 0 ;
23316 PyObject * obj0 = 0 ;
23317 char * kwnames[] = {
23318 (char *) "Id", NULL
23319 };
23320
23321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23322 if (obj0) {
23323 ecode1 = SWIG_AsVal_int(obj0, &val1);
23324 if (!SWIG_IsOK(ecode1)) {
23325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23326 }
23327 arg1 = static_cast< int >(val1);
23328 }
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23336 return resultobj;
23337 fail:
23338 return NULL;
23339 }
23340
23341
23342 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23343 PyObject *obj;
23344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23345 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23346 return SWIG_Py_Void();
23347 }
23348
23349 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23350 return SWIG_Python_InitShadowInstance(args);
23351 }
23352
23353 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23354 PyObject *resultobj = 0;
23355 int arg1 = (int) 0 ;
23356 wxNcPaintEvent *result = 0 ;
23357 int val1 ;
23358 int ecode1 = 0 ;
23359 PyObject * obj0 = 0 ;
23360 char * kwnames[] = {
23361 (char *) "winid", NULL
23362 };
23363
23364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23365 if (obj0) {
23366 ecode1 = SWIG_AsVal_int(obj0, &val1);
23367 if (!SWIG_IsOK(ecode1)) {
23368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23369 }
23370 arg1 = static_cast< int >(val1);
23371 }
23372 {
23373 PyThreadState* __tstate = wxPyBeginAllowThreads();
23374 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23375 wxPyEndAllowThreads(__tstate);
23376 if (PyErr_Occurred()) SWIG_fail;
23377 }
23378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23379 return resultobj;
23380 fail:
23381 return NULL;
23382 }
23383
23384
23385 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23386 PyObject *obj;
23387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23388 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23389 return SWIG_Py_Void();
23390 }
23391
23392 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23393 return SWIG_Python_InitShadowInstance(args);
23394 }
23395
23396 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23397 PyObject *resultobj = 0;
23398 int arg1 = (int) 0 ;
23399 wxDC *arg2 = (wxDC *) NULL ;
23400 wxEraseEvent *result = 0 ;
23401 int val1 ;
23402 int ecode1 = 0 ;
23403 void *argp2 = 0 ;
23404 int res2 = 0 ;
23405 PyObject * obj0 = 0 ;
23406 PyObject * obj1 = 0 ;
23407 char * kwnames[] = {
23408 (char *) "Id",(char *) "dc", NULL
23409 };
23410
23411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23412 if (obj0) {
23413 ecode1 = SWIG_AsVal_int(obj0, &val1);
23414 if (!SWIG_IsOK(ecode1)) {
23415 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23416 }
23417 arg1 = static_cast< int >(val1);
23418 }
23419 if (obj1) {
23420 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23421 if (!SWIG_IsOK(res2)) {
23422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23423 }
23424 arg2 = reinterpret_cast< wxDC * >(argp2);
23425 }
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23433 return resultobj;
23434 fail:
23435 return NULL;
23436 }
23437
23438
23439 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23440 PyObject *resultobj = 0;
23441 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23442 wxDC *result = 0 ;
23443 void *argp1 = 0 ;
23444 int res1 = 0 ;
23445 PyObject *swig_obj[1] ;
23446
23447 if (!args) SWIG_fail;
23448 swig_obj[0] = args;
23449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23450 if (!SWIG_IsOK(res1)) {
23451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23452 }
23453 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23454 {
23455 PyThreadState* __tstate = wxPyBeginAllowThreads();
23456 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23457 wxPyEndAllowThreads(__tstate);
23458 if (PyErr_Occurred()) SWIG_fail;
23459 }
23460 {
23461 resultobj = wxPyMake_wxObject(result, (bool)0);
23462 }
23463 return resultobj;
23464 fail:
23465 return NULL;
23466 }
23467
23468
23469 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23470 PyObject *obj;
23471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23472 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23473 return SWIG_Py_Void();
23474 }
23475
23476 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23477 return SWIG_Python_InitShadowInstance(args);
23478 }
23479
23480 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj = 0;
23482 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23483 int arg2 = (int) 0 ;
23484 wxFocusEvent *result = 0 ;
23485 int val1 ;
23486 int ecode1 = 0 ;
23487 int val2 ;
23488 int ecode2 = 0 ;
23489 PyObject * obj0 = 0 ;
23490 PyObject * obj1 = 0 ;
23491 char * kwnames[] = {
23492 (char *) "type",(char *) "winid", NULL
23493 };
23494
23495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23496 if (obj0) {
23497 ecode1 = SWIG_AsVal_int(obj0, &val1);
23498 if (!SWIG_IsOK(ecode1)) {
23499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23500 }
23501 arg1 = static_cast< wxEventType >(val1);
23502 }
23503 if (obj1) {
23504 ecode2 = SWIG_AsVal_int(obj1, &val2);
23505 if (!SWIG_IsOK(ecode2)) {
23506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23507 }
23508 arg2 = static_cast< int >(val2);
23509 }
23510 {
23511 PyThreadState* __tstate = wxPyBeginAllowThreads();
23512 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23513 wxPyEndAllowThreads(__tstate);
23514 if (PyErr_Occurred()) SWIG_fail;
23515 }
23516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23517 return resultobj;
23518 fail:
23519 return NULL;
23520 }
23521
23522
23523 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23524 PyObject *resultobj = 0;
23525 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23526 wxWindow *result = 0 ;
23527 void *argp1 = 0 ;
23528 int res1 = 0 ;
23529 PyObject *swig_obj[1] ;
23530
23531 if (!args) SWIG_fail;
23532 swig_obj[0] = args;
23533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23534 if (!SWIG_IsOK(res1)) {
23535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23536 }
23537 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23538 {
23539 PyThreadState* __tstate = wxPyBeginAllowThreads();
23540 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23541 wxPyEndAllowThreads(__tstate);
23542 if (PyErr_Occurred()) SWIG_fail;
23543 }
23544 {
23545 resultobj = wxPyMake_wxObject(result, (bool)0);
23546 }
23547 return resultobj;
23548 fail:
23549 return NULL;
23550 }
23551
23552
23553 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23554 PyObject *resultobj = 0;
23555 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23556 wxWindow *arg2 = (wxWindow *) 0 ;
23557 void *argp1 = 0 ;
23558 int res1 = 0 ;
23559 void *argp2 = 0 ;
23560 int res2 = 0 ;
23561 PyObject * obj0 = 0 ;
23562 PyObject * obj1 = 0 ;
23563 char * kwnames[] = {
23564 (char *) "self",(char *) "win", NULL
23565 };
23566
23567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23569 if (!SWIG_IsOK(res1)) {
23570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23571 }
23572 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23574 if (!SWIG_IsOK(res2)) {
23575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23576 }
23577 arg2 = reinterpret_cast< wxWindow * >(argp2);
23578 {
23579 PyThreadState* __tstate = wxPyBeginAllowThreads();
23580 (arg1)->SetWindow(arg2);
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 resultobj = SWIG_Py_Void();
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *obj;
23593 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23594 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23595 return SWIG_Py_Void();
23596 }
23597
23598 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23599 return SWIG_Python_InitShadowInstance(args);
23600 }
23601
23602 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23603 PyObject *resultobj = 0;
23604 wxWindow *arg1 = (wxWindow *) NULL ;
23605 wxChildFocusEvent *result = 0 ;
23606 void *argp1 = 0 ;
23607 int res1 = 0 ;
23608 PyObject * obj0 = 0 ;
23609 char * kwnames[] = {
23610 (char *) "win", NULL
23611 };
23612
23613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23614 if (obj0) {
23615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23616 if (!SWIG_IsOK(res1)) {
23617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23618 }
23619 arg1 = reinterpret_cast< wxWindow * >(argp1);
23620 }
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23624 wxPyEndAllowThreads(__tstate);
23625 if (PyErr_Occurred()) SWIG_fail;
23626 }
23627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23628 return resultobj;
23629 fail:
23630 return NULL;
23631 }
23632
23633
23634 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23635 PyObject *resultobj = 0;
23636 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23637 wxWindow *result = 0 ;
23638 void *argp1 = 0 ;
23639 int res1 = 0 ;
23640 PyObject *swig_obj[1] ;
23641
23642 if (!args) SWIG_fail;
23643 swig_obj[0] = args;
23644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23645 if (!SWIG_IsOK(res1)) {
23646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23647 }
23648 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23649 {
23650 PyThreadState* __tstate = wxPyBeginAllowThreads();
23651 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23652 wxPyEndAllowThreads(__tstate);
23653 if (PyErr_Occurred()) SWIG_fail;
23654 }
23655 {
23656 resultobj = wxPyMake_wxObject(result, (bool)0);
23657 }
23658 return resultobj;
23659 fail:
23660 return NULL;
23661 }
23662
23663
23664 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23665 PyObject *obj;
23666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23667 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23668 return SWIG_Py_Void();
23669 }
23670
23671 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23672 return SWIG_Python_InitShadowInstance(args);
23673 }
23674
23675 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23676 PyObject *resultobj = 0;
23677 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23678 bool arg2 = (bool) true ;
23679 int arg3 = (int) 0 ;
23680 wxActivateEvent *result = 0 ;
23681 int val1 ;
23682 int ecode1 = 0 ;
23683 bool val2 ;
23684 int ecode2 = 0 ;
23685 int val3 ;
23686 int ecode3 = 0 ;
23687 PyObject * obj0 = 0 ;
23688 PyObject * obj1 = 0 ;
23689 PyObject * obj2 = 0 ;
23690 char * kwnames[] = {
23691 (char *) "type",(char *) "active",(char *) "Id", NULL
23692 };
23693
23694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23695 if (obj0) {
23696 ecode1 = SWIG_AsVal_int(obj0, &val1);
23697 if (!SWIG_IsOK(ecode1)) {
23698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23699 }
23700 arg1 = static_cast< wxEventType >(val1);
23701 }
23702 if (obj1) {
23703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23704 if (!SWIG_IsOK(ecode2)) {
23705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23706 }
23707 arg2 = static_cast< bool >(val2);
23708 }
23709 if (obj2) {
23710 ecode3 = SWIG_AsVal_int(obj2, &val3);
23711 if (!SWIG_IsOK(ecode3)) {
23712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23713 }
23714 arg3 = static_cast< int >(val3);
23715 }
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23723 return resultobj;
23724 fail:
23725 return NULL;
23726 }
23727
23728
23729 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23730 PyObject *resultobj = 0;
23731 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23732 bool result;
23733 void *argp1 = 0 ;
23734 int res1 = 0 ;
23735 PyObject *swig_obj[1] ;
23736
23737 if (!args) SWIG_fail;
23738 swig_obj[0] = args;
23739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23740 if (!SWIG_IsOK(res1)) {
23741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23742 }
23743 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23747 wxPyEndAllowThreads(__tstate);
23748 if (PyErr_Occurred()) SWIG_fail;
23749 }
23750 {
23751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23752 }
23753 return resultobj;
23754 fail:
23755 return NULL;
23756 }
23757
23758
23759 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23760 PyObject *obj;
23761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23762 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23763 return SWIG_Py_Void();
23764 }
23765
23766 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23767 return SWIG_Python_InitShadowInstance(args);
23768 }
23769
23770 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23771 PyObject *resultobj = 0;
23772 int arg1 = (int) 0 ;
23773 wxInitDialogEvent *result = 0 ;
23774 int val1 ;
23775 int ecode1 = 0 ;
23776 PyObject * obj0 = 0 ;
23777 char * kwnames[] = {
23778 (char *) "Id", NULL
23779 };
23780
23781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23782 if (obj0) {
23783 ecode1 = SWIG_AsVal_int(obj0, &val1);
23784 if (!SWIG_IsOK(ecode1)) {
23785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23786 }
23787 arg1 = static_cast< int >(val1);
23788 }
23789 {
23790 PyThreadState* __tstate = wxPyBeginAllowThreads();
23791 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23792 wxPyEndAllowThreads(__tstate);
23793 if (PyErr_Occurred()) SWIG_fail;
23794 }
23795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23796 return resultobj;
23797 fail:
23798 return NULL;
23799 }
23800
23801
23802 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23803 PyObject *obj;
23804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23805 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23806 return SWIG_Py_Void();
23807 }
23808
23809 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 return SWIG_Python_InitShadowInstance(args);
23811 }
23812
23813 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23814 PyObject *resultobj = 0;
23815 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23816 int arg2 = (int) 0 ;
23817 wxMenu *arg3 = (wxMenu *) NULL ;
23818 wxMenuEvent *result = 0 ;
23819 int val1 ;
23820 int ecode1 = 0 ;
23821 int val2 ;
23822 int ecode2 = 0 ;
23823 void *argp3 = 0 ;
23824 int res3 = 0 ;
23825 PyObject * obj0 = 0 ;
23826 PyObject * obj1 = 0 ;
23827 PyObject * obj2 = 0 ;
23828 char * kwnames[] = {
23829 (char *) "type",(char *) "winid",(char *) "menu", NULL
23830 };
23831
23832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23833 if (obj0) {
23834 ecode1 = SWIG_AsVal_int(obj0, &val1);
23835 if (!SWIG_IsOK(ecode1)) {
23836 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23837 }
23838 arg1 = static_cast< wxEventType >(val1);
23839 }
23840 if (obj1) {
23841 ecode2 = SWIG_AsVal_int(obj1, &val2);
23842 if (!SWIG_IsOK(ecode2)) {
23843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23844 }
23845 arg2 = static_cast< int >(val2);
23846 }
23847 if (obj2) {
23848 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23849 if (!SWIG_IsOK(res3)) {
23850 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23851 }
23852 arg3 = reinterpret_cast< wxMenu * >(argp3);
23853 }
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23868 PyObject *resultobj = 0;
23869 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23870 int result;
23871 void *argp1 = 0 ;
23872 int res1 = 0 ;
23873 PyObject *swig_obj[1] ;
23874
23875 if (!args) SWIG_fail;
23876 swig_obj[0] = args;
23877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23880 }
23881 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 resultobj = SWIG_From_int(static_cast< int >(result));
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23896 PyObject *resultobj = 0;
23897 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23898 bool result;
23899 void *argp1 = 0 ;
23900 int res1 = 0 ;
23901 PyObject *swig_obj[1] ;
23902
23903 if (!args) SWIG_fail;
23904 swig_obj[0] = args;
23905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23906 if (!SWIG_IsOK(res1)) {
23907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23908 }
23909 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23910 {
23911 PyThreadState* __tstate = wxPyBeginAllowThreads();
23912 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 {
23917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23918 }
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23926 PyObject *resultobj = 0;
23927 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23928 wxMenu *result = 0 ;
23929 void *argp1 = 0 ;
23930 int res1 = 0 ;
23931 PyObject *swig_obj[1] ;
23932
23933 if (!args) SWIG_fail;
23934 swig_obj[0] = args;
23935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23936 if (!SWIG_IsOK(res1)) {
23937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23938 }
23939 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23940 {
23941 PyThreadState* __tstate = wxPyBeginAllowThreads();
23942 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23943 wxPyEndAllowThreads(__tstate);
23944 if (PyErr_Occurred()) SWIG_fail;
23945 }
23946 {
23947 resultobj = wxPyMake_wxObject(result, (bool)0);
23948 }
23949 return resultobj;
23950 fail:
23951 return NULL;
23952 }
23953
23954
23955 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23956 PyObject *obj;
23957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23958 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
23959 return SWIG_Py_Void();
23960 }
23961
23962 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23963 return SWIG_Python_InitShadowInstance(args);
23964 }
23965
23966 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj = 0;
23968 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23969 int arg2 = (int) 0 ;
23970 wxCloseEvent *result = 0 ;
23971 int val1 ;
23972 int ecode1 = 0 ;
23973 int val2 ;
23974 int ecode2 = 0 ;
23975 PyObject * obj0 = 0 ;
23976 PyObject * obj1 = 0 ;
23977 char * kwnames[] = {
23978 (char *) "type",(char *) "winid", NULL
23979 };
23980
23981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23982 if (obj0) {
23983 ecode1 = SWIG_AsVal_int(obj0, &val1);
23984 if (!SWIG_IsOK(ecode1)) {
23985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23986 }
23987 arg1 = static_cast< wxEventType >(val1);
23988 }
23989 if (obj1) {
23990 ecode2 = SWIG_AsVal_int(obj1, &val2);
23991 if (!SWIG_IsOK(ecode2)) {
23992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
23993 }
23994 arg2 = static_cast< int >(val2);
23995 }
23996 {
23997 PyThreadState* __tstate = wxPyBeginAllowThreads();
23998 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
23999 wxPyEndAllowThreads(__tstate);
24000 if (PyErr_Occurred()) SWIG_fail;
24001 }
24002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24003 return resultobj;
24004 fail:
24005 return NULL;
24006 }
24007
24008
24009 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24010 PyObject *resultobj = 0;
24011 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24012 bool arg2 ;
24013 void *argp1 = 0 ;
24014 int res1 = 0 ;
24015 bool val2 ;
24016 int ecode2 = 0 ;
24017 PyObject * obj0 = 0 ;
24018 PyObject * obj1 = 0 ;
24019 char * kwnames[] = {
24020 (char *) "self",(char *) "logOff", NULL
24021 };
24022
24023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24025 if (!SWIG_IsOK(res1)) {
24026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24027 }
24028 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24030 if (!SWIG_IsOK(ecode2)) {
24031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24032 }
24033 arg2 = static_cast< bool >(val2);
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 (arg1)->SetLoggingOff(arg2);
24037 wxPyEndAllowThreads(__tstate);
24038 if (PyErr_Occurred()) SWIG_fail;
24039 }
24040 resultobj = SWIG_Py_Void();
24041 return resultobj;
24042 fail:
24043 return NULL;
24044 }
24045
24046
24047 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24048 PyObject *resultobj = 0;
24049 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24050 bool result;
24051 void *argp1 = 0 ;
24052 int res1 = 0 ;
24053 PyObject *swig_obj[1] ;
24054
24055 if (!args) SWIG_fail;
24056 swig_obj[0] = args;
24057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24058 if (!SWIG_IsOK(res1)) {
24059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24060 }
24061 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24065 wxPyEndAllowThreads(__tstate);
24066 if (PyErr_Occurred()) SWIG_fail;
24067 }
24068 {
24069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24070 }
24071 return resultobj;
24072 fail:
24073 return NULL;
24074 }
24075
24076
24077 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24078 PyObject *resultobj = 0;
24079 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24080 bool arg2 = (bool) true ;
24081 void *argp1 = 0 ;
24082 int res1 = 0 ;
24083 bool val2 ;
24084 int ecode2 = 0 ;
24085 PyObject * obj0 = 0 ;
24086 PyObject * obj1 = 0 ;
24087 char * kwnames[] = {
24088 (char *) "self",(char *) "veto", NULL
24089 };
24090
24091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24093 if (!SWIG_IsOK(res1)) {
24094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24095 }
24096 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24097 if (obj1) {
24098 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24099 if (!SWIG_IsOK(ecode2)) {
24100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24101 }
24102 arg2 = static_cast< bool >(val2);
24103 }
24104 {
24105 PyThreadState* __tstate = wxPyBeginAllowThreads();
24106 (arg1)->Veto(arg2);
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 resultobj = SWIG_Py_Void();
24111 return resultobj;
24112 fail:
24113 return NULL;
24114 }
24115
24116
24117 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24118 PyObject *resultobj = 0;
24119 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24120 bool result;
24121 void *argp1 = 0 ;
24122 int res1 = 0 ;
24123 PyObject *swig_obj[1] ;
24124
24125 if (!args) SWIG_fail;
24126 swig_obj[0] = args;
24127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24128 if (!SWIG_IsOK(res1)) {
24129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24130 }
24131 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24132 {
24133 PyThreadState* __tstate = wxPyBeginAllowThreads();
24134 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24135 wxPyEndAllowThreads(__tstate);
24136 if (PyErr_Occurred()) SWIG_fail;
24137 }
24138 {
24139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24140 }
24141 return resultobj;
24142 fail:
24143 return NULL;
24144 }
24145
24146
24147 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24148 PyObject *resultobj = 0;
24149 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24150 bool arg2 ;
24151 void *argp1 = 0 ;
24152 int res1 = 0 ;
24153 bool val2 ;
24154 int ecode2 = 0 ;
24155 PyObject * obj0 = 0 ;
24156 PyObject * obj1 = 0 ;
24157 char * kwnames[] = {
24158 (char *) "self",(char *) "canVeto", NULL
24159 };
24160
24161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24163 if (!SWIG_IsOK(res1)) {
24164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24165 }
24166 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24167 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24168 if (!SWIG_IsOK(ecode2)) {
24169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24170 }
24171 arg2 = static_cast< bool >(val2);
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 (arg1)->SetCanVeto(arg2);
24175 wxPyEndAllowThreads(__tstate);
24176 if (PyErr_Occurred()) SWIG_fail;
24177 }
24178 resultobj = SWIG_Py_Void();
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24186 PyObject *resultobj = 0;
24187 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24188 bool result;
24189 void *argp1 = 0 ;
24190 int res1 = 0 ;
24191 PyObject *swig_obj[1] ;
24192
24193 if (!args) SWIG_fail;
24194 swig_obj[0] = args;
24195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24196 if (!SWIG_IsOK(res1)) {
24197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24198 }
24199 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 {
24207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24208 }
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24216 PyObject *obj;
24217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24218 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24219 return SWIG_Py_Void();
24220 }
24221
24222 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24223 return SWIG_Python_InitShadowInstance(args);
24224 }
24225
24226 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24227 PyObject *resultobj = 0;
24228 int arg1 = (int) 0 ;
24229 bool arg2 = (bool) false ;
24230 wxShowEvent *result = 0 ;
24231 int val1 ;
24232 int ecode1 = 0 ;
24233 bool val2 ;
24234 int ecode2 = 0 ;
24235 PyObject * obj0 = 0 ;
24236 PyObject * obj1 = 0 ;
24237 char * kwnames[] = {
24238 (char *) "winid",(char *) "show", NULL
24239 };
24240
24241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24242 if (obj0) {
24243 ecode1 = SWIG_AsVal_int(obj0, &val1);
24244 if (!SWIG_IsOK(ecode1)) {
24245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24246 }
24247 arg1 = static_cast< int >(val1);
24248 }
24249 if (obj1) {
24250 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24251 if (!SWIG_IsOK(ecode2)) {
24252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24253 }
24254 arg2 = static_cast< bool >(val2);
24255 }
24256 {
24257 PyThreadState* __tstate = wxPyBeginAllowThreads();
24258 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24259 wxPyEndAllowThreads(__tstate);
24260 if (PyErr_Occurred()) SWIG_fail;
24261 }
24262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24263 return resultobj;
24264 fail:
24265 return NULL;
24266 }
24267
24268
24269 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24270 PyObject *resultobj = 0;
24271 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24272 bool arg2 ;
24273 void *argp1 = 0 ;
24274 int res1 = 0 ;
24275 bool val2 ;
24276 int ecode2 = 0 ;
24277 PyObject * obj0 = 0 ;
24278 PyObject * obj1 = 0 ;
24279 char * kwnames[] = {
24280 (char *) "self",(char *) "show", NULL
24281 };
24282
24283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24285 if (!SWIG_IsOK(res1)) {
24286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24287 }
24288 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24289 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24290 if (!SWIG_IsOK(ecode2)) {
24291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24292 }
24293 arg2 = static_cast< bool >(val2);
24294 {
24295 PyThreadState* __tstate = wxPyBeginAllowThreads();
24296 (arg1)->SetShow(arg2);
24297 wxPyEndAllowThreads(__tstate);
24298 if (PyErr_Occurred()) SWIG_fail;
24299 }
24300 resultobj = SWIG_Py_Void();
24301 return resultobj;
24302 fail:
24303 return NULL;
24304 }
24305
24306
24307 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24308 PyObject *resultobj = 0;
24309 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24310 bool result;
24311 void *argp1 = 0 ;
24312 int res1 = 0 ;
24313 PyObject *swig_obj[1] ;
24314
24315 if (!args) SWIG_fail;
24316 swig_obj[0] = args;
24317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24318 if (!SWIG_IsOK(res1)) {
24319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24320 }
24321 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 {
24329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24330 }
24331 return resultobj;
24332 fail:
24333 return NULL;
24334 }
24335
24336
24337 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24338 PyObject *obj;
24339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24340 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24341 return SWIG_Py_Void();
24342 }
24343
24344 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24345 return SWIG_Python_InitShadowInstance(args);
24346 }
24347
24348 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24349 PyObject *resultobj = 0;
24350 int arg1 = (int) 0 ;
24351 bool arg2 = (bool) true ;
24352 wxIconizeEvent *result = 0 ;
24353 int val1 ;
24354 int ecode1 = 0 ;
24355 bool val2 ;
24356 int ecode2 = 0 ;
24357 PyObject * obj0 = 0 ;
24358 PyObject * obj1 = 0 ;
24359 char * kwnames[] = {
24360 (char *) "id",(char *) "iconized", NULL
24361 };
24362
24363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24364 if (obj0) {
24365 ecode1 = SWIG_AsVal_int(obj0, &val1);
24366 if (!SWIG_IsOK(ecode1)) {
24367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24368 }
24369 arg1 = static_cast< int >(val1);
24370 }
24371 if (obj1) {
24372 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24373 if (!SWIG_IsOK(ecode2)) {
24374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24375 }
24376 arg2 = static_cast< bool >(val2);
24377 }
24378 {
24379 PyThreadState* __tstate = wxPyBeginAllowThreads();
24380 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24381 wxPyEndAllowThreads(__tstate);
24382 if (PyErr_Occurred()) SWIG_fail;
24383 }
24384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24385 return resultobj;
24386 fail:
24387 return NULL;
24388 }
24389
24390
24391 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24392 PyObject *resultobj = 0;
24393 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24394 bool result;
24395 void *argp1 = 0 ;
24396 int res1 = 0 ;
24397 PyObject *swig_obj[1] ;
24398
24399 if (!args) SWIG_fail;
24400 swig_obj[0] = args;
24401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24402 if (!SWIG_IsOK(res1)) {
24403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24404 }
24405 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24406 {
24407 PyThreadState* __tstate = wxPyBeginAllowThreads();
24408 result = (bool)(arg1)->Iconized();
24409 wxPyEndAllowThreads(__tstate);
24410 if (PyErr_Occurred()) SWIG_fail;
24411 }
24412 {
24413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24414 }
24415 return resultobj;
24416 fail:
24417 return NULL;
24418 }
24419
24420
24421 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24422 PyObject *obj;
24423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24424 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24425 return SWIG_Py_Void();
24426 }
24427
24428 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24429 return SWIG_Python_InitShadowInstance(args);
24430 }
24431
24432 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24433 PyObject *resultobj = 0;
24434 int arg1 = (int) 0 ;
24435 wxMaximizeEvent *result = 0 ;
24436 int val1 ;
24437 int ecode1 = 0 ;
24438 PyObject * obj0 = 0 ;
24439 char * kwnames[] = {
24440 (char *) "id", NULL
24441 };
24442
24443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24444 if (obj0) {
24445 ecode1 = SWIG_AsVal_int(obj0, &val1);
24446 if (!SWIG_IsOK(ecode1)) {
24447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24448 }
24449 arg1 = static_cast< int >(val1);
24450 }
24451 {
24452 PyThreadState* __tstate = wxPyBeginAllowThreads();
24453 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24454 wxPyEndAllowThreads(__tstate);
24455 if (PyErr_Occurred()) SWIG_fail;
24456 }
24457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24465 PyObject *obj;
24466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24467 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24468 return SWIG_Py_Void();
24469 }
24470
24471 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24472 return SWIG_Python_InitShadowInstance(args);
24473 }
24474
24475 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24476 PyObject *resultobj = 0;
24477 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24478 wxPoint result;
24479 void *argp1 = 0 ;
24480 int res1 = 0 ;
24481 PyObject *swig_obj[1] ;
24482
24483 if (!args) SWIG_fail;
24484 swig_obj[0] = args;
24485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24488 }
24489 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24490 {
24491 PyThreadState* __tstate = wxPyBeginAllowThreads();
24492 result = (arg1)->GetPosition();
24493 wxPyEndAllowThreads(__tstate);
24494 if (PyErr_Occurred()) SWIG_fail;
24495 }
24496 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24504 PyObject *resultobj = 0;
24505 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24506 int result;
24507 void *argp1 = 0 ;
24508 int res1 = 0 ;
24509 PyObject *swig_obj[1] ;
24510
24511 if (!args) SWIG_fail;
24512 swig_obj[0] = args;
24513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24514 if (!SWIG_IsOK(res1)) {
24515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24516 }
24517 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 result = (int)(arg1)->GetNumberOfFiles();
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = SWIG_From_int(static_cast< int >(result));
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *resultobj = 0;
24533 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24534 PyObject *result = 0 ;
24535 void *argp1 = 0 ;
24536 int res1 = 0 ;
24537 PyObject *swig_obj[1] ;
24538
24539 if (!args) SWIG_fail;
24540 swig_obj[0] = args;
24541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24542 if (!SWIG_IsOK(res1)) {
24543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24544 }
24545 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24549 wxPyEndAllowThreads(__tstate);
24550 if (PyErr_Occurred()) SWIG_fail;
24551 }
24552 resultobj = result;
24553 return resultobj;
24554 fail:
24555 return NULL;
24556 }
24557
24558
24559 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24560 PyObject *obj;
24561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24562 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24563 return SWIG_Py_Void();
24564 }
24565
24566 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24567 PyObject *resultobj = 0;
24568 int arg1 = (int) 0 ;
24569 wxUpdateUIEvent *result = 0 ;
24570 int val1 ;
24571 int ecode1 = 0 ;
24572 PyObject * obj0 = 0 ;
24573 char * kwnames[] = {
24574 (char *) "commandId", NULL
24575 };
24576
24577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24578 if (obj0) {
24579 ecode1 = SWIG_AsVal_int(obj0, &val1);
24580 if (!SWIG_IsOK(ecode1)) {
24581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24582 }
24583 arg1 = static_cast< int >(val1);
24584 }
24585 {
24586 PyThreadState* __tstate = wxPyBeginAllowThreads();
24587 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24599 PyObject *resultobj = 0;
24600 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24601 bool result;
24602 void *argp1 = 0 ;
24603 int res1 = 0 ;
24604 PyObject *swig_obj[1] ;
24605
24606 if (!args) SWIG_fail;
24607 swig_obj[0] = args;
24608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24609 if (!SWIG_IsOK(res1)) {
24610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24611 }
24612 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24613 {
24614 PyThreadState* __tstate = wxPyBeginAllowThreads();
24615 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24616 wxPyEndAllowThreads(__tstate);
24617 if (PyErr_Occurred()) SWIG_fail;
24618 }
24619 {
24620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24621 }
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24629 PyObject *resultobj = 0;
24630 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24631 bool result;
24632 void *argp1 = 0 ;
24633 int res1 = 0 ;
24634 PyObject *swig_obj[1] ;
24635
24636 if (!args) SWIG_fail;
24637 swig_obj[0] = args;
24638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24639 if (!SWIG_IsOK(res1)) {
24640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24641 }
24642 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24643 {
24644 PyThreadState* __tstate = wxPyBeginAllowThreads();
24645 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24646 wxPyEndAllowThreads(__tstate);
24647 if (PyErr_Occurred()) SWIG_fail;
24648 }
24649 {
24650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24651 }
24652 return resultobj;
24653 fail:
24654 return NULL;
24655 }
24656
24657
24658 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24659 PyObject *resultobj = 0;
24660 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24661 bool result;
24662 void *argp1 = 0 ;
24663 int res1 = 0 ;
24664 PyObject *swig_obj[1] ;
24665
24666 if (!args) SWIG_fail;
24667 swig_obj[0] = args;
24668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24669 if (!SWIG_IsOK(res1)) {
24670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24671 }
24672 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24676 wxPyEndAllowThreads(__tstate);
24677 if (PyErr_Occurred()) SWIG_fail;
24678 }
24679 {
24680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24681 }
24682 return resultobj;
24683 fail:
24684 return NULL;
24685 }
24686
24687
24688 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24689 PyObject *resultobj = 0;
24690 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24691 wxString result;
24692 void *argp1 = 0 ;
24693 int res1 = 0 ;
24694 PyObject *swig_obj[1] ;
24695
24696 if (!args) SWIG_fail;
24697 swig_obj[0] = args;
24698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24699 if (!SWIG_IsOK(res1)) {
24700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24701 }
24702 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24703 {
24704 PyThreadState* __tstate = wxPyBeginAllowThreads();
24705 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24706 wxPyEndAllowThreads(__tstate);
24707 if (PyErr_Occurred()) SWIG_fail;
24708 }
24709 {
24710 #if wxUSE_UNICODE
24711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24712 #else
24713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24714 #endif
24715 }
24716 return resultobj;
24717 fail:
24718 return NULL;
24719 }
24720
24721
24722 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24723 PyObject *resultobj = 0;
24724 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24725 bool result;
24726 void *argp1 = 0 ;
24727 int res1 = 0 ;
24728 PyObject *swig_obj[1] ;
24729
24730 if (!args) SWIG_fail;
24731 swig_obj[0] = args;
24732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24733 if (!SWIG_IsOK(res1)) {
24734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24735 }
24736 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24737 {
24738 PyThreadState* __tstate = wxPyBeginAllowThreads();
24739 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24740 wxPyEndAllowThreads(__tstate);
24741 if (PyErr_Occurred()) SWIG_fail;
24742 }
24743 {
24744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24745 }
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24753 PyObject *resultobj = 0;
24754 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24755 bool result;
24756 void *argp1 = 0 ;
24757 int res1 = 0 ;
24758 PyObject *swig_obj[1] ;
24759
24760 if (!args) SWIG_fail;
24761 swig_obj[0] = args;
24762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24763 if (!SWIG_IsOK(res1)) {
24764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24765 }
24766 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 {
24774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24775 }
24776 return resultobj;
24777 fail:
24778 return NULL;
24779 }
24780
24781
24782 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24783 PyObject *resultobj = 0;
24784 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24785 bool result;
24786 void *argp1 = 0 ;
24787 int res1 = 0 ;
24788 PyObject *swig_obj[1] ;
24789
24790 if (!args) SWIG_fail;
24791 swig_obj[0] = args;
24792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24793 if (!SWIG_IsOK(res1)) {
24794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24795 }
24796 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24797 {
24798 PyThreadState* __tstate = wxPyBeginAllowThreads();
24799 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24800 wxPyEndAllowThreads(__tstate);
24801 if (PyErr_Occurred()) SWIG_fail;
24802 }
24803 {
24804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24805 }
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24813 PyObject *resultobj = 0;
24814 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24815 bool result;
24816 void *argp1 = 0 ;
24817 int res1 = 0 ;
24818 PyObject *swig_obj[1] ;
24819
24820 if (!args) SWIG_fail;
24821 swig_obj[0] = args;
24822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24823 if (!SWIG_IsOK(res1)) {
24824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24825 }
24826 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24830 wxPyEndAllowThreads(__tstate);
24831 if (PyErr_Occurred()) SWIG_fail;
24832 }
24833 {
24834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24835 }
24836 return resultobj;
24837 fail:
24838 return NULL;
24839 }
24840
24841
24842 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24843 PyObject *resultobj = 0;
24844 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24845 bool arg2 ;
24846 void *argp1 = 0 ;
24847 int res1 = 0 ;
24848 bool val2 ;
24849 int ecode2 = 0 ;
24850 PyObject * obj0 = 0 ;
24851 PyObject * obj1 = 0 ;
24852 char * kwnames[] = {
24853 (char *) "self",(char *) "check", NULL
24854 };
24855
24856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24858 if (!SWIG_IsOK(res1)) {
24859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24860 }
24861 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24862 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24863 if (!SWIG_IsOK(ecode2)) {
24864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24865 }
24866 arg2 = static_cast< bool >(val2);
24867 {
24868 PyThreadState* __tstate = wxPyBeginAllowThreads();
24869 (arg1)->Check(arg2);
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 resultobj = SWIG_Py_Void();
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj = 0;
24882 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24883 bool arg2 ;
24884 void *argp1 = 0 ;
24885 int res1 = 0 ;
24886 bool val2 ;
24887 int ecode2 = 0 ;
24888 PyObject * obj0 = 0 ;
24889 PyObject * obj1 = 0 ;
24890 char * kwnames[] = {
24891 (char *) "self",(char *) "enable", NULL
24892 };
24893
24894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24896 if (!SWIG_IsOK(res1)) {
24897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24898 }
24899 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24900 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24901 if (!SWIG_IsOK(ecode2)) {
24902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24903 }
24904 arg2 = static_cast< bool >(val2);
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 (arg1)->Enable(arg2);
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 resultobj = SWIG_Py_Void();
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24919 PyObject *resultobj = 0;
24920 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24921 bool arg2 ;
24922 void *argp1 = 0 ;
24923 int res1 = 0 ;
24924 bool val2 ;
24925 int ecode2 = 0 ;
24926 PyObject * obj0 = 0 ;
24927 PyObject * obj1 = 0 ;
24928 char * kwnames[] = {
24929 (char *) "self",(char *) "show", NULL
24930 };
24931
24932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24934 if (!SWIG_IsOK(res1)) {
24935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24936 }
24937 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24938 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24939 if (!SWIG_IsOK(ecode2)) {
24940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24941 }
24942 arg2 = static_cast< bool >(val2);
24943 {
24944 PyThreadState* __tstate = wxPyBeginAllowThreads();
24945 (arg1)->Show(arg2);
24946 wxPyEndAllowThreads(__tstate);
24947 if (PyErr_Occurred()) SWIG_fail;
24948 }
24949 resultobj = SWIG_Py_Void();
24950 return resultobj;
24951 fail:
24952 return NULL;
24953 }
24954
24955
24956 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24957 PyObject *resultobj = 0;
24958 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24959 wxString *arg2 = 0 ;
24960 void *argp1 = 0 ;
24961 int res1 = 0 ;
24962 bool temp2 = false ;
24963 PyObject * obj0 = 0 ;
24964 PyObject * obj1 = 0 ;
24965 char * kwnames[] = {
24966 (char *) "self",(char *) "text", NULL
24967 };
24968
24969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
24970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24971 if (!SWIG_IsOK(res1)) {
24972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24973 }
24974 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24975 {
24976 arg2 = wxString_in_helper(obj1);
24977 if (arg2 == NULL) SWIG_fail;
24978 temp2 = true;
24979 }
24980 {
24981 PyThreadState* __tstate = wxPyBeginAllowThreads();
24982 (arg1)->SetText((wxString const &)*arg2);
24983 wxPyEndAllowThreads(__tstate);
24984 if (PyErr_Occurred()) SWIG_fail;
24985 }
24986 resultobj = SWIG_Py_Void();
24987 {
24988 if (temp2)
24989 delete arg2;
24990 }
24991 return resultobj;
24992 fail:
24993 {
24994 if (temp2)
24995 delete arg2;
24996 }
24997 return NULL;
24998 }
24999
25000
25001 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25002 PyObject *resultobj = 0;
25003 long arg1 ;
25004 long val1 ;
25005 int ecode1 = 0 ;
25006 PyObject * obj0 = 0 ;
25007 char * kwnames[] = {
25008 (char *) "updateInterval", NULL
25009 };
25010
25011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25012 ecode1 = SWIG_AsVal_long(obj0, &val1);
25013 if (!SWIG_IsOK(ecode1)) {
25014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25015 }
25016 arg1 = static_cast< long >(val1);
25017 {
25018 PyThreadState* __tstate = wxPyBeginAllowThreads();
25019 wxUpdateUIEvent::SetUpdateInterval(arg1);
25020 wxPyEndAllowThreads(__tstate);
25021 if (PyErr_Occurred()) SWIG_fail;
25022 }
25023 resultobj = SWIG_Py_Void();
25024 return resultobj;
25025 fail:
25026 return NULL;
25027 }
25028
25029
25030 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25031 PyObject *resultobj = 0;
25032 long result;
25033
25034 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 resultobj = SWIG_From_long(static_cast< long >(result));
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25049 PyObject *resultobj = 0;
25050 wxWindow *arg1 = (wxWindow *) 0 ;
25051 bool result;
25052 void *argp1 = 0 ;
25053 int res1 = 0 ;
25054 PyObject * obj0 = 0 ;
25055 char * kwnames[] = {
25056 (char *) "win", NULL
25057 };
25058
25059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25061 if (!SWIG_IsOK(res1)) {
25062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25063 }
25064 arg1 = reinterpret_cast< wxWindow * >(argp1);
25065 {
25066 PyThreadState* __tstate = wxPyBeginAllowThreads();
25067 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25068 wxPyEndAllowThreads(__tstate);
25069 if (PyErr_Occurred()) SWIG_fail;
25070 }
25071 {
25072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25073 }
25074 return resultobj;
25075 fail:
25076 return NULL;
25077 }
25078
25079
25080 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25081 PyObject *resultobj = 0;
25082
25083 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 wxUpdateUIEvent::ResetUpdateTime();
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_Py_Void();
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj = 0;
25099 wxUpdateUIMode arg1 ;
25100 int val1 ;
25101 int ecode1 = 0 ;
25102 PyObject * obj0 = 0 ;
25103 char * kwnames[] = {
25104 (char *) "mode", NULL
25105 };
25106
25107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25108 ecode1 = SWIG_AsVal_int(obj0, &val1);
25109 if (!SWIG_IsOK(ecode1)) {
25110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25111 }
25112 arg1 = static_cast< wxUpdateUIMode >(val1);
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 wxUpdateUIEvent::SetMode(arg1);
25116 wxPyEndAllowThreads(__tstate);
25117 if (PyErr_Occurred()) SWIG_fail;
25118 }
25119 resultobj = SWIG_Py_Void();
25120 return resultobj;
25121 fail:
25122 return NULL;
25123 }
25124
25125
25126 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25127 PyObject *resultobj = 0;
25128 wxUpdateUIMode result;
25129
25130 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25131 {
25132 PyThreadState* __tstate = wxPyBeginAllowThreads();
25133 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 resultobj = SWIG_From_int(static_cast< int >(result));
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25145 PyObject *obj;
25146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25147 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25148 return SWIG_Py_Void();
25149 }
25150
25151 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25152 return SWIG_Python_InitShadowInstance(args);
25153 }
25154
25155 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25156 PyObject *resultobj = 0;
25157 wxSysColourChangedEvent *result = 0 ;
25158
25159 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25163 wxPyEndAllowThreads(__tstate);
25164 if (PyErr_Occurred()) SWIG_fail;
25165 }
25166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25167 return resultobj;
25168 fail:
25169 return NULL;
25170 }
25171
25172
25173 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25174 PyObject *obj;
25175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25176 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25177 return SWIG_Py_Void();
25178 }
25179
25180 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25181 return SWIG_Python_InitShadowInstance(args);
25182 }
25183
25184 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25185 PyObject *resultobj = 0;
25186 int arg1 = (int) 0 ;
25187 wxWindow *arg2 = (wxWindow *) NULL ;
25188 wxMouseCaptureChangedEvent *result = 0 ;
25189 int val1 ;
25190 int ecode1 = 0 ;
25191 void *argp2 = 0 ;
25192 int res2 = 0 ;
25193 PyObject * obj0 = 0 ;
25194 PyObject * obj1 = 0 ;
25195 char * kwnames[] = {
25196 (char *) "winid",(char *) "gainedCapture", NULL
25197 };
25198
25199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25200 if (obj0) {
25201 ecode1 = SWIG_AsVal_int(obj0, &val1);
25202 if (!SWIG_IsOK(ecode1)) {
25203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25204 }
25205 arg1 = static_cast< int >(val1);
25206 }
25207 if (obj1) {
25208 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25209 if (!SWIG_IsOK(res2)) {
25210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25211 }
25212 arg2 = reinterpret_cast< wxWindow * >(argp2);
25213 }
25214 {
25215 PyThreadState* __tstate = wxPyBeginAllowThreads();
25216 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25217 wxPyEndAllowThreads(__tstate);
25218 if (PyErr_Occurred()) SWIG_fail;
25219 }
25220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25221 return resultobj;
25222 fail:
25223 return NULL;
25224 }
25225
25226
25227 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25228 PyObject *resultobj = 0;
25229 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25230 wxWindow *result = 0 ;
25231 void *argp1 = 0 ;
25232 int res1 = 0 ;
25233 PyObject *swig_obj[1] ;
25234
25235 if (!args) SWIG_fail;
25236 swig_obj[0] = args;
25237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25238 if (!SWIG_IsOK(res1)) {
25239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25240 }
25241 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25242 {
25243 PyThreadState* __tstate = wxPyBeginAllowThreads();
25244 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25245 wxPyEndAllowThreads(__tstate);
25246 if (PyErr_Occurred()) SWIG_fail;
25247 }
25248 {
25249 resultobj = wxPyMake_wxObject(result, (bool)0);
25250 }
25251 return resultobj;
25252 fail:
25253 return NULL;
25254 }
25255
25256
25257 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25258 PyObject *obj;
25259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25260 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25261 return SWIG_Py_Void();
25262 }
25263
25264 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25265 return SWIG_Python_InitShadowInstance(args);
25266 }
25267
25268 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25269 PyObject *resultobj = 0;
25270 wxDisplayChangedEvent *result = 0 ;
25271
25272 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25273 {
25274 PyThreadState* __tstate = wxPyBeginAllowThreads();
25275 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25276 wxPyEndAllowThreads(__tstate);
25277 if (PyErr_Occurred()) SWIG_fail;
25278 }
25279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25280 return resultobj;
25281 fail:
25282 return NULL;
25283 }
25284
25285
25286 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25287 PyObject *obj;
25288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25289 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25290 return SWIG_Py_Void();
25291 }
25292
25293 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25294 return SWIG_Python_InitShadowInstance(args);
25295 }
25296
25297 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25298 PyObject *resultobj = 0;
25299 int arg1 = (int) 0 ;
25300 wxPaletteChangedEvent *result = 0 ;
25301 int val1 ;
25302 int ecode1 = 0 ;
25303 PyObject * obj0 = 0 ;
25304 char * kwnames[] = {
25305 (char *) "id", NULL
25306 };
25307
25308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25309 if (obj0) {
25310 ecode1 = SWIG_AsVal_int(obj0, &val1);
25311 if (!SWIG_IsOK(ecode1)) {
25312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25313 }
25314 arg1 = static_cast< int >(val1);
25315 }
25316 {
25317 PyThreadState* __tstate = wxPyBeginAllowThreads();
25318 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25319 wxPyEndAllowThreads(__tstate);
25320 if (PyErr_Occurred()) SWIG_fail;
25321 }
25322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25323 return resultobj;
25324 fail:
25325 return NULL;
25326 }
25327
25328
25329 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25330 PyObject *resultobj = 0;
25331 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25332 wxWindow *arg2 = (wxWindow *) 0 ;
25333 void *argp1 = 0 ;
25334 int res1 = 0 ;
25335 void *argp2 = 0 ;
25336 int res2 = 0 ;
25337 PyObject * obj0 = 0 ;
25338 PyObject * obj1 = 0 ;
25339 char * kwnames[] = {
25340 (char *) "self",(char *) "win", NULL
25341 };
25342
25343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25345 if (!SWIG_IsOK(res1)) {
25346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25347 }
25348 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25349 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25350 if (!SWIG_IsOK(res2)) {
25351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25352 }
25353 arg2 = reinterpret_cast< wxWindow * >(argp2);
25354 {
25355 PyThreadState* __tstate = wxPyBeginAllowThreads();
25356 (arg1)->SetChangedWindow(arg2);
25357 wxPyEndAllowThreads(__tstate);
25358 if (PyErr_Occurred()) SWIG_fail;
25359 }
25360 resultobj = SWIG_Py_Void();
25361 return resultobj;
25362 fail:
25363 return NULL;
25364 }
25365
25366
25367 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25368 PyObject *resultobj = 0;
25369 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25370 wxWindow *result = 0 ;
25371 void *argp1 = 0 ;
25372 int res1 = 0 ;
25373 PyObject *swig_obj[1] ;
25374
25375 if (!args) SWIG_fail;
25376 swig_obj[0] = args;
25377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25378 if (!SWIG_IsOK(res1)) {
25379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25380 }
25381 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25382 {
25383 PyThreadState* __tstate = wxPyBeginAllowThreads();
25384 result = (wxWindow *)(arg1)->GetChangedWindow();
25385 wxPyEndAllowThreads(__tstate);
25386 if (PyErr_Occurred()) SWIG_fail;
25387 }
25388 {
25389 resultobj = wxPyMake_wxObject(result, (bool)0);
25390 }
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25398 PyObject *obj;
25399 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25400 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25401 return SWIG_Py_Void();
25402 }
25403
25404 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25405 return SWIG_Python_InitShadowInstance(args);
25406 }
25407
25408 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25409 PyObject *resultobj = 0;
25410 int arg1 = (int) 0 ;
25411 wxQueryNewPaletteEvent *result = 0 ;
25412 int val1 ;
25413 int ecode1 = 0 ;
25414 PyObject * obj0 = 0 ;
25415 char * kwnames[] = {
25416 (char *) "winid", NULL
25417 };
25418
25419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25420 if (obj0) {
25421 ecode1 = SWIG_AsVal_int(obj0, &val1);
25422 if (!SWIG_IsOK(ecode1)) {
25423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25424 }
25425 arg1 = static_cast< int >(val1);
25426 }
25427 {
25428 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25430 wxPyEndAllowThreads(__tstate);
25431 if (PyErr_Occurred()) SWIG_fail;
25432 }
25433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25434 return resultobj;
25435 fail:
25436 return NULL;
25437 }
25438
25439
25440 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25441 PyObject *resultobj = 0;
25442 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25443 bool arg2 ;
25444 void *argp1 = 0 ;
25445 int res1 = 0 ;
25446 bool val2 ;
25447 int ecode2 = 0 ;
25448 PyObject * obj0 = 0 ;
25449 PyObject * obj1 = 0 ;
25450 char * kwnames[] = {
25451 (char *) "self",(char *) "realized", NULL
25452 };
25453
25454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25456 if (!SWIG_IsOK(res1)) {
25457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25458 }
25459 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25460 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25461 if (!SWIG_IsOK(ecode2)) {
25462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25463 }
25464 arg2 = static_cast< bool >(val2);
25465 {
25466 PyThreadState* __tstate = wxPyBeginAllowThreads();
25467 (arg1)->SetPaletteRealized(arg2);
25468 wxPyEndAllowThreads(__tstate);
25469 if (PyErr_Occurred()) SWIG_fail;
25470 }
25471 resultobj = SWIG_Py_Void();
25472 return resultobj;
25473 fail:
25474 return NULL;
25475 }
25476
25477
25478 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25479 PyObject *resultobj = 0;
25480 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25481 bool result;
25482 void *argp1 = 0 ;
25483 int res1 = 0 ;
25484 PyObject *swig_obj[1] ;
25485
25486 if (!args) SWIG_fail;
25487 swig_obj[0] = args;
25488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25489 if (!SWIG_IsOK(res1)) {
25490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25491 }
25492 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25493 {
25494 PyThreadState* __tstate = wxPyBeginAllowThreads();
25495 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25496 wxPyEndAllowThreads(__tstate);
25497 if (PyErr_Occurred()) SWIG_fail;
25498 }
25499 {
25500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25501 }
25502 return resultobj;
25503 fail:
25504 return NULL;
25505 }
25506
25507
25508 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25509 PyObject *obj;
25510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25511 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25512 return SWIG_Py_Void();
25513 }
25514
25515 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25516 return SWIG_Python_InitShadowInstance(args);
25517 }
25518
25519 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25520 PyObject *resultobj = 0;
25521 wxNavigationKeyEvent *result = 0 ;
25522
25523 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25524 {
25525 PyThreadState* __tstate = wxPyBeginAllowThreads();
25526 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25527 wxPyEndAllowThreads(__tstate);
25528 if (PyErr_Occurred()) SWIG_fail;
25529 }
25530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25531 return resultobj;
25532 fail:
25533 return NULL;
25534 }
25535
25536
25537 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25538 PyObject *resultobj = 0;
25539 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25540 bool result;
25541 void *argp1 = 0 ;
25542 int res1 = 0 ;
25543 PyObject *swig_obj[1] ;
25544
25545 if (!args) SWIG_fail;
25546 swig_obj[0] = args;
25547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25548 if (!SWIG_IsOK(res1)) {
25549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25550 }
25551 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25552 {
25553 PyThreadState* __tstate = wxPyBeginAllowThreads();
25554 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25555 wxPyEndAllowThreads(__tstate);
25556 if (PyErr_Occurred()) SWIG_fail;
25557 }
25558 {
25559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25560 }
25561 return resultobj;
25562 fail:
25563 return NULL;
25564 }
25565
25566
25567 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25568 PyObject *resultobj = 0;
25569 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25570 bool arg2 ;
25571 void *argp1 = 0 ;
25572 int res1 = 0 ;
25573 bool val2 ;
25574 int ecode2 = 0 ;
25575 PyObject * obj0 = 0 ;
25576 PyObject * obj1 = 0 ;
25577 char * kwnames[] = {
25578 (char *) "self",(char *) "forward", NULL
25579 };
25580
25581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25583 if (!SWIG_IsOK(res1)) {
25584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25585 }
25586 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25587 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25588 if (!SWIG_IsOK(ecode2)) {
25589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25590 }
25591 arg2 = static_cast< bool >(val2);
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 (arg1)->SetDirection(arg2);
25595 wxPyEndAllowThreads(__tstate);
25596 if (PyErr_Occurred()) SWIG_fail;
25597 }
25598 resultobj = SWIG_Py_Void();
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25606 PyObject *resultobj = 0;
25607 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25608 bool result;
25609 void *argp1 = 0 ;
25610 int res1 = 0 ;
25611 PyObject *swig_obj[1] ;
25612
25613 if (!args) SWIG_fail;
25614 swig_obj[0] = args;
25615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25616 if (!SWIG_IsOK(res1)) {
25617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25618 }
25619 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25620 {
25621 PyThreadState* __tstate = wxPyBeginAllowThreads();
25622 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25623 wxPyEndAllowThreads(__tstate);
25624 if (PyErr_Occurred()) SWIG_fail;
25625 }
25626 {
25627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25628 }
25629 return resultobj;
25630 fail:
25631 return NULL;
25632 }
25633
25634
25635 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25636 PyObject *resultobj = 0;
25637 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25638 bool arg2 ;
25639 void *argp1 = 0 ;
25640 int res1 = 0 ;
25641 bool val2 ;
25642 int ecode2 = 0 ;
25643 PyObject * obj0 = 0 ;
25644 PyObject * obj1 = 0 ;
25645 char * kwnames[] = {
25646 (char *) "self",(char *) "ischange", NULL
25647 };
25648
25649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25651 if (!SWIG_IsOK(res1)) {
25652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25653 }
25654 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25655 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25656 if (!SWIG_IsOK(ecode2)) {
25657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25658 }
25659 arg2 = static_cast< bool >(val2);
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 (arg1)->SetWindowChange(arg2);
25663 wxPyEndAllowThreads(__tstate);
25664 if (PyErr_Occurred()) SWIG_fail;
25665 }
25666 resultobj = SWIG_Py_Void();
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25676 bool result;
25677 void *argp1 = 0 ;
25678 int res1 = 0 ;
25679 PyObject *swig_obj[1] ;
25680
25681 if (!args) SWIG_fail;
25682 swig_obj[0] = args;
25683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25684 if (!SWIG_IsOK(res1)) {
25685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25686 }
25687 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 {
25695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25696 }
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25704 PyObject *resultobj = 0;
25705 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25706 bool arg2 ;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 bool val2 ;
25710 int ecode2 = 0 ;
25711 PyObject * obj0 = 0 ;
25712 PyObject * obj1 = 0 ;
25713 char * kwnames[] = {
25714 (char *) "self",(char *) "bIs", NULL
25715 };
25716
25717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25719 if (!SWIG_IsOK(res1)) {
25720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25721 }
25722 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25724 if (!SWIG_IsOK(ecode2)) {
25725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25726 }
25727 arg2 = static_cast< bool >(val2);
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 (arg1)->SetFromTab(arg2);
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 resultobj = SWIG_Py_Void();
25735 return resultobj;
25736 fail:
25737 return NULL;
25738 }
25739
25740
25741 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25742 PyObject *resultobj = 0;
25743 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25744 long arg2 ;
25745 void *argp1 = 0 ;
25746 int res1 = 0 ;
25747 long val2 ;
25748 int ecode2 = 0 ;
25749 PyObject * obj0 = 0 ;
25750 PyObject * obj1 = 0 ;
25751 char * kwnames[] = {
25752 (char *) "self",(char *) "flags", NULL
25753 };
25754
25755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25757 if (!SWIG_IsOK(res1)) {
25758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25759 }
25760 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25761 ecode2 = SWIG_AsVal_long(obj1, &val2);
25762 if (!SWIG_IsOK(ecode2)) {
25763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25764 }
25765 arg2 = static_cast< long >(val2);
25766 {
25767 PyThreadState* __tstate = wxPyBeginAllowThreads();
25768 (arg1)->SetFlags(arg2);
25769 wxPyEndAllowThreads(__tstate);
25770 if (PyErr_Occurred()) SWIG_fail;
25771 }
25772 resultobj = SWIG_Py_Void();
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25780 PyObject *resultobj = 0;
25781 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25782 wxWindow *result = 0 ;
25783 void *argp1 = 0 ;
25784 int res1 = 0 ;
25785 PyObject *swig_obj[1] ;
25786
25787 if (!args) SWIG_fail;
25788 swig_obj[0] = args;
25789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25790 if (!SWIG_IsOK(res1)) {
25791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25792 }
25793 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25794 {
25795 PyThreadState* __tstate = wxPyBeginAllowThreads();
25796 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25797 wxPyEndAllowThreads(__tstate);
25798 if (PyErr_Occurred()) SWIG_fail;
25799 }
25800 {
25801 resultobj = wxPyMake_wxObject(result, (bool)0);
25802 }
25803 return resultobj;
25804 fail:
25805 return NULL;
25806 }
25807
25808
25809 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25810 PyObject *resultobj = 0;
25811 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25812 wxWindow *arg2 = (wxWindow *) 0 ;
25813 void *argp1 = 0 ;
25814 int res1 = 0 ;
25815 void *argp2 = 0 ;
25816 int res2 = 0 ;
25817 PyObject * obj0 = 0 ;
25818 PyObject * obj1 = 0 ;
25819 char * kwnames[] = {
25820 (char *) "self",(char *) "win", NULL
25821 };
25822
25823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25825 if (!SWIG_IsOK(res1)) {
25826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25827 }
25828 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25830 if (!SWIG_IsOK(res2)) {
25831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25832 }
25833 arg2 = reinterpret_cast< wxWindow * >(argp2);
25834 {
25835 PyThreadState* __tstate = wxPyBeginAllowThreads();
25836 (arg1)->SetCurrentFocus(arg2);
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 resultobj = SWIG_Py_Void();
25841 return resultobj;
25842 fail:
25843 return NULL;
25844 }
25845
25846
25847 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25848 PyObject *obj;
25849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25850 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25851 return SWIG_Py_Void();
25852 }
25853
25854 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25855 return SWIG_Python_InitShadowInstance(args);
25856 }
25857
25858 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25859 PyObject *resultobj = 0;
25860 wxWindow *arg1 = (wxWindow *) NULL ;
25861 wxWindowCreateEvent *result = 0 ;
25862 void *argp1 = 0 ;
25863 int res1 = 0 ;
25864 PyObject * obj0 = 0 ;
25865 char * kwnames[] = {
25866 (char *) "win", NULL
25867 };
25868
25869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25870 if (obj0) {
25871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25872 if (!SWIG_IsOK(res1)) {
25873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25874 }
25875 arg1 = reinterpret_cast< wxWindow * >(argp1);
25876 }
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25884 return resultobj;
25885 fail:
25886 return NULL;
25887 }
25888
25889
25890 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25891 PyObject *resultobj = 0;
25892 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25893 wxWindow *result = 0 ;
25894 void *argp1 = 0 ;
25895 int res1 = 0 ;
25896 PyObject *swig_obj[1] ;
25897
25898 if (!args) SWIG_fail;
25899 swig_obj[0] = args;
25900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25901 if (!SWIG_IsOK(res1)) {
25902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25903 }
25904 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 {
25912 resultobj = wxPyMake_wxObject(result, (bool)0);
25913 }
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25921 PyObject *obj;
25922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25923 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25924 return SWIG_Py_Void();
25925 }
25926
25927 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25928 return SWIG_Python_InitShadowInstance(args);
25929 }
25930
25931 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25932 PyObject *resultobj = 0;
25933 wxWindow *arg1 = (wxWindow *) NULL ;
25934 wxWindowDestroyEvent *result = 0 ;
25935 void *argp1 = 0 ;
25936 int res1 = 0 ;
25937 PyObject * obj0 = 0 ;
25938 char * kwnames[] = {
25939 (char *) "win", NULL
25940 };
25941
25942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25943 if (obj0) {
25944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25945 if (!SWIG_IsOK(res1)) {
25946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25947 }
25948 arg1 = reinterpret_cast< wxWindow * >(argp1);
25949 }
25950 {
25951 PyThreadState* __tstate = wxPyBeginAllowThreads();
25952 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
25953 wxPyEndAllowThreads(__tstate);
25954 if (PyErr_Occurred()) SWIG_fail;
25955 }
25956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
25957 return resultobj;
25958 fail:
25959 return NULL;
25960 }
25961
25962
25963 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25964 PyObject *resultobj = 0;
25965 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
25966 wxWindow *result = 0 ;
25967 void *argp1 = 0 ;
25968 int res1 = 0 ;
25969 PyObject *swig_obj[1] ;
25970
25971 if (!args) SWIG_fail;
25972 swig_obj[0] = args;
25973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
25974 if (!SWIG_IsOK(res1)) {
25975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
25976 }
25977 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
25978 {
25979 PyThreadState* __tstate = wxPyBeginAllowThreads();
25980 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
25981 wxPyEndAllowThreads(__tstate);
25982 if (PyErr_Occurred()) SWIG_fail;
25983 }
25984 {
25985 resultobj = wxPyMake_wxObject(result, (bool)0);
25986 }
25987 return resultobj;
25988 fail:
25989 return NULL;
25990 }
25991
25992
25993 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25994 PyObject *obj;
25995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25996 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
25997 return SWIG_Py_Void();
25998 }
25999
26000 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26001 return SWIG_Python_InitShadowInstance(args);
26002 }
26003
26004 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26005 PyObject *resultobj = 0;
26006 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26007 int arg2 = (int) 0 ;
26008 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26009 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26010 wxContextMenuEvent *result = 0 ;
26011 int val1 ;
26012 int ecode1 = 0 ;
26013 int val2 ;
26014 int ecode2 = 0 ;
26015 wxPoint temp3 ;
26016 PyObject * obj0 = 0 ;
26017 PyObject * obj1 = 0 ;
26018 PyObject * obj2 = 0 ;
26019 char * kwnames[] = {
26020 (char *) "type",(char *) "winid",(char *) "pt", NULL
26021 };
26022
26023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26024 if (obj0) {
26025 ecode1 = SWIG_AsVal_int(obj0, &val1);
26026 if (!SWIG_IsOK(ecode1)) {
26027 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26028 }
26029 arg1 = static_cast< wxEventType >(val1);
26030 }
26031 if (obj1) {
26032 ecode2 = SWIG_AsVal_int(obj1, &val2);
26033 if (!SWIG_IsOK(ecode2)) {
26034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26035 }
26036 arg2 = static_cast< int >(val2);
26037 }
26038 if (obj2) {
26039 {
26040 arg3 = &temp3;
26041 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26042 }
26043 }
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26058 PyObject *resultobj = 0;
26059 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26060 wxPoint *result = 0 ;
26061 void *argp1 = 0 ;
26062 int res1 = 0 ;
26063 PyObject *swig_obj[1] ;
26064
26065 if (!args) SWIG_fail;
26066 swig_obj[0] = args;
26067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26068 if (!SWIG_IsOK(res1)) {
26069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26070 }
26071 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26072 {
26073 PyThreadState* __tstate = wxPyBeginAllowThreads();
26074 {
26075 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26076 result = (wxPoint *) &_result_ref;
26077 }
26078 wxPyEndAllowThreads(__tstate);
26079 if (PyErr_Occurred()) SWIG_fail;
26080 }
26081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26082 return resultobj;
26083 fail:
26084 return NULL;
26085 }
26086
26087
26088 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26089 PyObject *resultobj = 0;
26090 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26091 wxPoint *arg2 = 0 ;
26092 void *argp1 = 0 ;
26093 int res1 = 0 ;
26094 wxPoint temp2 ;
26095 PyObject * obj0 = 0 ;
26096 PyObject * obj1 = 0 ;
26097 char * kwnames[] = {
26098 (char *) "self",(char *) "pos", NULL
26099 };
26100
26101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26103 if (!SWIG_IsOK(res1)) {
26104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26105 }
26106 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26107 {
26108 arg2 = &temp2;
26109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26110 }
26111 {
26112 PyThreadState* __tstate = wxPyBeginAllowThreads();
26113 (arg1)->SetPosition((wxPoint const &)*arg2);
26114 wxPyEndAllowThreads(__tstate);
26115 if (PyErr_Occurred()) SWIG_fail;
26116 }
26117 resultobj = SWIG_Py_Void();
26118 return resultobj;
26119 fail:
26120 return NULL;
26121 }
26122
26123
26124 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26125 PyObject *obj;
26126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26127 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26128 return SWIG_Py_Void();
26129 }
26130
26131 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26132 return SWIG_Python_InitShadowInstance(args);
26133 }
26134
26135 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26136 PyObject *resultobj = 0;
26137 wxIdleEvent *result = 0 ;
26138
26139 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 result = (wxIdleEvent *)new wxIdleEvent();
26143 wxPyEndAllowThreads(__tstate);
26144 if (PyErr_Occurred()) SWIG_fail;
26145 }
26146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26154 PyObject *resultobj = 0;
26155 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26156 bool arg2 = (bool) true ;
26157 void *argp1 = 0 ;
26158 int res1 = 0 ;
26159 bool val2 ;
26160 int ecode2 = 0 ;
26161 PyObject * obj0 = 0 ;
26162 PyObject * obj1 = 0 ;
26163 char * kwnames[] = {
26164 (char *) "self",(char *) "needMore", NULL
26165 };
26166
26167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26169 if (!SWIG_IsOK(res1)) {
26170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26171 }
26172 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26173 if (obj1) {
26174 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26175 if (!SWIG_IsOK(ecode2)) {
26176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26177 }
26178 arg2 = static_cast< bool >(val2);
26179 }
26180 {
26181 PyThreadState* __tstate = wxPyBeginAllowThreads();
26182 (arg1)->RequestMore(arg2);
26183 wxPyEndAllowThreads(__tstate);
26184 if (PyErr_Occurred()) SWIG_fail;
26185 }
26186 resultobj = SWIG_Py_Void();
26187 return resultobj;
26188 fail:
26189 return NULL;
26190 }
26191
26192
26193 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26194 PyObject *resultobj = 0;
26195 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26196 bool result;
26197 void *argp1 = 0 ;
26198 int res1 = 0 ;
26199 PyObject *swig_obj[1] ;
26200
26201 if (!args) SWIG_fail;
26202 swig_obj[0] = args;
26203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26204 if (!SWIG_IsOK(res1)) {
26205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26206 }
26207 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 {
26215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26216 }
26217 return resultobj;
26218 fail:
26219 return NULL;
26220 }
26221
26222
26223 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26224 PyObject *resultobj = 0;
26225 wxIdleMode arg1 ;
26226 int val1 ;
26227 int ecode1 = 0 ;
26228 PyObject * obj0 = 0 ;
26229 char * kwnames[] = {
26230 (char *) "mode", NULL
26231 };
26232
26233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26234 ecode1 = SWIG_AsVal_int(obj0, &val1);
26235 if (!SWIG_IsOK(ecode1)) {
26236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26237 }
26238 arg1 = static_cast< wxIdleMode >(val1);
26239 {
26240 PyThreadState* __tstate = wxPyBeginAllowThreads();
26241 wxIdleEvent::SetMode(arg1);
26242 wxPyEndAllowThreads(__tstate);
26243 if (PyErr_Occurred()) SWIG_fail;
26244 }
26245 resultobj = SWIG_Py_Void();
26246 return resultobj;
26247 fail:
26248 return NULL;
26249 }
26250
26251
26252 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26253 PyObject *resultobj = 0;
26254 wxIdleMode result;
26255
26256 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26257 {
26258 PyThreadState* __tstate = wxPyBeginAllowThreads();
26259 result = (wxIdleMode)wxIdleEvent::GetMode();
26260 wxPyEndAllowThreads(__tstate);
26261 if (PyErr_Occurred()) SWIG_fail;
26262 }
26263 resultobj = SWIG_From_int(static_cast< int >(result));
26264 return resultobj;
26265 fail:
26266 return NULL;
26267 }
26268
26269
26270 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26271 PyObject *resultobj = 0;
26272 wxWindow *arg1 = (wxWindow *) 0 ;
26273 bool result;
26274 void *argp1 = 0 ;
26275 int res1 = 0 ;
26276 PyObject * obj0 = 0 ;
26277 char * kwnames[] = {
26278 (char *) "win", NULL
26279 };
26280
26281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26283 if (!SWIG_IsOK(res1)) {
26284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26285 }
26286 arg1 = reinterpret_cast< wxWindow * >(argp1);
26287 {
26288 PyThreadState* __tstate = wxPyBeginAllowThreads();
26289 result = (bool)wxIdleEvent::CanSend(arg1);
26290 wxPyEndAllowThreads(__tstate);
26291 if (PyErr_Occurred()) SWIG_fail;
26292 }
26293 {
26294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26295 }
26296 return resultobj;
26297 fail:
26298 return NULL;
26299 }
26300
26301
26302 SWIGINTERN PyObject *IdleEvent_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_wxIdleEvent, SWIG_NewClientData(obj));
26306 return SWIG_Py_Void();
26307 }
26308
26309 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26310 return SWIG_Python_InitShadowInstance(args);
26311 }
26312
26313 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26314 PyObject *resultobj = 0;
26315 int arg1 = (int) 0 ;
26316 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26317 wxPyEvent *result = 0 ;
26318 int val1 ;
26319 int ecode1 = 0 ;
26320 int val2 ;
26321 int ecode2 = 0 ;
26322 PyObject * obj0 = 0 ;
26323 PyObject * obj1 = 0 ;
26324 char * kwnames[] = {
26325 (char *) "winid",(char *) "eventType", NULL
26326 };
26327
26328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26329 if (obj0) {
26330 ecode1 = SWIG_AsVal_int(obj0, &val1);
26331 if (!SWIG_IsOK(ecode1)) {
26332 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26333 }
26334 arg1 = static_cast< int >(val1);
26335 }
26336 if (obj1) {
26337 ecode2 = SWIG_AsVal_int(obj1, &val2);
26338 if (!SWIG_IsOK(ecode2)) {
26339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26340 }
26341 arg2 = static_cast< wxEventType >(val2);
26342 }
26343 {
26344 PyThreadState* __tstate = wxPyBeginAllowThreads();
26345 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26346 wxPyEndAllowThreads(__tstate);
26347 if (PyErr_Occurred()) SWIG_fail;
26348 }
26349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26350 return resultobj;
26351 fail:
26352 return NULL;
26353 }
26354
26355
26356 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26357 PyObject *resultobj = 0;
26358 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26359 void *argp1 = 0 ;
26360 int res1 = 0 ;
26361 PyObject *swig_obj[1] ;
26362
26363 if (!args) SWIG_fail;
26364 swig_obj[0] = args;
26365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26366 if (!SWIG_IsOK(res1)) {
26367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26368 }
26369 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26370 {
26371 PyThreadState* __tstate = wxPyBeginAllowThreads();
26372 delete arg1;
26373
26374 wxPyEndAllowThreads(__tstate);
26375 if (PyErr_Occurred()) SWIG_fail;
26376 }
26377 resultobj = SWIG_Py_Void();
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26385 PyObject *resultobj = 0;
26386 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26387 PyObject *arg2 = (PyObject *) 0 ;
26388 void *argp1 = 0 ;
26389 int res1 = 0 ;
26390 PyObject * obj0 = 0 ;
26391 PyObject * obj1 = 0 ;
26392 char * kwnames[] = {
26393 (char *) "self",(char *) "self", NULL
26394 };
26395
26396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26398 if (!SWIG_IsOK(res1)) {
26399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26400 }
26401 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26402 arg2 = obj1;
26403 {
26404 PyThreadState* __tstate = wxPyBeginAllowThreads();
26405 (arg1)->SetSelf(arg2);
26406 wxPyEndAllowThreads(__tstate);
26407 if (PyErr_Occurred()) SWIG_fail;
26408 }
26409 resultobj = SWIG_Py_Void();
26410 return resultobj;
26411 fail:
26412 return NULL;
26413 }
26414
26415
26416 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26417 PyObject *resultobj = 0;
26418 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26419 PyObject *result = 0 ;
26420 void *argp1 = 0 ;
26421 int res1 = 0 ;
26422 PyObject *swig_obj[1] ;
26423
26424 if (!args) SWIG_fail;
26425 swig_obj[0] = args;
26426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26427 if (!SWIG_IsOK(res1)) {
26428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26429 }
26430 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26431 {
26432 PyThreadState* __tstate = wxPyBeginAllowThreads();
26433 result = (PyObject *)(arg1)->GetSelf();
26434 wxPyEndAllowThreads(__tstate);
26435 if (PyErr_Occurred()) SWIG_fail;
26436 }
26437 resultobj = result;
26438 return resultobj;
26439 fail:
26440 return NULL;
26441 }
26442
26443
26444 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26445 PyObject *obj;
26446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26447 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26448 return SWIG_Py_Void();
26449 }
26450
26451 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26452 return SWIG_Python_InitShadowInstance(args);
26453 }
26454
26455 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26456 PyObject *resultobj = 0;
26457 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26458 int arg2 = (int) 0 ;
26459 wxPyCommandEvent *result = 0 ;
26460 int val1 ;
26461 int ecode1 = 0 ;
26462 int val2 ;
26463 int ecode2 = 0 ;
26464 PyObject * obj0 = 0 ;
26465 PyObject * obj1 = 0 ;
26466 char * kwnames[] = {
26467 (char *) "eventType",(char *) "id", NULL
26468 };
26469
26470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26471 if (obj0) {
26472 ecode1 = SWIG_AsVal_int(obj0, &val1);
26473 if (!SWIG_IsOK(ecode1)) {
26474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26475 }
26476 arg1 = static_cast< wxEventType >(val1);
26477 }
26478 if (obj1) {
26479 ecode2 = SWIG_AsVal_int(obj1, &val2);
26480 if (!SWIG_IsOK(ecode2)) {
26481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26482 }
26483 arg2 = static_cast< int >(val2);
26484 }
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26488 wxPyEndAllowThreads(__tstate);
26489 if (PyErr_Occurred()) SWIG_fail;
26490 }
26491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26492 return resultobj;
26493 fail:
26494 return NULL;
26495 }
26496
26497
26498 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26499 PyObject *resultobj = 0;
26500 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26501 void *argp1 = 0 ;
26502 int res1 = 0 ;
26503 PyObject *swig_obj[1] ;
26504
26505 if (!args) SWIG_fail;
26506 swig_obj[0] = args;
26507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26508 if (!SWIG_IsOK(res1)) {
26509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26510 }
26511 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26512 {
26513 PyThreadState* __tstate = wxPyBeginAllowThreads();
26514 delete arg1;
26515
26516 wxPyEndAllowThreads(__tstate);
26517 if (PyErr_Occurred()) SWIG_fail;
26518 }
26519 resultobj = SWIG_Py_Void();
26520 return resultobj;
26521 fail:
26522 return NULL;
26523 }
26524
26525
26526 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26527 PyObject *resultobj = 0;
26528 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26529 PyObject *arg2 = (PyObject *) 0 ;
26530 void *argp1 = 0 ;
26531 int res1 = 0 ;
26532 PyObject * obj0 = 0 ;
26533 PyObject * obj1 = 0 ;
26534 char * kwnames[] = {
26535 (char *) "self",(char *) "self", NULL
26536 };
26537
26538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26540 if (!SWIG_IsOK(res1)) {
26541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26542 }
26543 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26544 arg2 = obj1;
26545 {
26546 PyThreadState* __tstate = wxPyBeginAllowThreads();
26547 (arg1)->SetSelf(arg2);
26548 wxPyEndAllowThreads(__tstate);
26549 if (PyErr_Occurred()) SWIG_fail;
26550 }
26551 resultobj = SWIG_Py_Void();
26552 return resultobj;
26553 fail:
26554 return NULL;
26555 }
26556
26557
26558 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26559 PyObject *resultobj = 0;
26560 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26561 PyObject *result = 0 ;
26562 void *argp1 = 0 ;
26563 int res1 = 0 ;
26564 PyObject *swig_obj[1] ;
26565
26566 if (!args) SWIG_fail;
26567 swig_obj[0] = args;
26568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26569 if (!SWIG_IsOK(res1)) {
26570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26571 }
26572 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 result = (PyObject *)(arg1)->GetSelf();
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 resultobj = result;
26580 return resultobj;
26581 fail:
26582 return NULL;
26583 }
26584
26585
26586 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26587 PyObject *obj;
26588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26589 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26590 return SWIG_Py_Void();
26591 }
26592
26593 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26594 return SWIG_Python_InitShadowInstance(args);
26595 }
26596
26597 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26598 PyObject *resultobj = 0;
26599 wxWindow *arg1 = (wxWindow *) 0 ;
26600 wxDateTime *arg2 = 0 ;
26601 wxEventType arg3 ;
26602 wxDateEvent *result = 0 ;
26603 void *argp1 = 0 ;
26604 int res1 = 0 ;
26605 void *argp2 = 0 ;
26606 int res2 = 0 ;
26607 int val3 ;
26608 int ecode3 = 0 ;
26609 PyObject * obj0 = 0 ;
26610 PyObject * obj1 = 0 ;
26611 PyObject * obj2 = 0 ;
26612 char * kwnames[] = {
26613 (char *) "win",(char *) "dt",(char *) "type", NULL
26614 };
26615
26616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26618 if (!SWIG_IsOK(res1)) {
26619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26620 }
26621 arg1 = reinterpret_cast< wxWindow * >(argp1);
26622 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26623 if (!SWIG_IsOK(res2)) {
26624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26625 }
26626 if (!argp2) {
26627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26628 }
26629 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26630 ecode3 = SWIG_AsVal_int(obj2, &val3);
26631 if (!SWIG_IsOK(ecode3)) {
26632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26633 }
26634 arg3 = static_cast< wxEventType >(val3);
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26638 wxPyEndAllowThreads(__tstate);
26639 if (PyErr_Occurred()) SWIG_fail;
26640 }
26641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26642 return resultobj;
26643 fail:
26644 return NULL;
26645 }
26646
26647
26648 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26649 PyObject *resultobj = 0;
26650 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26651 wxDateTime *result = 0 ;
26652 void *argp1 = 0 ;
26653 int res1 = 0 ;
26654 PyObject *swig_obj[1] ;
26655
26656 if (!args) SWIG_fail;
26657 swig_obj[0] = args;
26658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26659 if (!SWIG_IsOK(res1)) {
26660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26661 }
26662 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26663 {
26664 PyThreadState* __tstate = wxPyBeginAllowThreads();
26665 {
26666 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26667 result = (wxDateTime *) &_result_ref;
26668 }
26669 wxPyEndAllowThreads(__tstate);
26670 if (PyErr_Occurred()) SWIG_fail;
26671 }
26672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj = 0;
26681 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26682 wxDateTime *arg2 = 0 ;
26683 void *argp1 = 0 ;
26684 int res1 = 0 ;
26685 void *argp2 = 0 ;
26686 int res2 = 0 ;
26687 PyObject * obj0 = 0 ;
26688 PyObject * obj1 = 0 ;
26689 char * kwnames[] = {
26690 (char *) "self",(char *) "date", NULL
26691 };
26692
26693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26695 if (!SWIG_IsOK(res1)) {
26696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26697 }
26698 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26699 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26700 if (!SWIG_IsOK(res2)) {
26701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26702 }
26703 if (!argp2) {
26704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26705 }
26706 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26707 {
26708 PyThreadState* __tstate = wxPyBeginAllowThreads();
26709 (arg1)->SetDate((wxDateTime const &)*arg2);
26710 wxPyEndAllowThreads(__tstate);
26711 if (PyErr_Occurred()) SWIG_fail;
26712 }
26713 resultobj = SWIG_Py_Void();
26714 return resultobj;
26715 fail:
26716 return NULL;
26717 }
26718
26719
26720 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26721 PyObject *obj;
26722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26723 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26724 return SWIG_Py_Void();
26725 }
26726
26727 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26728 return SWIG_Python_InitShadowInstance(args);
26729 }
26730
26731 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26732 PyObject *resultobj = 0;
26733 wxPyApp *result = 0 ;
26734
26735 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26736 {
26737 PyThreadState* __tstate = wxPyBeginAllowThreads();
26738 result = (wxPyApp *)new_wxPyApp();
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26743 return resultobj;
26744 fail:
26745 return NULL;
26746 }
26747
26748
26749 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26750 PyObject *resultobj = 0;
26751 wxPyApp *arg1 = (wxPyApp *) 0 ;
26752 void *argp1 = 0 ;
26753 int res1 = 0 ;
26754 PyObject *swig_obj[1] ;
26755
26756 if (!args) SWIG_fail;
26757 swig_obj[0] = args;
26758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26759 if (!SWIG_IsOK(res1)) {
26760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26761 }
26762 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26763 {
26764 PyThreadState* __tstate = wxPyBeginAllowThreads();
26765 delete arg1;
26766
26767 wxPyEndAllowThreads(__tstate);
26768 if (PyErr_Occurred()) SWIG_fail;
26769 }
26770 resultobj = SWIG_Py_Void();
26771 return resultobj;
26772 fail:
26773 return NULL;
26774 }
26775
26776
26777 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26778 PyObject *resultobj = 0;
26779 wxPyApp *arg1 = (wxPyApp *) 0 ;
26780 PyObject *arg2 = (PyObject *) 0 ;
26781 PyObject *arg3 = (PyObject *) 0 ;
26782 bool arg4 ;
26783 void *argp1 = 0 ;
26784 int res1 = 0 ;
26785 bool val4 ;
26786 int ecode4 = 0 ;
26787 PyObject * obj0 = 0 ;
26788 PyObject * obj1 = 0 ;
26789 PyObject * obj2 = 0 ;
26790 PyObject * obj3 = 0 ;
26791 char * kwnames[] = {
26792 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26793 };
26794
26795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26797 if (!SWIG_IsOK(res1)) {
26798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26799 }
26800 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26801 arg2 = obj1;
26802 arg3 = obj2;
26803 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26804 if (!SWIG_IsOK(ecode4)) {
26805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26806 }
26807 arg4 = static_cast< bool >(val4);
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26811 wxPyEndAllowThreads(__tstate);
26812 if (PyErr_Occurred()) SWIG_fail;
26813 }
26814 resultobj = SWIG_Py_Void();
26815 return resultobj;
26816 fail:
26817 return NULL;
26818 }
26819
26820
26821 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26822 PyObject *resultobj = 0;
26823 wxPyApp *arg1 = (wxPyApp *) 0 ;
26824 wxString result;
26825 void *argp1 = 0 ;
26826 int res1 = 0 ;
26827 PyObject *swig_obj[1] ;
26828
26829 if (!args) SWIG_fail;
26830 swig_obj[0] = args;
26831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26832 if (!SWIG_IsOK(res1)) {
26833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26834 }
26835 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26836 {
26837 PyThreadState* __tstate = wxPyBeginAllowThreads();
26838 result = ((wxPyApp const *)arg1)->GetAppName();
26839 wxPyEndAllowThreads(__tstate);
26840 if (PyErr_Occurred()) SWIG_fail;
26841 }
26842 {
26843 #if wxUSE_UNICODE
26844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26845 #else
26846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26847 #endif
26848 }
26849 return resultobj;
26850 fail:
26851 return NULL;
26852 }
26853
26854
26855 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26856 PyObject *resultobj = 0;
26857 wxPyApp *arg1 = (wxPyApp *) 0 ;
26858 wxString *arg2 = 0 ;
26859 void *argp1 = 0 ;
26860 int res1 = 0 ;
26861 bool temp2 = false ;
26862 PyObject * obj0 = 0 ;
26863 PyObject * obj1 = 0 ;
26864 char * kwnames[] = {
26865 (char *) "self",(char *) "name", NULL
26866 };
26867
26868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26870 if (!SWIG_IsOK(res1)) {
26871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26872 }
26873 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26874 {
26875 arg2 = wxString_in_helper(obj1);
26876 if (arg2 == NULL) SWIG_fail;
26877 temp2 = true;
26878 }
26879 {
26880 PyThreadState* __tstate = wxPyBeginAllowThreads();
26881 (arg1)->SetAppName((wxString const &)*arg2);
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 resultobj = SWIG_Py_Void();
26886 {
26887 if (temp2)
26888 delete arg2;
26889 }
26890 return resultobj;
26891 fail:
26892 {
26893 if (temp2)
26894 delete arg2;
26895 }
26896 return NULL;
26897 }
26898
26899
26900 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26901 PyObject *resultobj = 0;
26902 wxPyApp *arg1 = (wxPyApp *) 0 ;
26903 wxString result;
26904 void *argp1 = 0 ;
26905 int res1 = 0 ;
26906 PyObject *swig_obj[1] ;
26907
26908 if (!args) SWIG_fail;
26909 swig_obj[0] = args;
26910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26911 if (!SWIG_IsOK(res1)) {
26912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26913 }
26914 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 result = ((wxPyApp const *)arg1)->GetClassName();
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 {
26922 #if wxUSE_UNICODE
26923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26924 #else
26925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26926 #endif
26927 }
26928 return resultobj;
26929 fail:
26930 return NULL;
26931 }
26932
26933
26934 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26935 PyObject *resultobj = 0;
26936 wxPyApp *arg1 = (wxPyApp *) 0 ;
26937 wxString *arg2 = 0 ;
26938 void *argp1 = 0 ;
26939 int res1 = 0 ;
26940 bool temp2 = false ;
26941 PyObject * obj0 = 0 ;
26942 PyObject * obj1 = 0 ;
26943 char * kwnames[] = {
26944 (char *) "self",(char *) "name", NULL
26945 };
26946
26947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26949 if (!SWIG_IsOK(res1)) {
26950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26951 }
26952 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26953 {
26954 arg2 = wxString_in_helper(obj1);
26955 if (arg2 == NULL) SWIG_fail;
26956 temp2 = true;
26957 }
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 (arg1)->SetClassName((wxString const &)*arg2);
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 resultobj = SWIG_Py_Void();
26965 {
26966 if (temp2)
26967 delete arg2;
26968 }
26969 return resultobj;
26970 fail:
26971 {
26972 if (temp2)
26973 delete arg2;
26974 }
26975 return NULL;
26976 }
26977
26978
26979 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26980 PyObject *resultobj = 0;
26981 wxPyApp *arg1 = (wxPyApp *) 0 ;
26982 wxString *result = 0 ;
26983 void *argp1 = 0 ;
26984 int res1 = 0 ;
26985 PyObject *swig_obj[1] ;
26986
26987 if (!args) SWIG_fail;
26988 swig_obj[0] = args;
26989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26990 if (!SWIG_IsOK(res1)) {
26991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26992 }
26993 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26994 {
26995 PyThreadState* __tstate = wxPyBeginAllowThreads();
26996 {
26997 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
26998 result = (wxString *) &_result_ref;
26999 }
27000 wxPyEndAllowThreads(__tstate);
27001 if (PyErr_Occurred()) SWIG_fail;
27002 }
27003 {
27004 #if wxUSE_UNICODE
27005 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27006 #else
27007 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27008 #endif
27009 }
27010 return resultobj;
27011 fail:
27012 return NULL;
27013 }
27014
27015
27016 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27017 PyObject *resultobj = 0;
27018 wxPyApp *arg1 = (wxPyApp *) 0 ;
27019 wxString *arg2 = 0 ;
27020 void *argp1 = 0 ;
27021 int res1 = 0 ;
27022 bool temp2 = false ;
27023 PyObject * obj0 = 0 ;
27024 PyObject * obj1 = 0 ;
27025 char * kwnames[] = {
27026 (char *) "self",(char *) "name", NULL
27027 };
27028
27029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27031 if (!SWIG_IsOK(res1)) {
27032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27033 }
27034 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27035 {
27036 arg2 = wxString_in_helper(obj1);
27037 if (arg2 == NULL) SWIG_fail;
27038 temp2 = true;
27039 }
27040 {
27041 PyThreadState* __tstate = wxPyBeginAllowThreads();
27042 (arg1)->SetVendorName((wxString const &)*arg2);
27043 wxPyEndAllowThreads(__tstate);
27044 if (PyErr_Occurred()) SWIG_fail;
27045 }
27046 resultobj = SWIG_Py_Void();
27047 {
27048 if (temp2)
27049 delete arg2;
27050 }
27051 return resultobj;
27052 fail:
27053 {
27054 if (temp2)
27055 delete arg2;
27056 }
27057 return NULL;
27058 }
27059
27060
27061 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27062 PyObject *resultobj = 0;
27063 wxPyApp *arg1 = (wxPyApp *) 0 ;
27064 wxAppTraits *result = 0 ;
27065 void *argp1 = 0 ;
27066 int res1 = 0 ;
27067 PyObject *swig_obj[1] ;
27068
27069 if (!args) SWIG_fail;
27070 swig_obj[0] = args;
27071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27072 if (!SWIG_IsOK(res1)) {
27073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27074 }
27075 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = (wxAppTraits *)(arg1)->GetTraits();
27079 wxPyEndAllowThreads(__tstate);
27080 if (PyErr_Occurred()) SWIG_fail;
27081 }
27082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27083 return resultobj;
27084 fail:
27085 return NULL;
27086 }
27087
27088
27089 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27090 PyObject *resultobj = 0;
27091 wxPyApp *arg1 = (wxPyApp *) 0 ;
27092 void *argp1 = 0 ;
27093 int res1 = 0 ;
27094 PyObject *swig_obj[1] ;
27095
27096 if (!args) SWIG_fail;
27097 swig_obj[0] = args;
27098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27099 if (!SWIG_IsOK(res1)) {
27100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27101 }
27102 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27103 {
27104 PyThreadState* __tstate = wxPyBeginAllowThreads();
27105 (arg1)->ProcessPendingEvents();
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 resultobj = SWIG_Py_Void();
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27117 PyObject *resultobj = 0;
27118 wxPyApp *arg1 = (wxPyApp *) 0 ;
27119 bool arg2 = (bool) false ;
27120 bool result;
27121 void *argp1 = 0 ;
27122 int res1 = 0 ;
27123 bool val2 ;
27124 int ecode2 = 0 ;
27125 PyObject * obj0 = 0 ;
27126 PyObject * obj1 = 0 ;
27127 char * kwnames[] = {
27128 (char *) "self",(char *) "onlyIfNeeded", NULL
27129 };
27130
27131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27133 if (!SWIG_IsOK(res1)) {
27134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27135 }
27136 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27137 if (obj1) {
27138 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27139 if (!SWIG_IsOK(ecode2)) {
27140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27141 }
27142 arg2 = static_cast< bool >(val2);
27143 }
27144 {
27145 PyThreadState* __tstate = wxPyBeginAllowThreads();
27146 result = (bool)(arg1)->Yield(arg2);
27147 wxPyEndAllowThreads(__tstate);
27148 if (PyErr_Occurred()) SWIG_fail;
27149 }
27150 {
27151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27152 }
27153 return resultobj;
27154 fail:
27155 return NULL;
27156 }
27157
27158
27159 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27160 PyObject *resultobj = 0;
27161 wxPyApp *arg1 = (wxPyApp *) 0 ;
27162 void *argp1 = 0 ;
27163 int res1 = 0 ;
27164 PyObject *swig_obj[1] ;
27165
27166 if (!args) SWIG_fail;
27167 swig_obj[0] = args;
27168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27169 if (!SWIG_IsOK(res1)) {
27170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27171 }
27172 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 (arg1)->WakeUpIdle();
27176 wxPyEndAllowThreads(__tstate);
27177 if (PyErr_Occurred()) SWIG_fail;
27178 }
27179 resultobj = SWIG_Py_Void();
27180 return resultobj;
27181 fail:
27182 return NULL;
27183 }
27184
27185
27186 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27187 PyObject *resultobj = 0;
27188 bool result;
27189
27190 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27191 {
27192 PyThreadState* __tstate = wxPyBeginAllowThreads();
27193 result = (bool)wxPyApp::IsMainLoopRunning();
27194 wxPyEndAllowThreads(__tstate);
27195 if (PyErr_Occurred()) SWIG_fail;
27196 }
27197 {
27198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27199 }
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27207 PyObject *resultobj = 0;
27208 wxPyApp *arg1 = (wxPyApp *) 0 ;
27209 int result;
27210 void *argp1 = 0 ;
27211 int res1 = 0 ;
27212 PyObject *swig_obj[1] ;
27213
27214 if (!args) SWIG_fail;
27215 swig_obj[0] = args;
27216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27217 if (!SWIG_IsOK(res1)) {
27218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27219 }
27220 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27221 {
27222 PyThreadState* __tstate = wxPyBeginAllowThreads();
27223 result = (int)(arg1)->MainLoop();
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 resultobj = SWIG_From_int(static_cast< int >(result));
27228 return resultobj;
27229 fail:
27230 return NULL;
27231 }
27232
27233
27234 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27235 PyObject *resultobj = 0;
27236 wxPyApp *arg1 = (wxPyApp *) 0 ;
27237 void *argp1 = 0 ;
27238 int res1 = 0 ;
27239 PyObject *swig_obj[1] ;
27240
27241 if (!args) SWIG_fail;
27242 swig_obj[0] = args;
27243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27244 if (!SWIG_IsOK(res1)) {
27245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27246 }
27247 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27248 {
27249 PyThreadState* __tstate = wxPyBeginAllowThreads();
27250 (arg1)->Exit();
27251 wxPyEndAllowThreads(__tstate);
27252 if (PyErr_Occurred()) SWIG_fail;
27253 }
27254 resultobj = SWIG_Py_Void();
27255 return resultobj;
27256 fail:
27257 return NULL;
27258 }
27259
27260
27261 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27262 PyObject *resultobj = 0;
27263 wxPyApp *arg1 = (wxPyApp *) 0 ;
27264 void *argp1 = 0 ;
27265 int res1 = 0 ;
27266 PyObject *swig_obj[1] ;
27267
27268 if (!args) SWIG_fail;
27269 swig_obj[0] = args;
27270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27271 if (!SWIG_IsOK(res1)) {
27272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27273 }
27274 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27275 {
27276 PyThreadState* __tstate = wxPyBeginAllowThreads();
27277 (arg1)->ExitMainLoop();
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 resultobj = SWIG_Py_Void();
27282 return resultobj;
27283 fail:
27284 return NULL;
27285 }
27286
27287
27288 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27289 PyObject *resultobj = 0;
27290 wxPyApp *arg1 = (wxPyApp *) 0 ;
27291 bool result;
27292 void *argp1 = 0 ;
27293 int res1 = 0 ;
27294 PyObject *swig_obj[1] ;
27295
27296 if (!args) SWIG_fail;
27297 swig_obj[0] = args;
27298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27299 if (!SWIG_IsOK(res1)) {
27300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27301 }
27302 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 result = (bool)(arg1)->Pending();
27306 wxPyEndAllowThreads(__tstate);
27307 if (PyErr_Occurred()) SWIG_fail;
27308 }
27309 {
27310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27311 }
27312 return resultobj;
27313 fail:
27314 return NULL;
27315 }
27316
27317
27318 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27319 PyObject *resultobj = 0;
27320 wxPyApp *arg1 = (wxPyApp *) 0 ;
27321 bool result;
27322 void *argp1 = 0 ;
27323 int res1 = 0 ;
27324 PyObject *swig_obj[1] ;
27325
27326 if (!args) SWIG_fail;
27327 swig_obj[0] = args;
27328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27329 if (!SWIG_IsOK(res1)) {
27330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27331 }
27332 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27333 {
27334 PyThreadState* __tstate = wxPyBeginAllowThreads();
27335 result = (bool)(arg1)->Dispatch();
27336 wxPyEndAllowThreads(__tstate);
27337 if (PyErr_Occurred()) SWIG_fail;
27338 }
27339 {
27340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27341 }
27342 return resultobj;
27343 fail:
27344 return NULL;
27345 }
27346
27347
27348 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27349 PyObject *resultobj = 0;
27350 wxPyApp *arg1 = (wxPyApp *) 0 ;
27351 bool result;
27352 void *argp1 = 0 ;
27353 int res1 = 0 ;
27354 PyObject *swig_obj[1] ;
27355
27356 if (!args) SWIG_fail;
27357 swig_obj[0] = args;
27358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27359 if (!SWIG_IsOK(res1)) {
27360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27361 }
27362 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27363 {
27364 PyThreadState* __tstate = wxPyBeginAllowThreads();
27365 result = (bool)(arg1)->ProcessIdle();
27366 wxPyEndAllowThreads(__tstate);
27367 if (PyErr_Occurred()) SWIG_fail;
27368 }
27369 {
27370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27371 }
27372 return resultobj;
27373 fail:
27374 return NULL;
27375 }
27376
27377
27378 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27379 PyObject *resultobj = 0;
27380 wxPyApp *arg1 = (wxPyApp *) 0 ;
27381 wxWindow *arg2 = (wxWindow *) 0 ;
27382 wxIdleEvent *arg3 = 0 ;
27383 bool result;
27384 void *argp1 = 0 ;
27385 int res1 = 0 ;
27386 void *argp2 = 0 ;
27387 int res2 = 0 ;
27388 void *argp3 = 0 ;
27389 int res3 = 0 ;
27390 PyObject * obj0 = 0 ;
27391 PyObject * obj1 = 0 ;
27392 PyObject * obj2 = 0 ;
27393 char * kwnames[] = {
27394 (char *) "self",(char *) "win",(char *) "event", NULL
27395 };
27396
27397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27399 if (!SWIG_IsOK(res1)) {
27400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27401 }
27402 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27403 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27404 if (!SWIG_IsOK(res2)) {
27405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27406 }
27407 arg2 = reinterpret_cast< wxWindow * >(argp2);
27408 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27409 if (!SWIG_IsOK(res3)) {
27410 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27411 }
27412 if (!argp3) {
27413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27414 }
27415 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27419 wxPyEndAllowThreads(__tstate);
27420 if (PyErr_Occurred()) SWIG_fail;
27421 }
27422 {
27423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27424 }
27425 return resultobj;
27426 fail:
27427 return NULL;
27428 }
27429
27430
27431 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27432 PyObject *resultobj = 0;
27433 wxPyApp *arg1 = (wxPyApp *) 0 ;
27434 bool result;
27435 void *argp1 = 0 ;
27436 int res1 = 0 ;
27437 PyObject *swig_obj[1] ;
27438
27439 if (!args) SWIG_fail;
27440 swig_obj[0] = args;
27441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27442 if (!SWIG_IsOK(res1)) {
27443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27444 }
27445 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27446 {
27447 PyThreadState* __tstate = wxPyBeginAllowThreads();
27448 result = (bool)((wxPyApp const *)arg1)->IsActive();
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 {
27453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27454 }
27455 return resultobj;
27456 fail:
27457 return NULL;
27458 }
27459
27460
27461 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27462 PyObject *resultobj = 0;
27463 wxPyApp *arg1 = (wxPyApp *) 0 ;
27464 wxWindow *arg2 = (wxWindow *) 0 ;
27465 void *argp1 = 0 ;
27466 int res1 = 0 ;
27467 void *argp2 = 0 ;
27468 int res2 = 0 ;
27469 PyObject * obj0 = 0 ;
27470 PyObject * obj1 = 0 ;
27471 char * kwnames[] = {
27472 (char *) "self",(char *) "win", NULL
27473 };
27474
27475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27477 if (!SWIG_IsOK(res1)) {
27478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27479 }
27480 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27482 if (!SWIG_IsOK(res2)) {
27483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27484 }
27485 arg2 = reinterpret_cast< wxWindow * >(argp2);
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 (arg1)->SetTopWindow(arg2);
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 resultobj = SWIG_Py_Void();
27493 return resultobj;
27494 fail:
27495 return NULL;
27496 }
27497
27498
27499 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27500 PyObject *resultobj = 0;
27501 wxPyApp *arg1 = (wxPyApp *) 0 ;
27502 wxWindow *result = 0 ;
27503 void *argp1 = 0 ;
27504 int res1 = 0 ;
27505 PyObject *swig_obj[1] ;
27506
27507 if (!args) SWIG_fail;
27508 swig_obj[0] = args;
27509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27510 if (!SWIG_IsOK(res1)) {
27511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27512 }
27513 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27517 wxPyEndAllowThreads(__tstate);
27518 if (PyErr_Occurred()) SWIG_fail;
27519 }
27520 {
27521 resultobj = wxPyMake_wxObject(result, (bool)0);
27522 }
27523 return resultobj;
27524 fail:
27525 return NULL;
27526 }
27527
27528
27529 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27530 PyObject *resultobj = 0;
27531 wxPyApp *arg1 = (wxPyApp *) 0 ;
27532 bool arg2 ;
27533 void *argp1 = 0 ;
27534 int res1 = 0 ;
27535 bool val2 ;
27536 int ecode2 = 0 ;
27537 PyObject * obj0 = 0 ;
27538 PyObject * obj1 = 0 ;
27539 char * kwnames[] = {
27540 (char *) "self",(char *) "flag", NULL
27541 };
27542
27543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27545 if (!SWIG_IsOK(res1)) {
27546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27547 }
27548 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27549 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27550 if (!SWIG_IsOK(ecode2)) {
27551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27552 }
27553 arg2 = static_cast< bool >(val2);
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 (arg1)->SetExitOnFrameDelete(arg2);
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 resultobj = SWIG_Py_Void();
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *resultobj = 0;
27569 wxPyApp *arg1 = (wxPyApp *) 0 ;
27570 bool result;
27571 void *argp1 = 0 ;
27572 int res1 = 0 ;
27573 PyObject *swig_obj[1] ;
27574
27575 if (!args) SWIG_fail;
27576 swig_obj[0] = args;
27577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27578 if (!SWIG_IsOK(res1)) {
27579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27580 }
27581 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 {
27589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27590 }
27591 return resultobj;
27592 fail:
27593 return NULL;
27594 }
27595
27596
27597 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27598 PyObject *resultobj = 0;
27599 wxPyApp *arg1 = (wxPyApp *) 0 ;
27600 bool arg2 ;
27601 void *argp1 = 0 ;
27602 int res1 = 0 ;
27603 bool val2 ;
27604 int ecode2 = 0 ;
27605 PyObject * obj0 = 0 ;
27606 PyObject * obj1 = 0 ;
27607 char * kwnames[] = {
27608 (char *) "self",(char *) "flag", NULL
27609 };
27610
27611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27613 if (!SWIG_IsOK(res1)) {
27614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27615 }
27616 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27617 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27618 if (!SWIG_IsOK(ecode2)) {
27619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27620 }
27621 arg2 = static_cast< bool >(val2);
27622 {
27623 PyThreadState* __tstate = wxPyBeginAllowThreads();
27624 (arg1)->SetUseBestVisual(arg2);
27625 wxPyEndAllowThreads(__tstate);
27626 if (PyErr_Occurred()) SWIG_fail;
27627 }
27628 resultobj = SWIG_Py_Void();
27629 return resultobj;
27630 fail:
27631 return NULL;
27632 }
27633
27634
27635 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27636 PyObject *resultobj = 0;
27637 wxPyApp *arg1 = (wxPyApp *) 0 ;
27638 bool result;
27639 void *argp1 = 0 ;
27640 int res1 = 0 ;
27641 PyObject *swig_obj[1] ;
27642
27643 if (!args) SWIG_fail;
27644 swig_obj[0] = args;
27645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27646 if (!SWIG_IsOK(res1)) {
27647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27648 }
27649 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27650 {
27651 PyThreadState* __tstate = wxPyBeginAllowThreads();
27652 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27653 wxPyEndAllowThreads(__tstate);
27654 if (PyErr_Occurred()) SWIG_fail;
27655 }
27656 {
27657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27658 }
27659 return resultobj;
27660 fail:
27661 return NULL;
27662 }
27663
27664
27665 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27666 PyObject *resultobj = 0;
27667 wxPyApp *arg1 = (wxPyApp *) 0 ;
27668 int arg2 ;
27669 void *argp1 = 0 ;
27670 int res1 = 0 ;
27671 int val2 ;
27672 int ecode2 = 0 ;
27673 PyObject * obj0 = 0 ;
27674 PyObject * obj1 = 0 ;
27675 char * kwnames[] = {
27676 (char *) "self",(char *) "mode", NULL
27677 };
27678
27679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27681 if (!SWIG_IsOK(res1)) {
27682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27683 }
27684 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27685 ecode2 = SWIG_AsVal_int(obj1, &val2);
27686 if (!SWIG_IsOK(ecode2)) {
27687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27688 }
27689 arg2 = static_cast< int >(val2);
27690 {
27691 PyThreadState* __tstate = wxPyBeginAllowThreads();
27692 (arg1)->SetPrintMode(arg2);
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 resultobj = SWIG_Py_Void();
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27704 PyObject *resultobj = 0;
27705 wxPyApp *arg1 = (wxPyApp *) 0 ;
27706 int result;
27707 void *argp1 = 0 ;
27708 int res1 = 0 ;
27709 PyObject *swig_obj[1] ;
27710
27711 if (!args) SWIG_fail;
27712 swig_obj[0] = args;
27713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27714 if (!SWIG_IsOK(res1)) {
27715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27716 }
27717 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27718 {
27719 PyThreadState* __tstate = wxPyBeginAllowThreads();
27720 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27721 wxPyEndAllowThreads(__tstate);
27722 if (PyErr_Occurred()) SWIG_fail;
27723 }
27724 resultobj = SWIG_From_int(static_cast< int >(result));
27725 return resultobj;
27726 fail:
27727 return NULL;
27728 }
27729
27730
27731 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27732 PyObject *resultobj = 0;
27733 wxPyApp *arg1 = (wxPyApp *) 0 ;
27734 int arg2 ;
27735 void *argp1 = 0 ;
27736 int res1 = 0 ;
27737 int val2 ;
27738 int ecode2 = 0 ;
27739 PyObject * obj0 = 0 ;
27740 PyObject * obj1 = 0 ;
27741 char * kwnames[] = {
27742 (char *) "self",(char *) "mode", NULL
27743 };
27744
27745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27747 if (!SWIG_IsOK(res1)) {
27748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27749 }
27750 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27751 ecode2 = SWIG_AsVal_int(obj1, &val2);
27752 if (!SWIG_IsOK(ecode2)) {
27753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27754 }
27755 arg2 = static_cast< int >(val2);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 (arg1)->SetAssertMode(arg2);
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 resultobj = SWIG_Py_Void();
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27770 PyObject *resultobj = 0;
27771 wxPyApp *arg1 = (wxPyApp *) 0 ;
27772 int result;
27773 void *argp1 = 0 ;
27774 int res1 = 0 ;
27775 PyObject *swig_obj[1] ;
27776
27777 if (!args) SWIG_fail;
27778 swig_obj[0] = args;
27779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27780 if (!SWIG_IsOK(res1)) {
27781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27782 }
27783 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27784 {
27785 PyThreadState* __tstate = wxPyBeginAllowThreads();
27786 result = (int)(arg1)->GetAssertMode();
27787 wxPyEndAllowThreads(__tstate);
27788 if (PyErr_Occurred()) SWIG_fail;
27789 }
27790 resultobj = SWIG_From_int(static_cast< int >(result));
27791 return resultobj;
27792 fail:
27793 return NULL;
27794 }
27795
27796
27797 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27798 PyObject *resultobj = 0;
27799 bool result;
27800
27801 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27802 {
27803 PyThreadState* __tstate = wxPyBeginAllowThreads();
27804 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27805 wxPyEndAllowThreads(__tstate);
27806 if (PyErr_Occurred()) SWIG_fail;
27807 }
27808 {
27809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27810 }
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27818 PyObject *resultobj = 0;
27819 long result;
27820
27821 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27822 {
27823 PyThreadState* __tstate = wxPyBeginAllowThreads();
27824 result = (long)wxPyApp::GetMacAboutMenuItemId();
27825 wxPyEndAllowThreads(__tstate);
27826 if (PyErr_Occurred()) SWIG_fail;
27827 }
27828 resultobj = SWIG_From_long(static_cast< long >(result));
27829 return resultobj;
27830 fail:
27831 return NULL;
27832 }
27833
27834
27835 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27836 PyObject *resultobj = 0;
27837 long result;
27838
27839 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27840 {
27841 PyThreadState* __tstate = wxPyBeginAllowThreads();
27842 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27843 wxPyEndAllowThreads(__tstate);
27844 if (PyErr_Occurred()) SWIG_fail;
27845 }
27846 resultobj = SWIG_From_long(static_cast< long >(result));
27847 return resultobj;
27848 fail:
27849 return NULL;
27850 }
27851
27852
27853 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27854 PyObject *resultobj = 0;
27855 long result;
27856
27857 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27858 {
27859 PyThreadState* __tstate = wxPyBeginAllowThreads();
27860 result = (long)wxPyApp::GetMacExitMenuItemId();
27861 wxPyEndAllowThreads(__tstate);
27862 if (PyErr_Occurred()) SWIG_fail;
27863 }
27864 resultobj = SWIG_From_long(static_cast< long >(result));
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27872 PyObject *resultobj = 0;
27873 wxString result;
27874
27875 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27876 {
27877 PyThreadState* __tstate = wxPyBeginAllowThreads();
27878 result = wxPyApp::GetMacHelpMenuTitleName();
27879 wxPyEndAllowThreads(__tstate);
27880 if (PyErr_Occurred()) SWIG_fail;
27881 }
27882 {
27883 #if wxUSE_UNICODE
27884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27885 #else
27886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27887 #endif
27888 }
27889 return resultobj;
27890 fail:
27891 return NULL;
27892 }
27893
27894
27895 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27896 PyObject *resultobj = 0;
27897 bool arg1 ;
27898 bool val1 ;
27899 int ecode1 = 0 ;
27900 PyObject * obj0 = 0 ;
27901 char * kwnames[] = {
27902 (char *) "val", NULL
27903 };
27904
27905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27906 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27907 if (!SWIG_IsOK(ecode1)) {
27908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27909 }
27910 arg1 = static_cast< bool >(val1);
27911 {
27912 PyThreadState* __tstate = wxPyBeginAllowThreads();
27913 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27914 wxPyEndAllowThreads(__tstate);
27915 if (PyErr_Occurred()) SWIG_fail;
27916 }
27917 resultobj = SWIG_Py_Void();
27918 return resultobj;
27919 fail:
27920 return NULL;
27921 }
27922
27923
27924 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27925 PyObject *resultobj = 0;
27926 long arg1 ;
27927 long val1 ;
27928 int ecode1 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 char * kwnames[] = {
27931 (char *) "val", NULL
27932 };
27933
27934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27935 ecode1 = SWIG_AsVal_long(obj0, &val1);
27936 if (!SWIG_IsOK(ecode1)) {
27937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27938 }
27939 arg1 = static_cast< long >(val1);
27940 {
27941 PyThreadState* __tstate = wxPyBeginAllowThreads();
27942 wxPyApp::SetMacAboutMenuItemId(arg1);
27943 wxPyEndAllowThreads(__tstate);
27944 if (PyErr_Occurred()) SWIG_fail;
27945 }
27946 resultobj = SWIG_Py_Void();
27947 return resultobj;
27948 fail:
27949 return NULL;
27950 }
27951
27952
27953 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27954 PyObject *resultobj = 0;
27955 long arg1 ;
27956 long val1 ;
27957 int ecode1 = 0 ;
27958 PyObject * obj0 = 0 ;
27959 char * kwnames[] = {
27960 (char *) "val", NULL
27961 };
27962
27963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
27964 ecode1 = SWIG_AsVal_long(obj0, &val1);
27965 if (!SWIG_IsOK(ecode1)) {
27966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
27967 }
27968 arg1 = static_cast< long >(val1);
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 wxPyApp::SetMacPreferencesMenuItemId(arg1);
27972 wxPyEndAllowThreads(__tstate);
27973 if (PyErr_Occurred()) SWIG_fail;
27974 }
27975 resultobj = SWIG_Py_Void();
27976 return resultobj;
27977 fail:
27978 return NULL;
27979 }
27980
27981
27982 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27983 PyObject *resultobj = 0;
27984 long arg1 ;
27985 long val1 ;
27986 int ecode1 = 0 ;
27987 PyObject * obj0 = 0 ;
27988 char * kwnames[] = {
27989 (char *) "val", NULL
27990 };
27991
27992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
27993 ecode1 = SWIG_AsVal_long(obj0, &val1);
27994 if (!SWIG_IsOK(ecode1)) {
27995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
27996 }
27997 arg1 = static_cast< long >(val1);
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 wxPyApp::SetMacExitMenuItemId(arg1);
28001 wxPyEndAllowThreads(__tstate);
28002 if (PyErr_Occurred()) SWIG_fail;
28003 }
28004 resultobj = SWIG_Py_Void();
28005 return resultobj;
28006 fail:
28007 return NULL;
28008 }
28009
28010
28011 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28012 PyObject *resultobj = 0;
28013 wxString *arg1 = 0 ;
28014 bool temp1 = false ;
28015 PyObject * obj0 = 0 ;
28016 char * kwnames[] = {
28017 (char *) "val", NULL
28018 };
28019
28020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28021 {
28022 arg1 = wxString_in_helper(obj0);
28023 if (arg1 == NULL) SWIG_fail;
28024 temp1 = true;
28025 }
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 resultobj = SWIG_Py_Void();
28033 {
28034 if (temp1)
28035 delete arg1;
28036 }
28037 return resultobj;
28038 fail:
28039 {
28040 if (temp1)
28041 delete arg1;
28042 }
28043 return NULL;
28044 }
28045
28046
28047 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28048 PyObject *resultobj = 0;
28049 wxPyApp *arg1 = (wxPyApp *) 0 ;
28050 void *argp1 = 0 ;
28051 int res1 = 0 ;
28052 PyObject *swig_obj[1] ;
28053
28054 if (!args) SWIG_fail;
28055 swig_obj[0] = args;
28056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28057 if (!SWIG_IsOK(res1)) {
28058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28059 }
28060 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 (arg1)->_BootstrapApp();
28064 wxPyEndAllowThreads(__tstate);
28065 if (PyErr_Occurred()) SWIG_fail;
28066 }
28067 resultobj = SWIG_Py_Void();
28068 return resultobj;
28069 fail:
28070 return NULL;
28071 }
28072
28073
28074 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28075 PyObject *resultobj = 0;
28076 int result;
28077
28078 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28079 {
28080 PyThreadState* __tstate = wxPyBeginAllowThreads();
28081 result = (int)wxPyApp_GetComCtl32Version();
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 resultobj = SWIG_From_int(static_cast< int >(result));
28086 return resultobj;
28087 fail:
28088 return NULL;
28089 }
28090
28091
28092 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28093 PyObject *obj;
28094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28095 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28096 return SWIG_Py_Void();
28097 }
28098
28099 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28100 return SWIG_Python_InitShadowInstance(args);
28101 }
28102
28103 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28104 PyObject *resultobj = 0;
28105
28106 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28107 {
28108 PyThreadState* __tstate = wxPyBeginAllowThreads();
28109 wxExit();
28110 wxPyEndAllowThreads(__tstate);
28111 if (PyErr_Occurred()) SWIG_fail;
28112 }
28113 resultobj = SWIG_Py_Void();
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28121 PyObject *resultobj = 0;
28122 bool result;
28123
28124 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = (bool)wxYield();
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 {
28132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28133 }
28134 return resultobj;
28135 fail:
28136 return NULL;
28137 }
28138
28139
28140 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28141 PyObject *resultobj = 0;
28142 bool result;
28143
28144 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 result = (bool)wxYieldIfNeeded();
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 {
28152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28153 }
28154 return resultobj;
28155 fail:
28156 return NULL;
28157 }
28158
28159
28160 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28161 PyObject *resultobj = 0;
28162 wxWindow *arg1 = (wxWindow *) NULL ;
28163 bool arg2 = (bool) false ;
28164 bool result;
28165 void *argp1 = 0 ;
28166 int res1 = 0 ;
28167 bool val2 ;
28168 int ecode2 = 0 ;
28169 PyObject * obj0 = 0 ;
28170 PyObject * obj1 = 0 ;
28171 char * kwnames[] = {
28172 (char *) "win",(char *) "onlyIfNeeded", NULL
28173 };
28174
28175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28176 if (obj0) {
28177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28178 if (!SWIG_IsOK(res1)) {
28179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28180 }
28181 arg1 = reinterpret_cast< wxWindow * >(argp1);
28182 }
28183 if (obj1) {
28184 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28185 if (!SWIG_IsOK(ecode2)) {
28186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28187 }
28188 arg2 = static_cast< bool >(val2);
28189 }
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 result = (bool)wxSafeYield(arg1,arg2);
28193 wxPyEndAllowThreads(__tstate);
28194 if (PyErr_Occurred()) SWIG_fail;
28195 }
28196 {
28197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28198 }
28199 return resultobj;
28200 fail:
28201 return NULL;
28202 }
28203
28204
28205 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28206 PyObject *resultobj = 0;
28207
28208 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28209 {
28210 PyThreadState* __tstate = wxPyBeginAllowThreads();
28211 wxWakeUpIdle();
28212 wxPyEndAllowThreads(__tstate);
28213 if (PyErr_Occurred()) SWIG_fail;
28214 }
28215 resultobj = SWIG_Py_Void();
28216 return resultobj;
28217 fail:
28218 return NULL;
28219 }
28220
28221
28222 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28223 PyObject *resultobj = 0;
28224 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28225 wxEvent *arg2 = 0 ;
28226 void *argp1 = 0 ;
28227 int res1 = 0 ;
28228 void *argp2 = 0 ;
28229 int res2 = 0 ;
28230 PyObject * obj0 = 0 ;
28231 PyObject * obj1 = 0 ;
28232 char * kwnames[] = {
28233 (char *) "dest",(char *) "event", NULL
28234 };
28235
28236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28238 if (!SWIG_IsOK(res1)) {
28239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28240 }
28241 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28242 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28243 if (!SWIG_IsOK(res2)) {
28244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28245 }
28246 if (!argp2) {
28247 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28248 }
28249 arg2 = reinterpret_cast< wxEvent * >(argp2);
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 wxPostEvent(arg1,*arg2);
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 resultobj = SWIG_Py_Void();
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28264 PyObject *resultobj = 0;
28265
28266 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 wxApp_CleanUp();
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 resultobj = SWIG_Py_Void();
28274 return resultobj;
28275 fail:
28276 return NULL;
28277 }
28278
28279
28280 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28281 PyObject *resultobj = 0;
28282 wxPyApp *result = 0 ;
28283
28284 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28285 {
28286 PyThreadState* __tstate = wxPyBeginAllowThreads();
28287 result = (wxPyApp *)wxPyGetApp();
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 {
28292 resultobj = wxPyMake_wxObject(result, 0);
28293 }
28294 return resultobj;
28295 fail:
28296 return NULL;
28297 }
28298
28299
28300 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28301 PyObject *resultobj = 0;
28302 char *arg1 = (char *) 0 ;
28303 int res1 ;
28304 char *buf1 = 0 ;
28305 int alloc1 = 0 ;
28306 PyObject * obj0 = 0 ;
28307 char * kwnames[] = {
28308 (char *) "encoding", NULL
28309 };
28310
28311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28312 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28313 if (!SWIG_IsOK(res1)) {
28314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28315 }
28316 arg1 = buf1;
28317 {
28318 PyThreadState* __tstate = wxPyBeginAllowThreads();
28319 wxSetDefaultPyEncoding((char const *)arg1);
28320 wxPyEndAllowThreads(__tstate);
28321 if (PyErr_Occurred()) SWIG_fail;
28322 }
28323 resultobj = SWIG_Py_Void();
28324 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28325 return resultobj;
28326 fail:
28327 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28328 return NULL;
28329 }
28330
28331
28332 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28333 PyObject *resultobj = 0;
28334 char *result = 0 ;
28335
28336 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28337 {
28338 PyThreadState* __tstate = wxPyBeginAllowThreads();
28339 result = (char *)wxGetDefaultPyEncoding();
28340 wxPyEndAllowThreads(__tstate);
28341 if (PyErr_Occurred()) SWIG_fail;
28342 }
28343 resultobj = SWIG_FromCharPtr(result);
28344 return resultobj;
28345 fail:
28346 return NULL;
28347 }
28348
28349
28350 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28351 PyObject *resultobj = 0;
28352 wxEventLoop *result = 0 ;
28353
28354 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28355 {
28356 PyThreadState* __tstate = wxPyBeginAllowThreads();
28357 result = (wxEventLoop *)new wxEventLoop();
28358 wxPyEndAllowThreads(__tstate);
28359 if (PyErr_Occurred()) SWIG_fail;
28360 }
28361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28362 return resultobj;
28363 fail:
28364 return NULL;
28365 }
28366
28367
28368 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28369 PyObject *resultobj = 0;
28370 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28371 void *argp1 = 0 ;
28372 int res1 = 0 ;
28373 PyObject *swig_obj[1] ;
28374
28375 if (!args) SWIG_fail;
28376 swig_obj[0] = args;
28377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28378 if (!SWIG_IsOK(res1)) {
28379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28380 }
28381 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 delete arg1;
28385
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 resultobj = SWIG_Py_Void();
28390 return resultobj;
28391 fail:
28392 return NULL;
28393 }
28394
28395
28396 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28397 PyObject *resultobj = 0;
28398 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28399 int result;
28400 void *argp1 = 0 ;
28401 int res1 = 0 ;
28402 PyObject *swig_obj[1] ;
28403
28404 if (!args) SWIG_fail;
28405 swig_obj[0] = args;
28406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28407 if (!SWIG_IsOK(res1)) {
28408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28409 }
28410 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28411 {
28412 PyThreadState* __tstate = wxPyBeginAllowThreads();
28413 result = (int)(arg1)->Run();
28414 wxPyEndAllowThreads(__tstate);
28415 if (PyErr_Occurred()) SWIG_fail;
28416 }
28417 resultobj = SWIG_From_int(static_cast< int >(result));
28418 return resultobj;
28419 fail:
28420 return NULL;
28421 }
28422
28423
28424 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28425 PyObject *resultobj = 0;
28426 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28427 int arg2 = (int) 0 ;
28428 void *argp1 = 0 ;
28429 int res1 = 0 ;
28430 int val2 ;
28431 int ecode2 = 0 ;
28432 PyObject * obj0 = 0 ;
28433 PyObject * obj1 = 0 ;
28434 char * kwnames[] = {
28435 (char *) "self",(char *) "rc", NULL
28436 };
28437
28438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28440 if (!SWIG_IsOK(res1)) {
28441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28442 }
28443 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28444 if (obj1) {
28445 ecode2 = SWIG_AsVal_int(obj1, &val2);
28446 if (!SWIG_IsOK(ecode2)) {
28447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28448 }
28449 arg2 = static_cast< int >(val2);
28450 }
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 (arg1)->Exit(arg2);
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 resultobj = SWIG_Py_Void();
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28465 PyObject *resultobj = 0;
28466 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28467 bool result;
28468 void *argp1 = 0 ;
28469 int res1 = 0 ;
28470 PyObject *swig_obj[1] ;
28471
28472 if (!args) SWIG_fail;
28473 swig_obj[0] = args;
28474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28475 if (!SWIG_IsOK(res1)) {
28476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28477 }
28478 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 result = (bool)((wxEventLoop const *)arg1)->Pending();
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 {
28486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28487 }
28488 return resultobj;
28489 fail:
28490 return NULL;
28491 }
28492
28493
28494 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28495 PyObject *resultobj = 0;
28496 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28497 bool result;
28498 void *argp1 = 0 ;
28499 int res1 = 0 ;
28500 PyObject *swig_obj[1] ;
28501
28502 if (!args) SWIG_fail;
28503 swig_obj[0] = args;
28504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28505 if (!SWIG_IsOK(res1)) {
28506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28507 }
28508 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = (bool)(arg1)->Dispatch();
28512 wxPyEndAllowThreads(__tstate);
28513 if (PyErr_Occurred()) SWIG_fail;
28514 }
28515 {
28516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28517 }
28518 return resultobj;
28519 fail:
28520 return NULL;
28521 }
28522
28523
28524 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28525 PyObject *resultobj = 0;
28526 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28527 bool result;
28528 void *argp1 = 0 ;
28529 int res1 = 0 ;
28530 PyObject *swig_obj[1] ;
28531
28532 if (!args) SWIG_fail;
28533 swig_obj[0] = args;
28534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28535 if (!SWIG_IsOK(res1)) {
28536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28537 }
28538 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28539 {
28540 PyThreadState* __tstate = wxPyBeginAllowThreads();
28541 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28542 wxPyEndAllowThreads(__tstate);
28543 if (PyErr_Occurred()) SWIG_fail;
28544 }
28545 {
28546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28547 }
28548 return resultobj;
28549 fail:
28550 return NULL;
28551 }
28552
28553
28554 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28555 PyObject *resultobj = 0;
28556 wxEventLoop *result = 0 ;
28557
28558 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28559 {
28560 PyThreadState* __tstate = wxPyBeginAllowThreads();
28561 result = (wxEventLoop *)wxEventLoop::GetActive();
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28566 return resultobj;
28567 fail:
28568 return NULL;
28569 }
28570
28571
28572 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28573 PyObject *resultobj = 0;
28574 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28575 void *argp1 = 0 ;
28576 int res1 = 0 ;
28577 PyObject * obj0 = 0 ;
28578 char * kwnames[] = {
28579 (char *) "loop", NULL
28580 };
28581
28582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28584 if (!SWIG_IsOK(res1)) {
28585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28586 }
28587 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 wxEventLoop::SetActive(arg1);
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 resultobj = SWIG_Py_Void();
28595 return resultobj;
28596 fail:
28597 return NULL;
28598 }
28599
28600
28601 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28602 PyObject *obj;
28603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28604 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28605 return SWIG_Py_Void();
28606 }
28607
28608 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28609 return SWIG_Python_InitShadowInstance(args);
28610 }
28611
28612 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28613 PyObject *resultobj = 0;
28614 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28615 wxEventLoopActivator *result = 0 ;
28616 void *argp1 = 0 ;
28617 int res1 = 0 ;
28618 PyObject * obj0 = 0 ;
28619 char * kwnames[] = {
28620 (char *) "evtLoop", NULL
28621 };
28622
28623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28625 if (!SWIG_IsOK(res1)) {
28626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28627 }
28628 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28629 {
28630 PyThreadState* __tstate = wxPyBeginAllowThreads();
28631 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28632 wxPyEndAllowThreads(__tstate);
28633 if (PyErr_Occurred()) SWIG_fail;
28634 }
28635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28643 PyObject *resultobj = 0;
28644 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28645 void *argp1 = 0 ;
28646 int res1 = 0 ;
28647 PyObject *swig_obj[1] ;
28648
28649 if (!args) SWIG_fail;
28650 swig_obj[0] = args;
28651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28652 if (!SWIG_IsOK(res1)) {
28653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28654 }
28655 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28656 {
28657 PyThreadState* __tstate = wxPyBeginAllowThreads();
28658 delete arg1;
28659
28660 wxPyEndAllowThreads(__tstate);
28661 if (PyErr_Occurred()) SWIG_fail;
28662 }
28663 resultobj = SWIG_Py_Void();
28664 return resultobj;
28665 fail:
28666 return NULL;
28667 }
28668
28669
28670 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28671 PyObject *obj;
28672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28673 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28674 return SWIG_Py_Void();
28675 }
28676
28677 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28678 return SWIG_Python_InitShadowInstance(args);
28679 }
28680
28681 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28682 PyObject *resultobj = 0;
28683 int arg1 = (int) 0 ;
28684 int arg2 = (int) 0 ;
28685 int arg3 = (int) 0 ;
28686 wxAcceleratorEntry *result = 0 ;
28687 int val1 ;
28688 int ecode1 = 0 ;
28689 int val2 ;
28690 int ecode2 = 0 ;
28691 int val3 ;
28692 int ecode3 = 0 ;
28693 PyObject * obj0 = 0 ;
28694 PyObject * obj1 = 0 ;
28695 PyObject * obj2 = 0 ;
28696 char * kwnames[] = {
28697 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28698 };
28699
28700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28701 if (obj0) {
28702 ecode1 = SWIG_AsVal_int(obj0, &val1);
28703 if (!SWIG_IsOK(ecode1)) {
28704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28705 }
28706 arg1 = static_cast< int >(val1);
28707 }
28708 if (obj1) {
28709 ecode2 = SWIG_AsVal_int(obj1, &val2);
28710 if (!SWIG_IsOK(ecode2)) {
28711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28712 }
28713 arg2 = static_cast< int >(val2);
28714 }
28715 if (obj2) {
28716 ecode3 = SWIG_AsVal_int(obj2, &val3);
28717 if (!SWIG_IsOK(ecode3)) {
28718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28719 }
28720 arg3 = static_cast< int >(val3);
28721 }
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28725 wxPyEndAllowThreads(__tstate);
28726 if (PyErr_Occurred()) SWIG_fail;
28727 }
28728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28736 PyObject *resultobj = 0;
28737 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28738 void *argp1 = 0 ;
28739 int res1 = 0 ;
28740 PyObject *swig_obj[1] ;
28741
28742 if (!args) SWIG_fail;
28743 swig_obj[0] = args;
28744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28745 if (!SWIG_IsOK(res1)) {
28746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28747 }
28748 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 delete arg1;
28752
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 resultobj = SWIG_Py_Void();
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28764 PyObject *resultobj = 0;
28765 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28766 int arg2 ;
28767 int arg3 ;
28768 int arg4 ;
28769 void *argp1 = 0 ;
28770 int res1 = 0 ;
28771 int val2 ;
28772 int ecode2 = 0 ;
28773 int val3 ;
28774 int ecode3 = 0 ;
28775 int val4 ;
28776 int ecode4 = 0 ;
28777 PyObject * obj0 = 0 ;
28778 PyObject * obj1 = 0 ;
28779 PyObject * obj2 = 0 ;
28780 PyObject * obj3 = 0 ;
28781 char * kwnames[] = {
28782 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28783 };
28784
28785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28787 if (!SWIG_IsOK(res1)) {
28788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28789 }
28790 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28791 ecode2 = SWIG_AsVal_int(obj1, &val2);
28792 if (!SWIG_IsOK(ecode2)) {
28793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28794 }
28795 arg2 = static_cast< int >(val2);
28796 ecode3 = SWIG_AsVal_int(obj2, &val3);
28797 if (!SWIG_IsOK(ecode3)) {
28798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28799 }
28800 arg3 = static_cast< int >(val3);
28801 ecode4 = SWIG_AsVal_int(obj3, &val4);
28802 if (!SWIG_IsOK(ecode4)) {
28803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28804 }
28805 arg4 = static_cast< int >(val4);
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 (arg1)->Set(arg2,arg3,arg4);
28809 wxPyEndAllowThreads(__tstate);
28810 if (PyErr_Occurred()) SWIG_fail;
28811 }
28812 resultobj = SWIG_Py_Void();
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28820 PyObject *resultobj = 0;
28821 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28822 int result;
28823 void *argp1 = 0 ;
28824 int res1 = 0 ;
28825 PyObject *swig_obj[1] ;
28826
28827 if (!args) SWIG_fail;
28828 swig_obj[0] = args;
28829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28830 if (!SWIG_IsOK(res1)) {
28831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28832 }
28833 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28834 {
28835 PyThreadState* __tstate = wxPyBeginAllowThreads();
28836 result = (int)(arg1)->GetFlags();
28837 wxPyEndAllowThreads(__tstate);
28838 if (PyErr_Occurred()) SWIG_fail;
28839 }
28840 resultobj = SWIG_From_int(static_cast< int >(result));
28841 return resultobj;
28842 fail:
28843 return NULL;
28844 }
28845
28846
28847 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28848 PyObject *resultobj = 0;
28849 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28850 int result;
28851 void *argp1 = 0 ;
28852 int res1 = 0 ;
28853 PyObject *swig_obj[1] ;
28854
28855 if (!args) SWIG_fail;
28856 swig_obj[0] = args;
28857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28858 if (!SWIG_IsOK(res1)) {
28859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28860 }
28861 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28862 {
28863 PyThreadState* __tstate = wxPyBeginAllowThreads();
28864 result = (int)(arg1)->GetKeyCode();
28865 wxPyEndAllowThreads(__tstate);
28866 if (PyErr_Occurred()) SWIG_fail;
28867 }
28868 resultobj = SWIG_From_int(static_cast< int >(result));
28869 return resultobj;
28870 fail:
28871 return NULL;
28872 }
28873
28874
28875 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28876 PyObject *resultobj = 0;
28877 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28878 int result;
28879 void *argp1 = 0 ;
28880 int res1 = 0 ;
28881 PyObject *swig_obj[1] ;
28882
28883 if (!args) SWIG_fail;
28884 swig_obj[0] = args;
28885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28886 if (!SWIG_IsOK(res1)) {
28887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28888 }
28889 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28890 {
28891 PyThreadState* __tstate = wxPyBeginAllowThreads();
28892 result = (int)(arg1)->GetCommand();
28893 wxPyEndAllowThreads(__tstate);
28894 if (PyErr_Occurred()) SWIG_fail;
28895 }
28896 resultobj = SWIG_From_int(static_cast< int >(result));
28897 return resultobj;
28898 fail:
28899 return NULL;
28900 }
28901
28902
28903 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28904 PyObject *obj;
28905 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28906 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28907 return SWIG_Py_Void();
28908 }
28909
28910 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28911 return SWIG_Python_InitShadowInstance(args);
28912 }
28913
28914 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28915 PyObject *resultobj = 0;
28916 int arg1 ;
28917 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28918 wxAcceleratorTable *result = 0 ;
28919 PyObject * obj0 = 0 ;
28920 char * kwnames[] = {
28921 (char *) "n", NULL
28922 };
28923
28924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28925 {
28926 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28927 if (arg2) arg1 = PyList_Size(obj0);
28928 else arg1 = 0;
28929 }
28930 {
28931 PyThreadState* __tstate = wxPyBeginAllowThreads();
28932 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 PyObject *resultobj = 0;
28945 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28946 void *argp1 = 0 ;
28947 int res1 = 0 ;
28948 PyObject *swig_obj[1] ;
28949
28950 if (!args) SWIG_fail;
28951 swig_obj[0] = args;
28952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
28953 if (!SWIG_IsOK(res1)) {
28954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
28955 }
28956 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 delete arg1;
28960
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 resultobj = SWIG_Py_Void();
28965 return resultobj;
28966 fail:
28967 return NULL;
28968 }
28969
28970
28971 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28972 PyObject *resultobj = 0;
28973 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28974 bool result;
28975 void *argp1 = 0 ;
28976 int res1 = 0 ;
28977 PyObject *swig_obj[1] ;
28978
28979 if (!args) SWIG_fail;
28980 swig_obj[0] = args;
28981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
28982 if (!SWIG_IsOK(res1)) {
28983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
28984 }
28985 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28986 {
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
28989 wxPyEndAllowThreads(__tstate);
28990 if (PyErr_Occurred()) SWIG_fail;
28991 }
28992 {
28993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28994 }
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29002 PyObject *obj;
29003 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29004 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29005 return SWIG_Py_Void();
29006 }
29007
29008 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29009 return SWIG_Python_InitShadowInstance(args);
29010 }
29011
29012 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29013 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29014 return 1;
29015 }
29016
29017
29018 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29019 PyObject *pyobj = 0;
29020
29021 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29022 return pyobj;
29023 }
29024
29025
29026 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29027 PyObject *resultobj = 0;
29028 wxString *arg1 = 0 ;
29029 wxAcceleratorEntry *result = 0 ;
29030 bool temp1 = false ;
29031 PyObject * obj0 = 0 ;
29032 char * kwnames[] = {
29033 (char *) "label", NULL
29034 };
29035
29036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29037 {
29038 arg1 = wxString_in_helper(obj0);
29039 if (arg1 == NULL) SWIG_fail;
29040 temp1 = true;
29041 }
29042 {
29043 PyThreadState* __tstate = wxPyBeginAllowThreads();
29044 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29045 wxPyEndAllowThreads(__tstate);
29046 if (PyErr_Occurred()) SWIG_fail;
29047 }
29048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29049 {
29050 if (temp1)
29051 delete arg1;
29052 }
29053 return resultobj;
29054 fail:
29055 {
29056 if (temp1)
29057 delete arg1;
29058 }
29059 return NULL;
29060 }
29061
29062
29063 SWIGINTERN int PanelNameStr_set(PyObject *) {
29064 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29065 return 1;
29066 }
29067
29068
29069 SWIGINTERN PyObject *PanelNameStr_get(void) {
29070 PyObject *pyobj = 0;
29071
29072 {
29073 #if wxUSE_UNICODE
29074 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29075 #else
29076 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29077 #endif
29078 }
29079 return pyobj;
29080 }
29081
29082
29083 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29084 PyObject *resultobj = 0;
29085 wxVisualAttributes *result = 0 ;
29086
29087 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29088 {
29089 PyThreadState* __tstate = wxPyBeginAllowThreads();
29090 result = (wxVisualAttributes *)new_wxVisualAttributes();
29091 wxPyEndAllowThreads(__tstate);
29092 if (PyErr_Occurred()) SWIG_fail;
29093 }
29094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29095 return resultobj;
29096 fail:
29097 return NULL;
29098 }
29099
29100
29101 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29102 PyObject *resultobj = 0;
29103 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29104 void *argp1 = 0 ;
29105 int res1 = 0 ;
29106 PyObject *swig_obj[1] ;
29107
29108 if (!args) SWIG_fail;
29109 swig_obj[0] = args;
29110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29111 if (!SWIG_IsOK(res1)) {
29112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29113 }
29114 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29115 {
29116 PyThreadState* __tstate = wxPyBeginAllowThreads();
29117 delete_wxVisualAttributes(arg1);
29118
29119 wxPyEndAllowThreads(__tstate);
29120 if (PyErr_Occurred()) SWIG_fail;
29121 }
29122 resultobj = SWIG_Py_Void();
29123 return resultobj;
29124 fail:
29125 return NULL;
29126 }
29127
29128
29129 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29130 PyObject *resultobj = 0;
29131 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29132 wxFont *arg2 = (wxFont *) 0 ;
29133 void *argp1 = 0 ;
29134 int res1 = 0 ;
29135 void *argp2 = 0 ;
29136 int res2 = 0 ;
29137 PyObject *swig_obj[2] ;
29138
29139 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29141 if (!SWIG_IsOK(res1)) {
29142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29143 }
29144 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29145 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29146 if (!SWIG_IsOK(res2)) {
29147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29148 }
29149 arg2 = reinterpret_cast< wxFont * >(argp2);
29150 if (arg1) (arg1)->font = *arg2;
29151
29152 resultobj = SWIG_Py_Void();
29153 return resultobj;
29154 fail:
29155 return NULL;
29156 }
29157
29158
29159 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29160 PyObject *resultobj = 0;
29161 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29162 wxFont *result = 0 ;
29163 void *argp1 = 0 ;
29164 int res1 = 0 ;
29165 PyObject *swig_obj[1] ;
29166
29167 if (!args) SWIG_fail;
29168 swig_obj[0] = args;
29169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29170 if (!SWIG_IsOK(res1)) {
29171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29172 }
29173 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29174 result = (wxFont *)& ((arg1)->font);
29175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29176 return resultobj;
29177 fail:
29178 return NULL;
29179 }
29180
29181
29182 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29183 PyObject *resultobj = 0;
29184 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29185 wxColour *arg2 = (wxColour *) 0 ;
29186 void *argp1 = 0 ;
29187 int res1 = 0 ;
29188 void *argp2 = 0 ;
29189 int res2 = 0 ;
29190 PyObject *swig_obj[2] ;
29191
29192 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29194 if (!SWIG_IsOK(res1)) {
29195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29196 }
29197 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29198 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29199 if (!SWIG_IsOK(res2)) {
29200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29201 }
29202 arg2 = reinterpret_cast< wxColour * >(argp2);
29203 if (arg1) (arg1)->colFg = *arg2;
29204
29205 resultobj = SWIG_Py_Void();
29206 return resultobj;
29207 fail:
29208 return NULL;
29209 }
29210
29211
29212 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29213 PyObject *resultobj = 0;
29214 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29215 wxColour *result = 0 ;
29216 void *argp1 = 0 ;
29217 int res1 = 0 ;
29218 PyObject *swig_obj[1] ;
29219
29220 if (!args) SWIG_fail;
29221 swig_obj[0] = args;
29222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29223 if (!SWIG_IsOK(res1)) {
29224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29225 }
29226 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29227 result = (wxColour *)& ((arg1)->colFg);
29228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29229 return resultobj;
29230 fail:
29231 return NULL;
29232 }
29233
29234
29235 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29236 PyObject *resultobj = 0;
29237 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29238 wxColour *arg2 = (wxColour *) 0 ;
29239 void *argp1 = 0 ;
29240 int res1 = 0 ;
29241 void *argp2 = 0 ;
29242 int res2 = 0 ;
29243 PyObject *swig_obj[2] ;
29244
29245 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29247 if (!SWIG_IsOK(res1)) {
29248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29249 }
29250 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29251 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29252 if (!SWIG_IsOK(res2)) {
29253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29254 }
29255 arg2 = reinterpret_cast< wxColour * >(argp2);
29256 if (arg1) (arg1)->colBg = *arg2;
29257
29258 resultobj = SWIG_Py_Void();
29259 return resultobj;
29260 fail:
29261 return NULL;
29262 }
29263
29264
29265 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29266 PyObject *resultobj = 0;
29267 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29268 wxColour *result = 0 ;
29269 void *argp1 = 0 ;
29270 int res1 = 0 ;
29271 PyObject *swig_obj[1] ;
29272
29273 if (!args) SWIG_fail;
29274 swig_obj[0] = args;
29275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29276 if (!SWIG_IsOK(res1)) {
29277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29278 }
29279 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29280 result = (wxColour *)& ((arg1)->colBg);
29281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29282 return resultobj;
29283 fail:
29284 return NULL;
29285 }
29286
29287
29288 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29289 PyObject *obj;
29290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29291 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29292 return SWIG_Py_Void();
29293 }
29294
29295 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29296 return SWIG_Python_InitShadowInstance(args);
29297 }
29298
29299 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29300 PyObject *resultobj = 0;
29301 wxWindow *arg1 = (wxWindow *) 0 ;
29302 int arg2 = (int) (int)-1 ;
29303 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29304 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29305 wxSize const &arg4_defvalue = wxDefaultSize ;
29306 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29307 long arg5 = (long) 0 ;
29308 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29309 wxString *arg6 = (wxString *) &arg6_defvalue ;
29310 wxWindow *result = 0 ;
29311 void *argp1 = 0 ;
29312 int res1 = 0 ;
29313 int val2 ;
29314 int ecode2 = 0 ;
29315 wxPoint temp3 ;
29316 wxSize temp4 ;
29317 long val5 ;
29318 int ecode5 = 0 ;
29319 bool temp6 = false ;
29320 PyObject * obj0 = 0 ;
29321 PyObject * obj1 = 0 ;
29322 PyObject * obj2 = 0 ;
29323 PyObject * obj3 = 0 ;
29324 PyObject * obj4 = 0 ;
29325 PyObject * obj5 = 0 ;
29326 char * kwnames[] = {
29327 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29328 };
29329
29330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29332 if (!SWIG_IsOK(res1)) {
29333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29334 }
29335 arg1 = reinterpret_cast< wxWindow * >(argp1);
29336 if (obj1) {
29337 ecode2 = SWIG_AsVal_int(obj1, &val2);
29338 if (!SWIG_IsOK(ecode2)) {
29339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29340 }
29341 arg2 = static_cast< int >(val2);
29342 }
29343 if (obj2) {
29344 {
29345 arg3 = &temp3;
29346 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29347 }
29348 }
29349 if (obj3) {
29350 {
29351 arg4 = &temp4;
29352 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29353 }
29354 }
29355 if (obj4) {
29356 ecode5 = SWIG_AsVal_long(obj4, &val5);
29357 if (!SWIG_IsOK(ecode5)) {
29358 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29359 }
29360 arg5 = static_cast< long >(val5);
29361 }
29362 if (obj5) {
29363 {
29364 arg6 = wxString_in_helper(obj5);
29365 if (arg6 == NULL) SWIG_fail;
29366 temp6 = true;
29367 }
29368 }
29369 {
29370 if (!wxPyCheckForApp()) SWIG_fail;
29371 PyThreadState* __tstate = wxPyBeginAllowThreads();
29372 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29373 wxPyEndAllowThreads(__tstate);
29374 if (PyErr_Occurred()) SWIG_fail;
29375 }
29376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29377 {
29378 if (temp6)
29379 delete arg6;
29380 }
29381 return resultobj;
29382 fail:
29383 {
29384 if (temp6)
29385 delete arg6;
29386 }
29387 return NULL;
29388 }
29389
29390
29391 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29392 PyObject *resultobj = 0;
29393 wxWindow *result = 0 ;
29394
29395 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29396 {
29397 if (!wxPyCheckForApp()) SWIG_fail;
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 result = (wxWindow *)new wxWindow();
29400 wxPyEndAllowThreads(__tstate);
29401 if (PyErr_Occurred()) SWIG_fail;
29402 }
29403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29411 PyObject *resultobj = 0;
29412 wxWindow *arg1 = (wxWindow *) 0 ;
29413 wxWindow *arg2 = (wxWindow *) 0 ;
29414 int arg3 = (int) (int)-1 ;
29415 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29416 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29417 wxSize const &arg5_defvalue = wxDefaultSize ;
29418 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29419 long arg6 = (long) 0 ;
29420 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29421 wxString *arg7 = (wxString *) &arg7_defvalue ;
29422 bool result;
29423 void *argp1 = 0 ;
29424 int res1 = 0 ;
29425 void *argp2 = 0 ;
29426 int res2 = 0 ;
29427 int val3 ;
29428 int ecode3 = 0 ;
29429 wxPoint temp4 ;
29430 wxSize temp5 ;
29431 long val6 ;
29432 int ecode6 = 0 ;
29433 bool temp7 = false ;
29434 PyObject * obj0 = 0 ;
29435 PyObject * obj1 = 0 ;
29436 PyObject * obj2 = 0 ;
29437 PyObject * obj3 = 0 ;
29438 PyObject * obj4 = 0 ;
29439 PyObject * obj5 = 0 ;
29440 PyObject * obj6 = 0 ;
29441 char * kwnames[] = {
29442 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29443 };
29444
29445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29447 if (!SWIG_IsOK(res1)) {
29448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29449 }
29450 arg1 = reinterpret_cast< wxWindow * >(argp1);
29451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29452 if (!SWIG_IsOK(res2)) {
29453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29454 }
29455 arg2 = reinterpret_cast< wxWindow * >(argp2);
29456 if (obj2) {
29457 ecode3 = SWIG_AsVal_int(obj2, &val3);
29458 if (!SWIG_IsOK(ecode3)) {
29459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29460 }
29461 arg3 = static_cast< int >(val3);
29462 }
29463 if (obj3) {
29464 {
29465 arg4 = &temp4;
29466 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29467 }
29468 }
29469 if (obj4) {
29470 {
29471 arg5 = &temp5;
29472 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29473 }
29474 }
29475 if (obj5) {
29476 ecode6 = SWIG_AsVal_long(obj5, &val6);
29477 if (!SWIG_IsOK(ecode6)) {
29478 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29479 }
29480 arg6 = static_cast< long >(val6);
29481 }
29482 if (obj6) {
29483 {
29484 arg7 = wxString_in_helper(obj6);
29485 if (arg7 == NULL) SWIG_fail;
29486 temp7 = true;
29487 }
29488 }
29489 {
29490 PyThreadState* __tstate = wxPyBeginAllowThreads();
29491 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29492 wxPyEndAllowThreads(__tstate);
29493 if (PyErr_Occurred()) SWIG_fail;
29494 }
29495 {
29496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29497 }
29498 {
29499 if (temp7)
29500 delete arg7;
29501 }
29502 return resultobj;
29503 fail:
29504 {
29505 if (temp7)
29506 delete arg7;
29507 }
29508 return NULL;
29509 }
29510
29511
29512 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29513 PyObject *resultobj = 0;
29514 wxWindow *arg1 = (wxWindow *) 0 ;
29515 bool arg2 = (bool) false ;
29516 bool result;
29517 void *argp1 = 0 ;
29518 int res1 = 0 ;
29519 bool val2 ;
29520 int ecode2 = 0 ;
29521 PyObject * obj0 = 0 ;
29522 PyObject * obj1 = 0 ;
29523 char * kwnames[] = {
29524 (char *) "self",(char *) "force", NULL
29525 };
29526
29527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29529 if (!SWIG_IsOK(res1)) {
29530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29531 }
29532 arg1 = reinterpret_cast< wxWindow * >(argp1);
29533 if (obj1) {
29534 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29535 if (!SWIG_IsOK(ecode2)) {
29536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29537 }
29538 arg2 = static_cast< bool >(val2);
29539 }
29540 {
29541 PyThreadState* __tstate = wxPyBeginAllowThreads();
29542 result = (bool)(arg1)->Close(arg2);
29543 wxPyEndAllowThreads(__tstate);
29544 if (PyErr_Occurred()) SWIG_fail;
29545 }
29546 {
29547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29548 }
29549 return resultobj;
29550 fail:
29551 return NULL;
29552 }
29553
29554
29555 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29556 PyObject *resultobj = 0;
29557 wxWindow *arg1 = (wxWindow *) 0 ;
29558 bool result;
29559 void *argp1 = 0 ;
29560 int res1 = 0 ;
29561 PyObject *swig_obj[1] ;
29562
29563 if (!args) SWIG_fail;
29564 swig_obj[0] = args;
29565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29566 if (!SWIG_IsOK(res1)) {
29567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29568 }
29569 arg1 = reinterpret_cast< wxWindow * >(argp1);
29570 {
29571 PyThreadState* __tstate = wxPyBeginAllowThreads();
29572 result = (bool)(arg1)->Destroy();
29573 wxPyEndAllowThreads(__tstate);
29574 if (PyErr_Occurred()) SWIG_fail;
29575 }
29576 {
29577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29578 }
29579 return resultobj;
29580 fail:
29581 return NULL;
29582 }
29583
29584
29585 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29586 PyObject *resultobj = 0;
29587 wxWindow *arg1 = (wxWindow *) 0 ;
29588 bool result;
29589 void *argp1 = 0 ;
29590 int res1 = 0 ;
29591 PyObject *swig_obj[1] ;
29592
29593 if (!args) SWIG_fail;
29594 swig_obj[0] = args;
29595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29596 if (!SWIG_IsOK(res1)) {
29597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29598 }
29599 arg1 = reinterpret_cast< wxWindow * >(argp1);
29600 {
29601 PyThreadState* __tstate = wxPyBeginAllowThreads();
29602 result = (bool)(arg1)->DestroyChildren();
29603 wxPyEndAllowThreads(__tstate);
29604 if (PyErr_Occurred()) SWIG_fail;
29605 }
29606 {
29607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29608 }
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29616 PyObject *resultobj = 0;
29617 wxWindow *arg1 = (wxWindow *) 0 ;
29618 bool result;
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_wxWindow, 0 | 0 );
29626 if (!SWIG_IsOK(res1)) {
29627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29628 }
29629 arg1 = reinterpret_cast< wxWindow * >(argp1);
29630 {
29631 PyThreadState* __tstate = wxPyBeginAllowThreads();
29632 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29633 wxPyEndAllowThreads(__tstate);
29634 if (PyErr_Occurred()) SWIG_fail;
29635 }
29636 {
29637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29638 }
29639 return resultobj;
29640 fail:
29641 return NULL;
29642 }
29643
29644
29645 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29646 PyObject *resultobj = 0;
29647 wxWindow *arg1 = (wxWindow *) 0 ;
29648 wxString *arg2 = 0 ;
29649 void *argp1 = 0 ;
29650 int res1 = 0 ;
29651 bool temp2 = false ;
29652 PyObject * obj0 = 0 ;
29653 PyObject * obj1 = 0 ;
29654 char * kwnames[] = {
29655 (char *) "self",(char *) "label", NULL
29656 };
29657
29658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29660 if (!SWIG_IsOK(res1)) {
29661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29662 }
29663 arg1 = reinterpret_cast< wxWindow * >(argp1);
29664 {
29665 arg2 = wxString_in_helper(obj1);
29666 if (arg2 == NULL) SWIG_fail;
29667 temp2 = true;
29668 }
29669 {
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 (arg1)->SetLabel((wxString const &)*arg2);
29672 wxPyEndAllowThreads(__tstate);
29673 if (PyErr_Occurred()) SWIG_fail;
29674 }
29675 resultobj = SWIG_Py_Void();
29676 {
29677 if (temp2)
29678 delete arg2;
29679 }
29680 return resultobj;
29681 fail:
29682 {
29683 if (temp2)
29684 delete arg2;
29685 }
29686 return NULL;
29687 }
29688
29689
29690 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29691 PyObject *resultobj = 0;
29692 wxWindow *arg1 = (wxWindow *) 0 ;
29693 wxString result;
29694 void *argp1 = 0 ;
29695 int res1 = 0 ;
29696 PyObject *swig_obj[1] ;
29697
29698 if (!args) SWIG_fail;
29699 swig_obj[0] = args;
29700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29701 if (!SWIG_IsOK(res1)) {
29702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29703 }
29704 arg1 = reinterpret_cast< wxWindow * >(argp1);
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 result = ((wxWindow const *)arg1)->GetLabel();
29708 wxPyEndAllowThreads(__tstate);
29709 if (PyErr_Occurred()) SWIG_fail;
29710 }
29711 {
29712 #if wxUSE_UNICODE
29713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29714 #else
29715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29716 #endif
29717 }
29718 return resultobj;
29719 fail:
29720 return NULL;
29721 }
29722
29723
29724 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29725 PyObject *resultobj = 0;
29726 wxWindow *arg1 = (wxWindow *) 0 ;
29727 wxString *arg2 = 0 ;
29728 void *argp1 = 0 ;
29729 int res1 = 0 ;
29730 bool temp2 = false ;
29731 PyObject * obj0 = 0 ;
29732 PyObject * obj1 = 0 ;
29733 char * kwnames[] = {
29734 (char *) "self",(char *) "name", NULL
29735 };
29736
29737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29739 if (!SWIG_IsOK(res1)) {
29740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29741 }
29742 arg1 = reinterpret_cast< wxWindow * >(argp1);
29743 {
29744 arg2 = wxString_in_helper(obj1);
29745 if (arg2 == NULL) SWIG_fail;
29746 temp2 = true;
29747 }
29748 {
29749 PyThreadState* __tstate = wxPyBeginAllowThreads();
29750 (arg1)->SetName((wxString const &)*arg2);
29751 wxPyEndAllowThreads(__tstate);
29752 if (PyErr_Occurred()) SWIG_fail;
29753 }
29754 resultobj = SWIG_Py_Void();
29755 {
29756 if (temp2)
29757 delete arg2;
29758 }
29759 return resultobj;
29760 fail:
29761 {
29762 if (temp2)
29763 delete arg2;
29764 }
29765 return NULL;
29766 }
29767
29768
29769 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29770 PyObject *resultobj = 0;
29771 wxWindow *arg1 = (wxWindow *) 0 ;
29772 wxString result;
29773 void *argp1 = 0 ;
29774 int res1 = 0 ;
29775 PyObject *swig_obj[1] ;
29776
29777 if (!args) SWIG_fail;
29778 swig_obj[0] = args;
29779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29780 if (!SWIG_IsOK(res1)) {
29781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29782 }
29783 arg1 = reinterpret_cast< wxWindow * >(argp1);
29784 {
29785 PyThreadState* __tstate = wxPyBeginAllowThreads();
29786 result = ((wxWindow const *)arg1)->GetName();
29787 wxPyEndAllowThreads(__tstate);
29788 if (PyErr_Occurred()) SWIG_fail;
29789 }
29790 {
29791 #if wxUSE_UNICODE
29792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29793 #else
29794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29795 #endif
29796 }
29797 return resultobj;
29798 fail:
29799 return NULL;
29800 }
29801
29802
29803 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29804 PyObject *resultobj = 0;
29805 wxWindow *arg1 = (wxWindow *) 0 ;
29806 wxWindowVariant arg2 ;
29807 void *argp1 = 0 ;
29808 int res1 = 0 ;
29809 int val2 ;
29810 int ecode2 = 0 ;
29811 PyObject * obj0 = 0 ;
29812 PyObject * obj1 = 0 ;
29813 char * kwnames[] = {
29814 (char *) "self",(char *) "variant", NULL
29815 };
29816
29817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29819 if (!SWIG_IsOK(res1)) {
29820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29821 }
29822 arg1 = reinterpret_cast< wxWindow * >(argp1);
29823 ecode2 = SWIG_AsVal_int(obj1, &val2);
29824 if (!SWIG_IsOK(ecode2)) {
29825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29826 }
29827 arg2 = static_cast< wxWindowVariant >(val2);
29828 {
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 (arg1)->SetWindowVariant(arg2);
29831 wxPyEndAllowThreads(__tstate);
29832 if (PyErr_Occurred()) SWIG_fail;
29833 }
29834 resultobj = SWIG_Py_Void();
29835 return resultobj;
29836 fail:
29837 return NULL;
29838 }
29839
29840
29841 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29842 PyObject *resultobj = 0;
29843 wxWindow *arg1 = (wxWindow *) 0 ;
29844 wxWindowVariant result;
29845 void *argp1 = 0 ;
29846 int res1 = 0 ;
29847 PyObject *swig_obj[1] ;
29848
29849 if (!args) SWIG_fail;
29850 swig_obj[0] = args;
29851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29852 if (!SWIG_IsOK(res1)) {
29853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29854 }
29855 arg1 = reinterpret_cast< wxWindow * >(argp1);
29856 {
29857 PyThreadState* __tstate = wxPyBeginAllowThreads();
29858 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29859 wxPyEndAllowThreads(__tstate);
29860 if (PyErr_Occurred()) SWIG_fail;
29861 }
29862 resultobj = SWIG_From_int(static_cast< int >(result));
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29870 PyObject *resultobj = 0;
29871 wxWindow *arg1 = (wxWindow *) 0 ;
29872 int arg2 ;
29873 void *argp1 = 0 ;
29874 int res1 = 0 ;
29875 int val2 ;
29876 int ecode2 = 0 ;
29877 PyObject * obj0 = 0 ;
29878 PyObject * obj1 = 0 ;
29879 char * kwnames[] = {
29880 (char *) "self",(char *) "winid", NULL
29881 };
29882
29883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29885 if (!SWIG_IsOK(res1)) {
29886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29887 }
29888 arg1 = reinterpret_cast< wxWindow * >(argp1);
29889 ecode2 = SWIG_AsVal_int(obj1, &val2);
29890 if (!SWIG_IsOK(ecode2)) {
29891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29892 }
29893 arg2 = static_cast< int >(val2);
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 (arg1)->SetId(arg2);
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 resultobj = SWIG_Py_Void();
29901 return resultobj;
29902 fail:
29903 return NULL;
29904 }
29905
29906
29907 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29908 PyObject *resultobj = 0;
29909 wxWindow *arg1 = (wxWindow *) 0 ;
29910 int result;
29911 void *argp1 = 0 ;
29912 int res1 = 0 ;
29913 PyObject *swig_obj[1] ;
29914
29915 if (!args) SWIG_fail;
29916 swig_obj[0] = args;
29917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29918 if (!SWIG_IsOK(res1)) {
29919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29920 }
29921 arg1 = reinterpret_cast< wxWindow * >(argp1);
29922 {
29923 PyThreadState* __tstate = wxPyBeginAllowThreads();
29924 result = (int)((wxWindow const *)arg1)->GetId();
29925 wxPyEndAllowThreads(__tstate);
29926 if (PyErr_Occurred()) SWIG_fail;
29927 }
29928 resultobj = SWIG_From_int(static_cast< int >(result));
29929 return resultobj;
29930 fail:
29931 return NULL;
29932 }
29933
29934
29935 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29936 PyObject *resultobj = 0;
29937 int result;
29938
29939 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 result = (int)wxWindow::NewControlId();
29943 wxPyEndAllowThreads(__tstate);
29944 if (PyErr_Occurred()) SWIG_fail;
29945 }
29946 resultobj = SWIG_From_int(static_cast< int >(result));
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj = 0;
29955 int arg1 ;
29956 int result;
29957 int val1 ;
29958 int ecode1 = 0 ;
29959 PyObject * obj0 = 0 ;
29960 char * kwnames[] = {
29961 (char *) "winid", NULL
29962 };
29963
29964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
29965 ecode1 = SWIG_AsVal_int(obj0, &val1);
29966 if (!SWIG_IsOK(ecode1)) {
29967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
29968 }
29969 arg1 = static_cast< int >(val1);
29970 {
29971 PyThreadState* __tstate = wxPyBeginAllowThreads();
29972 result = (int)wxWindow::NextControlId(arg1);
29973 wxPyEndAllowThreads(__tstate);
29974 if (PyErr_Occurred()) SWIG_fail;
29975 }
29976 resultobj = SWIG_From_int(static_cast< int >(result));
29977 return resultobj;
29978 fail:
29979 return NULL;
29980 }
29981
29982
29983 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29984 PyObject *resultobj = 0;
29985 int arg1 ;
29986 int result;
29987 int val1 ;
29988 int ecode1 = 0 ;
29989 PyObject * obj0 = 0 ;
29990 char * kwnames[] = {
29991 (char *) "winid", NULL
29992 };
29993
29994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
29995 ecode1 = SWIG_AsVal_int(obj0, &val1);
29996 if (!SWIG_IsOK(ecode1)) {
29997 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
29998 }
29999 arg1 = static_cast< int >(val1);
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 result = (int)wxWindow::PrevControlId(arg1);
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 resultobj = SWIG_From_int(static_cast< int >(result));
30007 return resultobj;
30008 fail:
30009 return NULL;
30010 }
30011
30012
30013 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30014 PyObject *resultobj = 0;
30015 wxWindow *arg1 = (wxWindow *) 0 ;
30016 wxSize *arg2 = 0 ;
30017 void *argp1 = 0 ;
30018 int res1 = 0 ;
30019 wxSize temp2 ;
30020 PyObject * obj0 = 0 ;
30021 PyObject * obj1 = 0 ;
30022 char * kwnames[] = {
30023 (char *) "self",(char *) "size", NULL
30024 };
30025
30026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30028 if (!SWIG_IsOK(res1)) {
30029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30030 }
30031 arg1 = reinterpret_cast< wxWindow * >(argp1);
30032 {
30033 arg2 = &temp2;
30034 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30035 }
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 (arg1)->SetSize((wxSize const &)*arg2);
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 resultobj = SWIG_Py_Void();
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30050 PyObject *resultobj = 0;
30051 wxWindow *arg1 = (wxWindow *) 0 ;
30052 int arg2 ;
30053 int arg3 ;
30054 int arg4 ;
30055 int arg5 ;
30056 int arg6 = (int) wxSIZE_AUTO ;
30057 void *argp1 = 0 ;
30058 int res1 = 0 ;
30059 int val2 ;
30060 int ecode2 = 0 ;
30061 int val3 ;
30062 int ecode3 = 0 ;
30063 int val4 ;
30064 int ecode4 = 0 ;
30065 int val5 ;
30066 int ecode5 = 0 ;
30067 int val6 ;
30068 int ecode6 = 0 ;
30069 PyObject * obj0 = 0 ;
30070 PyObject * obj1 = 0 ;
30071 PyObject * obj2 = 0 ;
30072 PyObject * obj3 = 0 ;
30073 PyObject * obj4 = 0 ;
30074 PyObject * obj5 = 0 ;
30075 char * kwnames[] = {
30076 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30077 };
30078
30079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30081 if (!SWIG_IsOK(res1)) {
30082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30083 }
30084 arg1 = reinterpret_cast< wxWindow * >(argp1);
30085 ecode2 = SWIG_AsVal_int(obj1, &val2);
30086 if (!SWIG_IsOK(ecode2)) {
30087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30088 }
30089 arg2 = static_cast< int >(val2);
30090 ecode3 = SWIG_AsVal_int(obj2, &val3);
30091 if (!SWIG_IsOK(ecode3)) {
30092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30093 }
30094 arg3 = static_cast< int >(val3);
30095 ecode4 = SWIG_AsVal_int(obj3, &val4);
30096 if (!SWIG_IsOK(ecode4)) {
30097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30098 }
30099 arg4 = static_cast< int >(val4);
30100 ecode5 = SWIG_AsVal_int(obj4, &val5);
30101 if (!SWIG_IsOK(ecode5)) {
30102 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30103 }
30104 arg5 = static_cast< int >(val5);
30105 if (obj5) {
30106 ecode6 = SWIG_AsVal_int(obj5, &val6);
30107 if (!SWIG_IsOK(ecode6)) {
30108 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30109 }
30110 arg6 = static_cast< int >(val6);
30111 }
30112 {
30113 PyThreadState* __tstate = wxPyBeginAllowThreads();
30114 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30115 wxPyEndAllowThreads(__tstate);
30116 if (PyErr_Occurred()) SWIG_fail;
30117 }
30118 resultobj = SWIG_Py_Void();
30119 return resultobj;
30120 fail:
30121 return NULL;
30122 }
30123
30124
30125 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30126 PyObject *resultobj = 0;
30127 wxWindow *arg1 = (wxWindow *) 0 ;
30128 wxRect *arg2 = 0 ;
30129 int arg3 = (int) wxSIZE_AUTO ;
30130 void *argp1 = 0 ;
30131 int res1 = 0 ;
30132 wxRect temp2 ;
30133 int val3 ;
30134 int ecode3 = 0 ;
30135 PyObject * obj0 = 0 ;
30136 PyObject * obj1 = 0 ;
30137 PyObject * obj2 = 0 ;
30138 char * kwnames[] = {
30139 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30140 };
30141
30142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30144 if (!SWIG_IsOK(res1)) {
30145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30146 }
30147 arg1 = reinterpret_cast< wxWindow * >(argp1);
30148 {
30149 arg2 = &temp2;
30150 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30151 }
30152 if (obj2) {
30153 ecode3 = SWIG_AsVal_int(obj2, &val3);
30154 if (!SWIG_IsOK(ecode3)) {
30155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30156 }
30157 arg3 = static_cast< int >(val3);
30158 }
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 resultobj = SWIG_Py_Void();
30166 return resultobj;
30167 fail:
30168 return NULL;
30169 }
30170
30171
30172 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30173 PyObject *resultobj = 0;
30174 wxWindow *arg1 = (wxWindow *) 0 ;
30175 int arg2 ;
30176 int arg3 ;
30177 void *argp1 = 0 ;
30178 int res1 = 0 ;
30179 int val2 ;
30180 int ecode2 = 0 ;
30181 int val3 ;
30182 int ecode3 = 0 ;
30183 PyObject * obj0 = 0 ;
30184 PyObject * obj1 = 0 ;
30185 PyObject * obj2 = 0 ;
30186 char * kwnames[] = {
30187 (char *) "self",(char *) "width",(char *) "height", NULL
30188 };
30189
30190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30192 if (!SWIG_IsOK(res1)) {
30193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30194 }
30195 arg1 = reinterpret_cast< wxWindow * >(argp1);
30196 ecode2 = SWIG_AsVal_int(obj1, &val2);
30197 if (!SWIG_IsOK(ecode2)) {
30198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30199 }
30200 arg2 = static_cast< int >(val2);
30201 ecode3 = SWIG_AsVal_int(obj2, &val3);
30202 if (!SWIG_IsOK(ecode3)) {
30203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30204 }
30205 arg3 = static_cast< int >(val3);
30206 {
30207 PyThreadState* __tstate = wxPyBeginAllowThreads();
30208 (arg1)->SetSize(arg2,arg3);
30209 wxPyEndAllowThreads(__tstate);
30210 if (PyErr_Occurred()) SWIG_fail;
30211 }
30212 resultobj = SWIG_Py_Void();
30213 return resultobj;
30214 fail:
30215 return NULL;
30216 }
30217
30218
30219 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30220 PyObject *resultobj = 0;
30221 wxWindow *arg1 = (wxWindow *) 0 ;
30222 wxPoint *arg2 = 0 ;
30223 int arg3 = (int) wxSIZE_USE_EXISTING ;
30224 void *argp1 = 0 ;
30225 int res1 = 0 ;
30226 wxPoint temp2 ;
30227 int val3 ;
30228 int ecode3 = 0 ;
30229 PyObject * obj0 = 0 ;
30230 PyObject * obj1 = 0 ;
30231 PyObject * obj2 = 0 ;
30232 char * kwnames[] = {
30233 (char *) "self",(char *) "pt",(char *) "flags", NULL
30234 };
30235
30236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30238 if (!SWIG_IsOK(res1)) {
30239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30240 }
30241 arg1 = reinterpret_cast< wxWindow * >(argp1);
30242 {
30243 arg2 = &temp2;
30244 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30245 }
30246 if (obj2) {
30247 ecode3 = SWIG_AsVal_int(obj2, &val3);
30248 if (!SWIG_IsOK(ecode3)) {
30249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30250 }
30251 arg3 = static_cast< int >(val3);
30252 }
30253 {
30254 PyThreadState* __tstate = wxPyBeginAllowThreads();
30255 (arg1)->Move((wxPoint const &)*arg2,arg3);
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 resultobj = SWIG_Py_Void();
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30267 PyObject *resultobj = 0;
30268 wxWindow *arg1 = (wxWindow *) 0 ;
30269 int arg2 ;
30270 int arg3 ;
30271 int arg4 = (int) wxSIZE_USE_EXISTING ;
30272 void *argp1 = 0 ;
30273 int res1 = 0 ;
30274 int val2 ;
30275 int ecode2 = 0 ;
30276 int val3 ;
30277 int ecode3 = 0 ;
30278 int val4 ;
30279 int ecode4 = 0 ;
30280 PyObject * obj0 = 0 ;
30281 PyObject * obj1 = 0 ;
30282 PyObject * obj2 = 0 ;
30283 PyObject * obj3 = 0 ;
30284 char * kwnames[] = {
30285 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30286 };
30287
30288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30290 if (!SWIG_IsOK(res1)) {
30291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30292 }
30293 arg1 = reinterpret_cast< wxWindow * >(argp1);
30294 ecode2 = SWIG_AsVal_int(obj1, &val2);
30295 if (!SWIG_IsOK(ecode2)) {
30296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30297 }
30298 arg2 = static_cast< int >(val2);
30299 ecode3 = SWIG_AsVal_int(obj2, &val3);
30300 if (!SWIG_IsOK(ecode3)) {
30301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30302 }
30303 arg3 = static_cast< int >(val3);
30304 if (obj3) {
30305 ecode4 = SWIG_AsVal_int(obj3, &val4);
30306 if (!SWIG_IsOK(ecode4)) {
30307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30308 }
30309 arg4 = static_cast< int >(val4);
30310 }
30311 {
30312 PyThreadState* __tstate = wxPyBeginAllowThreads();
30313 (arg1)->Move(arg2,arg3,arg4);
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 resultobj = SWIG_Py_Void();
30318 return resultobj;
30319 fail:
30320 return NULL;
30321 }
30322
30323
30324 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30325 PyObject *resultobj = 0;
30326 wxWindow *arg1 = (wxWindow *) 0 ;
30327 wxSize const &arg2_defvalue = wxDefaultSize ;
30328 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30329 void *argp1 = 0 ;
30330 int res1 = 0 ;
30331 wxSize temp2 ;
30332 PyObject * obj0 = 0 ;
30333 PyObject * obj1 = 0 ;
30334 char * kwnames[] = {
30335 (char *) "self",(char *) "size", NULL
30336 };
30337
30338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30340 if (!SWIG_IsOK(res1)) {
30341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30342 }
30343 arg1 = reinterpret_cast< wxWindow * >(argp1);
30344 if (obj1) {
30345 {
30346 arg2 = &temp2;
30347 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30348 }
30349 }
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 (arg1)->SetBestFittingSize((wxSize const &)*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_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30364 PyObject *resultobj = 0;
30365 wxWindow *arg1 = (wxWindow *) 0 ;
30366 void *argp1 = 0 ;
30367 int res1 = 0 ;
30368 PyObject *swig_obj[1] ;
30369
30370 if (!args) SWIG_fail;
30371 swig_obj[0] = args;
30372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30373 if (!SWIG_IsOK(res1)) {
30374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30375 }
30376 arg1 = reinterpret_cast< wxWindow * >(argp1);
30377 {
30378 PyThreadState* __tstate = wxPyBeginAllowThreads();
30379 (arg1)->Raise();
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 resultobj = SWIG_Py_Void();
30384 return resultobj;
30385 fail:
30386 return NULL;
30387 }
30388
30389
30390 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30391 PyObject *resultobj = 0;
30392 wxWindow *arg1 = (wxWindow *) 0 ;
30393 void *argp1 = 0 ;
30394 int res1 = 0 ;
30395 PyObject *swig_obj[1] ;
30396
30397 if (!args) SWIG_fail;
30398 swig_obj[0] = args;
30399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30400 if (!SWIG_IsOK(res1)) {
30401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30402 }
30403 arg1 = reinterpret_cast< wxWindow * >(argp1);
30404 {
30405 PyThreadState* __tstate = wxPyBeginAllowThreads();
30406 (arg1)->Lower();
30407 wxPyEndAllowThreads(__tstate);
30408 if (PyErr_Occurred()) SWIG_fail;
30409 }
30410 resultobj = SWIG_Py_Void();
30411 return resultobj;
30412 fail:
30413 return NULL;
30414 }
30415
30416
30417 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30418 PyObject *resultobj = 0;
30419 wxWindow *arg1 = (wxWindow *) 0 ;
30420 wxSize *arg2 = 0 ;
30421 void *argp1 = 0 ;
30422 int res1 = 0 ;
30423 wxSize temp2 ;
30424 PyObject * obj0 = 0 ;
30425 PyObject * obj1 = 0 ;
30426 char * kwnames[] = {
30427 (char *) "self",(char *) "size", NULL
30428 };
30429
30430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30432 if (!SWIG_IsOK(res1)) {
30433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30434 }
30435 arg1 = reinterpret_cast< wxWindow * >(argp1);
30436 {
30437 arg2 = &temp2;
30438 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30439 }
30440 {
30441 PyThreadState* __tstate = wxPyBeginAllowThreads();
30442 (arg1)->SetClientSize((wxSize const &)*arg2);
30443 wxPyEndAllowThreads(__tstate);
30444 if (PyErr_Occurred()) SWIG_fail;
30445 }
30446 resultobj = SWIG_Py_Void();
30447 return resultobj;
30448 fail:
30449 return NULL;
30450 }
30451
30452
30453 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30454 PyObject *resultobj = 0;
30455 wxWindow *arg1 = (wxWindow *) 0 ;
30456 int arg2 ;
30457 int arg3 ;
30458 void *argp1 = 0 ;
30459 int res1 = 0 ;
30460 int val2 ;
30461 int ecode2 = 0 ;
30462 int val3 ;
30463 int ecode3 = 0 ;
30464 PyObject * obj0 = 0 ;
30465 PyObject * obj1 = 0 ;
30466 PyObject * obj2 = 0 ;
30467 char * kwnames[] = {
30468 (char *) "self",(char *) "width",(char *) "height", NULL
30469 };
30470
30471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30473 if (!SWIG_IsOK(res1)) {
30474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30475 }
30476 arg1 = reinterpret_cast< wxWindow * >(argp1);
30477 ecode2 = SWIG_AsVal_int(obj1, &val2);
30478 if (!SWIG_IsOK(ecode2)) {
30479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30480 }
30481 arg2 = static_cast< int >(val2);
30482 ecode3 = SWIG_AsVal_int(obj2, &val3);
30483 if (!SWIG_IsOK(ecode3)) {
30484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30485 }
30486 arg3 = static_cast< int >(val3);
30487 {
30488 PyThreadState* __tstate = wxPyBeginAllowThreads();
30489 (arg1)->SetClientSize(arg2,arg3);
30490 wxPyEndAllowThreads(__tstate);
30491 if (PyErr_Occurred()) SWIG_fail;
30492 }
30493 resultobj = SWIG_Py_Void();
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30501 PyObject *resultobj = 0;
30502 wxWindow *arg1 = (wxWindow *) 0 ;
30503 wxRect *arg2 = 0 ;
30504 void *argp1 = 0 ;
30505 int res1 = 0 ;
30506 wxRect temp2 ;
30507 PyObject * obj0 = 0 ;
30508 PyObject * obj1 = 0 ;
30509 char * kwnames[] = {
30510 (char *) "self",(char *) "rect", NULL
30511 };
30512
30513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30515 if (!SWIG_IsOK(res1)) {
30516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30517 }
30518 arg1 = reinterpret_cast< wxWindow * >(argp1);
30519 {
30520 arg2 = &temp2;
30521 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30522 }
30523 {
30524 PyThreadState* __tstate = wxPyBeginAllowThreads();
30525 (arg1)->SetClientSize((wxRect const &)*arg2);
30526 wxPyEndAllowThreads(__tstate);
30527 if (PyErr_Occurred()) SWIG_fail;
30528 }
30529 resultobj = SWIG_Py_Void();
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30537 PyObject *resultobj = 0;
30538 wxWindow *arg1 = (wxWindow *) 0 ;
30539 wxPoint result;
30540 void *argp1 = 0 ;
30541 int res1 = 0 ;
30542 PyObject *swig_obj[1] ;
30543
30544 if (!args) SWIG_fail;
30545 swig_obj[0] = args;
30546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30547 if (!SWIG_IsOK(res1)) {
30548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30549 }
30550 arg1 = reinterpret_cast< wxWindow * >(argp1);
30551 {
30552 PyThreadState* __tstate = wxPyBeginAllowThreads();
30553 result = ((wxWindow const *)arg1)->GetPosition();
30554 wxPyEndAllowThreads(__tstate);
30555 if (PyErr_Occurred()) SWIG_fail;
30556 }
30557 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30558 return resultobj;
30559 fail:
30560 return NULL;
30561 }
30562
30563
30564 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30565 PyObject *resultobj = 0;
30566 wxWindow *arg1 = (wxWindow *) 0 ;
30567 int *arg2 = (int *) 0 ;
30568 int *arg3 = (int *) 0 ;
30569 void *argp1 = 0 ;
30570 int res1 = 0 ;
30571 int temp2 ;
30572 int res2 = SWIG_TMPOBJ ;
30573 int temp3 ;
30574 int res3 = SWIG_TMPOBJ ;
30575 PyObject *swig_obj[1] ;
30576
30577 arg2 = &temp2;
30578 arg3 = &temp3;
30579 if (!args) SWIG_fail;
30580 swig_obj[0] = args;
30581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30582 if (!SWIG_IsOK(res1)) {
30583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30584 }
30585 arg1 = reinterpret_cast< wxWindow * >(argp1);
30586 {
30587 PyThreadState* __tstate = wxPyBeginAllowThreads();
30588 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30589 wxPyEndAllowThreads(__tstate);
30590 if (PyErr_Occurred()) SWIG_fail;
30591 }
30592 resultobj = SWIG_Py_Void();
30593 if (SWIG_IsTmpObj(res2)) {
30594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30595 } else {
30596 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30598 }
30599 if (SWIG_IsTmpObj(res3)) {
30600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30601 } else {
30602 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30604 }
30605 return resultobj;
30606 fail:
30607 return NULL;
30608 }
30609
30610
30611 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30612 PyObject *resultobj = 0;
30613 wxWindow *arg1 = (wxWindow *) 0 ;
30614 wxPoint result;
30615 void *argp1 = 0 ;
30616 int res1 = 0 ;
30617 PyObject *swig_obj[1] ;
30618
30619 if (!args) SWIG_fail;
30620 swig_obj[0] = args;
30621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30622 if (!SWIG_IsOK(res1)) {
30623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30624 }
30625 arg1 = reinterpret_cast< wxWindow * >(argp1);
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 result = ((wxWindow const *)arg1)->GetScreenPosition();
30629 wxPyEndAllowThreads(__tstate);
30630 if (PyErr_Occurred()) SWIG_fail;
30631 }
30632 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30633 return resultobj;
30634 fail:
30635 return NULL;
30636 }
30637
30638
30639 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30640 PyObject *resultobj = 0;
30641 wxWindow *arg1 = (wxWindow *) 0 ;
30642 int *arg2 = (int *) 0 ;
30643 int *arg3 = (int *) 0 ;
30644 void *argp1 = 0 ;
30645 int res1 = 0 ;
30646 int temp2 ;
30647 int res2 = SWIG_TMPOBJ ;
30648 int temp3 ;
30649 int res3 = SWIG_TMPOBJ ;
30650 PyObject *swig_obj[1] ;
30651
30652 arg2 = &temp2;
30653 arg3 = &temp3;
30654 if (!args) SWIG_fail;
30655 swig_obj[0] = args;
30656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30657 if (!SWIG_IsOK(res1)) {
30658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30659 }
30660 arg1 = reinterpret_cast< wxWindow * >(argp1);
30661 {
30662 PyThreadState* __tstate = wxPyBeginAllowThreads();
30663 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30664 wxPyEndAllowThreads(__tstate);
30665 if (PyErr_Occurred()) SWIG_fail;
30666 }
30667 resultobj = SWIG_Py_Void();
30668 if (SWIG_IsTmpObj(res2)) {
30669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30670 } else {
30671 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30673 }
30674 if (SWIG_IsTmpObj(res3)) {
30675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30676 } else {
30677 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30679 }
30680 return resultobj;
30681 fail:
30682 return NULL;
30683 }
30684
30685
30686 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30687 PyObject *resultobj = 0;
30688 wxWindow *arg1 = (wxWindow *) 0 ;
30689 wxRect result;
30690 void *argp1 = 0 ;
30691 int res1 = 0 ;
30692 PyObject *swig_obj[1] ;
30693
30694 if (!args) SWIG_fail;
30695 swig_obj[0] = args;
30696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30697 if (!SWIG_IsOK(res1)) {
30698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30699 }
30700 arg1 = reinterpret_cast< wxWindow * >(argp1);
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 result = ((wxWindow const *)arg1)->GetScreenRect();
30704 wxPyEndAllowThreads(__tstate);
30705 if (PyErr_Occurred()) SWIG_fail;
30706 }
30707 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30708 return resultobj;
30709 fail:
30710 return NULL;
30711 }
30712
30713
30714 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30715 PyObject *resultobj = 0;
30716 wxWindow *arg1 = (wxWindow *) 0 ;
30717 wxSize result;
30718 void *argp1 = 0 ;
30719 int res1 = 0 ;
30720 PyObject *swig_obj[1] ;
30721
30722 if (!args) SWIG_fail;
30723 swig_obj[0] = args;
30724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30725 if (!SWIG_IsOK(res1)) {
30726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30727 }
30728 arg1 = reinterpret_cast< wxWindow * >(argp1);
30729 {
30730 PyThreadState* __tstate = wxPyBeginAllowThreads();
30731 result = ((wxWindow const *)arg1)->GetSize();
30732 wxPyEndAllowThreads(__tstate);
30733 if (PyErr_Occurred()) SWIG_fail;
30734 }
30735 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30743 PyObject *resultobj = 0;
30744 wxWindow *arg1 = (wxWindow *) 0 ;
30745 int *arg2 = (int *) 0 ;
30746 int *arg3 = (int *) 0 ;
30747 void *argp1 = 0 ;
30748 int res1 = 0 ;
30749 int temp2 ;
30750 int res2 = SWIG_TMPOBJ ;
30751 int temp3 ;
30752 int res3 = SWIG_TMPOBJ ;
30753 PyObject *swig_obj[1] ;
30754
30755 arg2 = &temp2;
30756 arg3 = &temp3;
30757 if (!args) SWIG_fail;
30758 swig_obj[0] = args;
30759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30760 if (!SWIG_IsOK(res1)) {
30761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30762 }
30763 arg1 = reinterpret_cast< wxWindow * >(argp1);
30764 {
30765 PyThreadState* __tstate = wxPyBeginAllowThreads();
30766 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30767 wxPyEndAllowThreads(__tstate);
30768 if (PyErr_Occurred()) SWIG_fail;
30769 }
30770 resultobj = SWIG_Py_Void();
30771 if (SWIG_IsTmpObj(res2)) {
30772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30773 } else {
30774 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30776 }
30777 if (SWIG_IsTmpObj(res3)) {
30778 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30779 } else {
30780 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30781 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30782 }
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30790 PyObject *resultobj = 0;
30791 wxWindow *arg1 = (wxWindow *) 0 ;
30792 wxRect result;
30793 void *argp1 = 0 ;
30794 int res1 = 0 ;
30795 PyObject *swig_obj[1] ;
30796
30797 if (!args) SWIG_fail;
30798 swig_obj[0] = args;
30799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30800 if (!SWIG_IsOK(res1)) {
30801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30802 }
30803 arg1 = reinterpret_cast< wxWindow * >(argp1);
30804 {
30805 PyThreadState* __tstate = wxPyBeginAllowThreads();
30806 result = ((wxWindow const *)arg1)->GetRect();
30807 wxPyEndAllowThreads(__tstate);
30808 if (PyErr_Occurred()) SWIG_fail;
30809 }
30810 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30811 return resultobj;
30812 fail:
30813 return NULL;
30814 }
30815
30816
30817 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30818 PyObject *resultobj = 0;
30819 wxWindow *arg1 = (wxWindow *) 0 ;
30820 wxSize result;
30821 void *argp1 = 0 ;
30822 int res1 = 0 ;
30823 PyObject *swig_obj[1] ;
30824
30825 if (!args) SWIG_fail;
30826 swig_obj[0] = args;
30827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30828 if (!SWIG_IsOK(res1)) {
30829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30830 }
30831 arg1 = reinterpret_cast< wxWindow * >(argp1);
30832 {
30833 PyThreadState* __tstate = wxPyBeginAllowThreads();
30834 result = ((wxWindow const *)arg1)->GetClientSize();
30835 wxPyEndAllowThreads(__tstate);
30836 if (PyErr_Occurred()) SWIG_fail;
30837 }
30838 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30839 return resultobj;
30840 fail:
30841 return NULL;
30842 }
30843
30844
30845 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30846 PyObject *resultobj = 0;
30847 wxWindow *arg1 = (wxWindow *) 0 ;
30848 int *arg2 = (int *) 0 ;
30849 int *arg3 = (int *) 0 ;
30850 void *argp1 = 0 ;
30851 int res1 = 0 ;
30852 int temp2 ;
30853 int res2 = SWIG_TMPOBJ ;
30854 int temp3 ;
30855 int res3 = SWIG_TMPOBJ ;
30856 PyObject *swig_obj[1] ;
30857
30858 arg2 = &temp2;
30859 arg3 = &temp3;
30860 if (!args) SWIG_fail;
30861 swig_obj[0] = args;
30862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30863 if (!SWIG_IsOK(res1)) {
30864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30865 }
30866 arg1 = reinterpret_cast< wxWindow * >(argp1);
30867 {
30868 PyThreadState* __tstate = wxPyBeginAllowThreads();
30869 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30870 wxPyEndAllowThreads(__tstate);
30871 if (PyErr_Occurred()) SWIG_fail;
30872 }
30873 resultobj = SWIG_Py_Void();
30874 if (SWIG_IsTmpObj(res2)) {
30875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30876 } else {
30877 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30879 }
30880 if (SWIG_IsTmpObj(res3)) {
30881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30882 } else {
30883 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30885 }
30886 return resultobj;
30887 fail:
30888 return NULL;
30889 }
30890
30891
30892 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30893 PyObject *resultobj = 0;
30894 wxWindow *arg1 = (wxWindow *) 0 ;
30895 wxPoint result;
30896 void *argp1 = 0 ;
30897 int res1 = 0 ;
30898 PyObject *swig_obj[1] ;
30899
30900 if (!args) SWIG_fail;
30901 swig_obj[0] = args;
30902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30903 if (!SWIG_IsOK(res1)) {
30904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30905 }
30906 arg1 = reinterpret_cast< wxWindow * >(argp1);
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30910 wxPyEndAllowThreads(__tstate);
30911 if (PyErr_Occurred()) SWIG_fail;
30912 }
30913 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30921 PyObject *resultobj = 0;
30922 wxWindow *arg1 = (wxWindow *) 0 ;
30923 wxRect result;
30924 void *argp1 = 0 ;
30925 int res1 = 0 ;
30926 PyObject *swig_obj[1] ;
30927
30928 if (!args) SWIG_fail;
30929 swig_obj[0] = args;
30930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30931 if (!SWIG_IsOK(res1)) {
30932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30933 }
30934 arg1 = reinterpret_cast< wxWindow * >(argp1);
30935 {
30936 PyThreadState* __tstate = wxPyBeginAllowThreads();
30937 result = ((wxWindow const *)arg1)->GetClientRect();
30938 wxPyEndAllowThreads(__tstate);
30939 if (PyErr_Occurred()) SWIG_fail;
30940 }
30941 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30949 PyObject *resultobj = 0;
30950 wxWindow *arg1 = (wxWindow *) 0 ;
30951 wxSize result;
30952 void *argp1 = 0 ;
30953 int res1 = 0 ;
30954 PyObject *swig_obj[1] ;
30955
30956 if (!args) SWIG_fail;
30957 swig_obj[0] = args;
30958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30959 if (!SWIG_IsOK(res1)) {
30960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30961 }
30962 arg1 = reinterpret_cast< wxWindow * >(argp1);
30963 {
30964 PyThreadState* __tstate = wxPyBeginAllowThreads();
30965 result = ((wxWindow const *)arg1)->GetBestSize();
30966 wxPyEndAllowThreads(__tstate);
30967 if (PyErr_Occurred()) SWIG_fail;
30968 }
30969 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30970 return resultobj;
30971 fail:
30972 return NULL;
30973 }
30974
30975
30976 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30977 PyObject *resultobj = 0;
30978 wxWindow *arg1 = (wxWindow *) 0 ;
30979 int *arg2 = (int *) 0 ;
30980 int *arg3 = (int *) 0 ;
30981 void *argp1 = 0 ;
30982 int res1 = 0 ;
30983 int temp2 ;
30984 int res2 = SWIG_TMPOBJ ;
30985 int temp3 ;
30986 int res3 = SWIG_TMPOBJ ;
30987 PyObject *swig_obj[1] ;
30988
30989 arg2 = &temp2;
30990 arg3 = &temp3;
30991 if (!args) SWIG_fail;
30992 swig_obj[0] = args;
30993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30994 if (!SWIG_IsOK(res1)) {
30995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30996 }
30997 arg1 = reinterpret_cast< wxWindow * >(argp1);
30998 {
30999 PyThreadState* __tstate = wxPyBeginAllowThreads();
31000 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31001 wxPyEndAllowThreads(__tstate);
31002 if (PyErr_Occurred()) SWIG_fail;
31003 }
31004 resultobj = SWIG_Py_Void();
31005 if (SWIG_IsTmpObj(res2)) {
31006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31007 } else {
31008 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31010 }
31011 if (SWIG_IsTmpObj(res3)) {
31012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31013 } else {
31014 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31016 }
31017 return resultobj;
31018 fail:
31019 return NULL;
31020 }
31021
31022
31023 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31024 PyObject *resultobj = 0;
31025 wxWindow *arg1 = (wxWindow *) 0 ;
31026 void *argp1 = 0 ;
31027 int res1 = 0 ;
31028 PyObject *swig_obj[1] ;
31029
31030 if (!args) SWIG_fail;
31031 swig_obj[0] = args;
31032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31033 if (!SWIG_IsOK(res1)) {
31034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31035 }
31036 arg1 = reinterpret_cast< wxWindow * >(argp1);
31037 {
31038 PyThreadState* __tstate = wxPyBeginAllowThreads();
31039 (arg1)->InvalidateBestSize();
31040 wxPyEndAllowThreads(__tstate);
31041 if (PyErr_Occurred()) SWIG_fail;
31042 }
31043 resultobj = SWIG_Py_Void();
31044 return resultobj;
31045 fail:
31046 return NULL;
31047 }
31048
31049
31050 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31051 PyObject *resultobj = 0;
31052 wxWindow *arg1 = (wxWindow *) 0 ;
31053 wxSize *arg2 = 0 ;
31054 void *argp1 = 0 ;
31055 int res1 = 0 ;
31056 wxSize temp2 ;
31057 PyObject * obj0 = 0 ;
31058 PyObject * obj1 = 0 ;
31059 char * kwnames[] = {
31060 (char *) "self",(char *) "size", NULL
31061 };
31062
31063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31065 if (!SWIG_IsOK(res1)) {
31066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31067 }
31068 arg1 = reinterpret_cast< wxWindow * >(argp1);
31069 {
31070 arg2 = &temp2;
31071 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31072 }
31073 {
31074 PyThreadState* __tstate = wxPyBeginAllowThreads();
31075 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 resultobj = SWIG_Py_Void();
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31087 PyObject *resultobj = 0;
31088 wxWindow *arg1 = (wxWindow *) 0 ;
31089 wxSize result;
31090 void *argp1 = 0 ;
31091 int res1 = 0 ;
31092 PyObject *swig_obj[1] ;
31093
31094 if (!args) SWIG_fail;
31095 swig_obj[0] = args;
31096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31097 if (!SWIG_IsOK(res1)) {
31098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31099 }
31100 arg1 = reinterpret_cast< wxWindow * >(argp1);
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31115 PyObject *resultobj = 0;
31116 wxWindow *arg1 = (wxWindow *) 0 ;
31117 wxSize result;
31118 void *argp1 = 0 ;
31119 int res1 = 0 ;
31120 PyObject *swig_obj[1] ;
31121
31122 if (!args) SWIG_fail;
31123 swig_obj[0] = args;
31124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31125 if (!SWIG_IsOK(res1)) {
31126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31127 }
31128 arg1 = reinterpret_cast< wxWindow * >(argp1);
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31143 PyObject *resultobj = 0;
31144 wxWindow *arg1 = (wxWindow *) 0 ;
31145 int arg2 = (int) wxBOTH ;
31146 void *argp1 = 0 ;
31147 int res1 = 0 ;
31148 int val2 ;
31149 int ecode2 = 0 ;
31150 PyObject * obj0 = 0 ;
31151 PyObject * obj1 = 0 ;
31152 char * kwnames[] = {
31153 (char *) "self",(char *) "direction", NULL
31154 };
31155
31156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31158 if (!SWIG_IsOK(res1)) {
31159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31160 }
31161 arg1 = reinterpret_cast< wxWindow * >(argp1);
31162 if (obj1) {
31163 ecode2 = SWIG_AsVal_int(obj1, &val2);
31164 if (!SWIG_IsOK(ecode2)) {
31165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31166 }
31167 arg2 = static_cast< int >(val2);
31168 }
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 (arg1)->Center(arg2);
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 resultobj = SWIG_Py_Void();
31176 return resultobj;
31177 fail:
31178 return NULL;
31179 }
31180
31181
31182 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31183 PyObject *resultobj = 0;
31184 wxWindow *arg1 = (wxWindow *) 0 ;
31185 int arg2 = (int) wxBOTH ;
31186 void *argp1 = 0 ;
31187 int res1 = 0 ;
31188 int val2 ;
31189 int ecode2 = 0 ;
31190 PyObject * obj0 = 0 ;
31191 PyObject * obj1 = 0 ;
31192 char * kwnames[] = {
31193 (char *) "self",(char *) "dir", NULL
31194 };
31195
31196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31198 if (!SWIG_IsOK(res1)) {
31199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31200 }
31201 arg1 = reinterpret_cast< wxWindow * >(argp1);
31202 if (obj1) {
31203 ecode2 = SWIG_AsVal_int(obj1, &val2);
31204 if (!SWIG_IsOK(ecode2)) {
31205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31206 }
31207 arg2 = static_cast< int >(val2);
31208 }
31209 {
31210 PyThreadState* __tstate = wxPyBeginAllowThreads();
31211 (arg1)->CenterOnParent(arg2);
31212 wxPyEndAllowThreads(__tstate);
31213 if (PyErr_Occurred()) SWIG_fail;
31214 }
31215 resultobj = SWIG_Py_Void();
31216 return resultobj;
31217 fail:
31218 return NULL;
31219 }
31220
31221
31222 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31223 PyObject *resultobj = 0;
31224 wxWindow *arg1 = (wxWindow *) 0 ;
31225 void *argp1 = 0 ;
31226 int res1 = 0 ;
31227 PyObject *swig_obj[1] ;
31228
31229 if (!args) SWIG_fail;
31230 swig_obj[0] = args;
31231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31232 if (!SWIG_IsOK(res1)) {
31233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31234 }
31235 arg1 = reinterpret_cast< wxWindow * >(argp1);
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 (arg1)->Fit();
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 resultobj = SWIG_Py_Void();
31243 return resultobj;
31244 fail:
31245 return NULL;
31246 }
31247
31248
31249 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31250 PyObject *resultobj = 0;
31251 wxWindow *arg1 = (wxWindow *) 0 ;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 PyObject *swig_obj[1] ;
31255
31256 if (!args) SWIG_fail;
31257 swig_obj[0] = args;
31258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31259 if (!SWIG_IsOK(res1)) {
31260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31261 }
31262 arg1 = reinterpret_cast< wxWindow * >(argp1);
31263 {
31264 PyThreadState* __tstate = wxPyBeginAllowThreads();
31265 (arg1)->FitInside();
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 resultobj = SWIG_Py_Void();
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31277 PyObject *resultobj = 0;
31278 wxWindow *arg1 = (wxWindow *) 0 ;
31279 int arg2 ;
31280 int arg3 ;
31281 int arg4 = (int) -1 ;
31282 int arg5 = (int) -1 ;
31283 int arg6 = (int) -1 ;
31284 int arg7 = (int) -1 ;
31285 void *argp1 = 0 ;
31286 int res1 = 0 ;
31287 int val2 ;
31288 int ecode2 = 0 ;
31289 int val3 ;
31290 int ecode3 = 0 ;
31291 int val4 ;
31292 int ecode4 = 0 ;
31293 int val5 ;
31294 int ecode5 = 0 ;
31295 int val6 ;
31296 int ecode6 = 0 ;
31297 int val7 ;
31298 int ecode7 = 0 ;
31299 PyObject * obj0 = 0 ;
31300 PyObject * obj1 = 0 ;
31301 PyObject * obj2 = 0 ;
31302 PyObject * obj3 = 0 ;
31303 PyObject * obj4 = 0 ;
31304 PyObject * obj5 = 0 ;
31305 PyObject * obj6 = 0 ;
31306 char * kwnames[] = {
31307 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31308 };
31309
31310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31312 if (!SWIG_IsOK(res1)) {
31313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31314 }
31315 arg1 = reinterpret_cast< wxWindow * >(argp1);
31316 ecode2 = SWIG_AsVal_int(obj1, &val2);
31317 if (!SWIG_IsOK(ecode2)) {
31318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31319 }
31320 arg2 = static_cast< int >(val2);
31321 ecode3 = SWIG_AsVal_int(obj2, &val3);
31322 if (!SWIG_IsOK(ecode3)) {
31323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31324 }
31325 arg3 = static_cast< int >(val3);
31326 if (obj3) {
31327 ecode4 = SWIG_AsVal_int(obj3, &val4);
31328 if (!SWIG_IsOK(ecode4)) {
31329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31330 }
31331 arg4 = static_cast< int >(val4);
31332 }
31333 if (obj4) {
31334 ecode5 = SWIG_AsVal_int(obj4, &val5);
31335 if (!SWIG_IsOK(ecode5)) {
31336 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31337 }
31338 arg5 = static_cast< int >(val5);
31339 }
31340 if (obj5) {
31341 ecode6 = SWIG_AsVal_int(obj5, &val6);
31342 if (!SWIG_IsOK(ecode6)) {
31343 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31344 }
31345 arg6 = static_cast< int >(val6);
31346 }
31347 if (obj6) {
31348 ecode7 = SWIG_AsVal_int(obj6, &val7);
31349 if (!SWIG_IsOK(ecode7)) {
31350 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31351 }
31352 arg7 = static_cast< int >(val7);
31353 }
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 resultobj = SWIG_Py_Void();
31361 return resultobj;
31362 fail:
31363 return NULL;
31364 }
31365
31366
31367 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31368 PyObject *resultobj = 0;
31369 wxWindow *arg1 = (wxWindow *) 0 ;
31370 wxSize *arg2 = 0 ;
31371 wxSize const &arg3_defvalue = wxDefaultSize ;
31372 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31373 wxSize const &arg4_defvalue = wxDefaultSize ;
31374 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31375 void *argp1 = 0 ;
31376 int res1 = 0 ;
31377 wxSize temp2 ;
31378 wxSize temp3 ;
31379 wxSize temp4 ;
31380 PyObject * obj0 = 0 ;
31381 PyObject * obj1 = 0 ;
31382 PyObject * obj2 = 0 ;
31383 PyObject * obj3 = 0 ;
31384 char * kwnames[] = {
31385 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31386 };
31387
31388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31390 if (!SWIG_IsOK(res1)) {
31391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31392 }
31393 arg1 = reinterpret_cast< wxWindow * >(argp1);
31394 {
31395 arg2 = &temp2;
31396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31397 }
31398 if (obj2) {
31399 {
31400 arg3 = &temp3;
31401 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31402 }
31403 }
31404 if (obj3) {
31405 {
31406 arg4 = &temp4;
31407 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31408 }
31409 }
31410 {
31411 PyThreadState* __tstate = wxPyBeginAllowThreads();
31412 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31413 wxPyEndAllowThreads(__tstate);
31414 if (PyErr_Occurred()) SWIG_fail;
31415 }
31416 resultobj = SWIG_Py_Void();
31417 return resultobj;
31418 fail:
31419 return NULL;
31420 }
31421
31422
31423 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31424 PyObject *resultobj = 0;
31425 wxWindow *arg1 = (wxWindow *) 0 ;
31426 int arg2 ;
31427 int arg3 ;
31428 int arg4 = (int) -1 ;
31429 int arg5 = (int) -1 ;
31430 void *argp1 = 0 ;
31431 int res1 = 0 ;
31432 int val2 ;
31433 int ecode2 = 0 ;
31434 int val3 ;
31435 int ecode3 = 0 ;
31436 int val4 ;
31437 int ecode4 = 0 ;
31438 int val5 ;
31439 int ecode5 = 0 ;
31440 PyObject * obj0 = 0 ;
31441 PyObject * obj1 = 0 ;
31442 PyObject * obj2 = 0 ;
31443 PyObject * obj3 = 0 ;
31444 PyObject * obj4 = 0 ;
31445 char * kwnames[] = {
31446 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31447 };
31448
31449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31451 if (!SWIG_IsOK(res1)) {
31452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31453 }
31454 arg1 = reinterpret_cast< wxWindow * >(argp1);
31455 ecode2 = SWIG_AsVal_int(obj1, &val2);
31456 if (!SWIG_IsOK(ecode2)) {
31457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31458 }
31459 arg2 = static_cast< int >(val2);
31460 ecode3 = SWIG_AsVal_int(obj2, &val3);
31461 if (!SWIG_IsOK(ecode3)) {
31462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31463 }
31464 arg3 = static_cast< int >(val3);
31465 if (obj3) {
31466 ecode4 = SWIG_AsVal_int(obj3, &val4);
31467 if (!SWIG_IsOK(ecode4)) {
31468 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31469 }
31470 arg4 = static_cast< int >(val4);
31471 }
31472 if (obj4) {
31473 ecode5 = SWIG_AsVal_int(obj4, &val5);
31474 if (!SWIG_IsOK(ecode5)) {
31475 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31476 }
31477 arg5 = static_cast< int >(val5);
31478 }
31479 {
31480 PyThreadState* __tstate = wxPyBeginAllowThreads();
31481 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 resultobj = SWIG_Py_Void();
31486 return resultobj;
31487 fail:
31488 return NULL;
31489 }
31490
31491
31492 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31493 PyObject *resultobj = 0;
31494 wxWindow *arg1 = (wxWindow *) 0 ;
31495 wxSize *arg2 = 0 ;
31496 wxSize const &arg3_defvalue = wxDefaultSize ;
31497 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31498 void *argp1 = 0 ;
31499 int res1 = 0 ;
31500 wxSize temp2 ;
31501 wxSize temp3 ;
31502 PyObject * obj0 = 0 ;
31503 PyObject * obj1 = 0 ;
31504 PyObject * obj2 = 0 ;
31505 char * kwnames[] = {
31506 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31507 };
31508
31509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31511 if (!SWIG_IsOK(res1)) {
31512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31513 }
31514 arg1 = reinterpret_cast< wxWindow * >(argp1);
31515 {
31516 arg2 = &temp2;
31517 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31518 }
31519 if (obj2) {
31520 {
31521 arg3 = &temp3;
31522 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31523 }
31524 }
31525 {
31526 PyThreadState* __tstate = wxPyBeginAllowThreads();
31527 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31528 wxPyEndAllowThreads(__tstate);
31529 if (PyErr_Occurred()) SWIG_fail;
31530 }
31531 resultobj = SWIG_Py_Void();
31532 return resultobj;
31533 fail:
31534 return NULL;
31535 }
31536
31537
31538 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31539 PyObject *resultobj = 0;
31540 wxWindow *arg1 = (wxWindow *) 0 ;
31541 wxSize result;
31542 void *argp1 = 0 ;
31543 int res1 = 0 ;
31544 PyObject *swig_obj[1] ;
31545
31546 if (!args) SWIG_fail;
31547 swig_obj[0] = args;
31548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31549 if (!SWIG_IsOK(res1)) {
31550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31551 }
31552 arg1 = reinterpret_cast< wxWindow * >(argp1);
31553 {
31554 PyThreadState* __tstate = wxPyBeginAllowThreads();
31555 result = ((wxWindow const *)arg1)->GetMaxSize();
31556 wxPyEndAllowThreads(__tstate);
31557 if (PyErr_Occurred()) SWIG_fail;
31558 }
31559 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31560 return resultobj;
31561 fail:
31562 return NULL;
31563 }
31564
31565
31566 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31567 PyObject *resultobj = 0;
31568 wxWindow *arg1 = (wxWindow *) 0 ;
31569 wxSize result;
31570 void *argp1 = 0 ;
31571 int res1 = 0 ;
31572 PyObject *swig_obj[1] ;
31573
31574 if (!args) SWIG_fail;
31575 swig_obj[0] = args;
31576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31577 if (!SWIG_IsOK(res1)) {
31578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31579 }
31580 arg1 = reinterpret_cast< wxWindow * >(argp1);
31581 {
31582 PyThreadState* __tstate = wxPyBeginAllowThreads();
31583 result = ((wxWindow const *)arg1)->GetMinSize();
31584 wxPyEndAllowThreads(__tstate);
31585 if (PyErr_Occurred()) SWIG_fail;
31586 }
31587 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31588 return resultobj;
31589 fail:
31590 return NULL;
31591 }
31592
31593
31594 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31595 PyObject *resultobj = 0;
31596 wxWindow *arg1 = (wxWindow *) 0 ;
31597 wxSize *arg2 = 0 ;
31598 void *argp1 = 0 ;
31599 int res1 = 0 ;
31600 wxSize temp2 ;
31601 PyObject * obj0 = 0 ;
31602 PyObject * obj1 = 0 ;
31603 char * kwnames[] = {
31604 (char *) "self",(char *) "minSize", NULL
31605 };
31606
31607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31609 if (!SWIG_IsOK(res1)) {
31610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31611 }
31612 arg1 = reinterpret_cast< wxWindow * >(argp1);
31613 {
31614 arg2 = &temp2;
31615 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31616 }
31617 {
31618 PyThreadState* __tstate = wxPyBeginAllowThreads();
31619 (arg1)->SetMinSize((wxSize const &)*arg2);
31620 wxPyEndAllowThreads(__tstate);
31621 if (PyErr_Occurred()) SWIG_fail;
31622 }
31623 resultobj = SWIG_Py_Void();
31624 return resultobj;
31625 fail:
31626 return NULL;
31627 }
31628
31629
31630 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31631 PyObject *resultobj = 0;
31632 wxWindow *arg1 = (wxWindow *) 0 ;
31633 wxSize *arg2 = 0 ;
31634 void *argp1 = 0 ;
31635 int res1 = 0 ;
31636 wxSize temp2 ;
31637 PyObject * obj0 = 0 ;
31638 PyObject * obj1 = 0 ;
31639 char * kwnames[] = {
31640 (char *) "self",(char *) "maxSize", NULL
31641 };
31642
31643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31645 if (!SWIG_IsOK(res1)) {
31646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31647 }
31648 arg1 = reinterpret_cast< wxWindow * >(argp1);
31649 {
31650 arg2 = &temp2;
31651 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31652 }
31653 {
31654 PyThreadState* __tstate = wxPyBeginAllowThreads();
31655 (arg1)->SetMaxSize((wxSize const &)*arg2);
31656 wxPyEndAllowThreads(__tstate);
31657 if (PyErr_Occurred()) SWIG_fail;
31658 }
31659 resultobj = SWIG_Py_Void();
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31667 PyObject *resultobj = 0;
31668 wxWindow *arg1 = (wxWindow *) 0 ;
31669 int result;
31670 void *argp1 = 0 ;
31671 int res1 = 0 ;
31672 PyObject *swig_obj[1] ;
31673
31674 if (!args) SWIG_fail;
31675 swig_obj[0] = args;
31676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31677 if (!SWIG_IsOK(res1)) {
31678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31679 }
31680 arg1 = reinterpret_cast< wxWindow * >(argp1);
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31684 wxPyEndAllowThreads(__tstate);
31685 if (PyErr_Occurred()) SWIG_fail;
31686 }
31687 resultobj = SWIG_From_int(static_cast< int >(result));
31688 return resultobj;
31689 fail:
31690 return NULL;
31691 }
31692
31693
31694 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31695 PyObject *resultobj = 0;
31696 wxWindow *arg1 = (wxWindow *) 0 ;
31697 int result;
31698 void *argp1 = 0 ;
31699 int res1 = 0 ;
31700 PyObject *swig_obj[1] ;
31701
31702 if (!args) SWIG_fail;
31703 swig_obj[0] = args;
31704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31705 if (!SWIG_IsOK(res1)) {
31706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31707 }
31708 arg1 = reinterpret_cast< wxWindow * >(argp1);
31709 {
31710 PyThreadState* __tstate = wxPyBeginAllowThreads();
31711 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 resultobj = SWIG_From_int(static_cast< int >(result));
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31723 PyObject *resultobj = 0;
31724 wxWindow *arg1 = (wxWindow *) 0 ;
31725 int result;
31726 void *argp1 = 0 ;
31727 int res1 = 0 ;
31728 PyObject *swig_obj[1] ;
31729
31730 if (!args) SWIG_fail;
31731 swig_obj[0] = args;
31732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31733 if (!SWIG_IsOK(res1)) {
31734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31735 }
31736 arg1 = reinterpret_cast< wxWindow * >(argp1);
31737 {
31738 PyThreadState* __tstate = wxPyBeginAllowThreads();
31739 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31740 wxPyEndAllowThreads(__tstate);
31741 if (PyErr_Occurred()) SWIG_fail;
31742 }
31743 resultobj = SWIG_From_int(static_cast< int >(result));
31744 return resultobj;
31745 fail:
31746 return NULL;
31747 }
31748
31749
31750 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31751 PyObject *resultobj = 0;
31752 wxWindow *arg1 = (wxWindow *) 0 ;
31753 int result;
31754 void *argp1 = 0 ;
31755 int res1 = 0 ;
31756 PyObject *swig_obj[1] ;
31757
31758 if (!args) SWIG_fail;
31759 swig_obj[0] = args;
31760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31761 if (!SWIG_IsOK(res1)) {
31762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31763 }
31764 arg1 = reinterpret_cast< wxWindow * >(argp1);
31765 {
31766 PyThreadState* __tstate = wxPyBeginAllowThreads();
31767 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31768 wxPyEndAllowThreads(__tstate);
31769 if (PyErr_Occurred()) SWIG_fail;
31770 }
31771 resultobj = SWIG_From_int(static_cast< int >(result));
31772 return resultobj;
31773 fail:
31774 return NULL;
31775 }
31776
31777
31778 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31779 PyObject *resultobj = 0;
31780 wxWindow *arg1 = (wxWindow *) 0 ;
31781 wxSize *arg2 = 0 ;
31782 void *argp1 = 0 ;
31783 int res1 = 0 ;
31784 wxSize temp2 ;
31785 PyObject * obj0 = 0 ;
31786 PyObject * obj1 = 0 ;
31787 char * kwnames[] = {
31788 (char *) "self",(char *) "size", NULL
31789 };
31790
31791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31793 if (!SWIG_IsOK(res1)) {
31794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31795 }
31796 arg1 = reinterpret_cast< wxWindow * >(argp1);
31797 {
31798 arg2 = &temp2;
31799 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31800 }
31801 {
31802 PyThreadState* __tstate = wxPyBeginAllowThreads();
31803 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 resultobj = SWIG_Py_Void();
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31815 PyObject *resultobj = 0;
31816 wxWindow *arg1 = (wxWindow *) 0 ;
31817 int arg2 ;
31818 int arg3 ;
31819 void *argp1 = 0 ;
31820 int res1 = 0 ;
31821 int val2 ;
31822 int ecode2 = 0 ;
31823 int val3 ;
31824 int ecode3 = 0 ;
31825 PyObject * obj0 = 0 ;
31826 PyObject * obj1 = 0 ;
31827 PyObject * obj2 = 0 ;
31828 char * kwnames[] = {
31829 (char *) "self",(char *) "w",(char *) "h", NULL
31830 };
31831
31832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31834 if (!SWIG_IsOK(res1)) {
31835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31836 }
31837 arg1 = reinterpret_cast< wxWindow * >(argp1);
31838 ecode2 = SWIG_AsVal_int(obj1, &val2);
31839 if (!SWIG_IsOK(ecode2)) {
31840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31841 }
31842 arg2 = static_cast< int >(val2);
31843 ecode3 = SWIG_AsVal_int(obj2, &val3);
31844 if (!SWIG_IsOK(ecode3)) {
31845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31846 }
31847 arg3 = static_cast< int >(val3);
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 (arg1)->SetVirtualSize(arg2,arg3);
31851 wxPyEndAllowThreads(__tstate);
31852 if (PyErr_Occurred()) SWIG_fail;
31853 }
31854 resultobj = SWIG_Py_Void();
31855 return resultobj;
31856 fail:
31857 return NULL;
31858 }
31859
31860
31861 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31862 PyObject *resultobj = 0;
31863 wxWindow *arg1 = (wxWindow *) 0 ;
31864 wxSize result;
31865 void *argp1 = 0 ;
31866 int res1 = 0 ;
31867 PyObject *swig_obj[1] ;
31868
31869 if (!args) SWIG_fail;
31870 swig_obj[0] = args;
31871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31872 if (!SWIG_IsOK(res1)) {
31873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31874 }
31875 arg1 = reinterpret_cast< wxWindow * >(argp1);
31876 {
31877 PyThreadState* __tstate = wxPyBeginAllowThreads();
31878 result = ((wxWindow const *)arg1)->GetVirtualSize();
31879 wxPyEndAllowThreads(__tstate);
31880 if (PyErr_Occurred()) SWIG_fail;
31881 }
31882 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31883 return resultobj;
31884 fail:
31885 return NULL;
31886 }
31887
31888
31889 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31890 PyObject *resultobj = 0;
31891 wxWindow *arg1 = (wxWindow *) 0 ;
31892 int *arg2 = (int *) 0 ;
31893 int *arg3 = (int *) 0 ;
31894 void *argp1 = 0 ;
31895 int res1 = 0 ;
31896 int temp2 ;
31897 int res2 = SWIG_TMPOBJ ;
31898 int temp3 ;
31899 int res3 = SWIG_TMPOBJ ;
31900 PyObject *swig_obj[1] ;
31901
31902 arg2 = &temp2;
31903 arg3 = &temp3;
31904 if (!args) SWIG_fail;
31905 swig_obj[0] = args;
31906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31907 if (!SWIG_IsOK(res1)) {
31908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31909 }
31910 arg1 = reinterpret_cast< wxWindow * >(argp1);
31911 {
31912 PyThreadState* __tstate = wxPyBeginAllowThreads();
31913 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31914 wxPyEndAllowThreads(__tstate);
31915 if (PyErr_Occurred()) SWIG_fail;
31916 }
31917 resultobj = SWIG_Py_Void();
31918 if (SWIG_IsTmpObj(res2)) {
31919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31920 } else {
31921 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31923 }
31924 if (SWIG_IsTmpObj(res3)) {
31925 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31926 } else {
31927 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31929 }
31930 return resultobj;
31931 fail:
31932 return NULL;
31933 }
31934
31935
31936 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31937 PyObject *resultobj = 0;
31938 wxWindow *arg1 = (wxWindow *) 0 ;
31939 wxSize result;
31940 void *argp1 = 0 ;
31941 int res1 = 0 ;
31942 PyObject *swig_obj[1] ;
31943
31944 if (!args) SWIG_fail;
31945 swig_obj[0] = args;
31946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31947 if (!SWIG_IsOK(res1)) {
31948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31949 }
31950 arg1 = reinterpret_cast< wxWindow * >(argp1);
31951 {
31952 PyThreadState* __tstate = wxPyBeginAllowThreads();
31953 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
31954 wxPyEndAllowThreads(__tstate);
31955 if (PyErr_Occurred()) SWIG_fail;
31956 }
31957 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31958 return resultobj;
31959 fail:
31960 return NULL;
31961 }
31962
31963
31964 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31965 PyObject *resultobj = 0;
31966 wxWindow *arg1 = (wxWindow *) 0 ;
31967 bool arg2 = (bool) true ;
31968 bool result;
31969 void *argp1 = 0 ;
31970 int res1 = 0 ;
31971 bool val2 ;
31972 int ecode2 = 0 ;
31973 PyObject * obj0 = 0 ;
31974 PyObject * obj1 = 0 ;
31975 char * kwnames[] = {
31976 (char *) "self",(char *) "show", NULL
31977 };
31978
31979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
31980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31981 if (!SWIG_IsOK(res1)) {
31982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
31983 }
31984 arg1 = reinterpret_cast< wxWindow * >(argp1);
31985 if (obj1) {
31986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31987 if (!SWIG_IsOK(ecode2)) {
31988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
31989 }
31990 arg2 = static_cast< bool >(val2);
31991 }
31992 {
31993 PyThreadState* __tstate = wxPyBeginAllowThreads();
31994 result = (bool)(arg1)->Show(arg2);
31995 wxPyEndAllowThreads(__tstate);
31996 if (PyErr_Occurred()) SWIG_fail;
31997 }
31998 {
31999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32000 }
32001 return resultobj;
32002 fail:
32003 return NULL;
32004 }
32005
32006
32007 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32008 PyObject *resultobj = 0;
32009 wxWindow *arg1 = (wxWindow *) 0 ;
32010 bool result;
32011 void *argp1 = 0 ;
32012 int res1 = 0 ;
32013 PyObject *swig_obj[1] ;
32014
32015 if (!args) SWIG_fail;
32016 swig_obj[0] = args;
32017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32018 if (!SWIG_IsOK(res1)) {
32019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32020 }
32021 arg1 = reinterpret_cast< wxWindow * >(argp1);
32022 {
32023 PyThreadState* __tstate = wxPyBeginAllowThreads();
32024 result = (bool)(arg1)->Hide();
32025 wxPyEndAllowThreads(__tstate);
32026 if (PyErr_Occurred()) SWIG_fail;
32027 }
32028 {
32029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32030 }
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32038 PyObject *resultobj = 0;
32039 wxWindow *arg1 = (wxWindow *) 0 ;
32040 bool arg2 = (bool) true ;
32041 bool result;
32042 void *argp1 = 0 ;
32043 int res1 = 0 ;
32044 bool val2 ;
32045 int ecode2 = 0 ;
32046 PyObject * obj0 = 0 ;
32047 PyObject * obj1 = 0 ;
32048 char * kwnames[] = {
32049 (char *) "self",(char *) "enable", NULL
32050 };
32051
32052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32054 if (!SWIG_IsOK(res1)) {
32055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32056 }
32057 arg1 = reinterpret_cast< wxWindow * >(argp1);
32058 if (obj1) {
32059 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32060 if (!SWIG_IsOK(ecode2)) {
32061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32062 }
32063 arg2 = static_cast< bool >(val2);
32064 }
32065 {
32066 PyThreadState* __tstate = wxPyBeginAllowThreads();
32067 result = (bool)(arg1)->Enable(arg2);
32068 wxPyEndAllowThreads(__tstate);
32069 if (PyErr_Occurred()) SWIG_fail;
32070 }
32071 {
32072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32073 }
32074 return resultobj;
32075 fail:
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32081 PyObject *resultobj = 0;
32082 wxWindow *arg1 = (wxWindow *) 0 ;
32083 bool result;
32084 void *argp1 = 0 ;
32085 int res1 = 0 ;
32086 PyObject *swig_obj[1] ;
32087
32088 if (!args) SWIG_fail;
32089 swig_obj[0] = args;
32090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32091 if (!SWIG_IsOK(res1)) {
32092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32093 }
32094 arg1 = reinterpret_cast< wxWindow * >(argp1);
32095 {
32096 PyThreadState* __tstate = wxPyBeginAllowThreads();
32097 result = (bool)(arg1)->Disable();
32098 wxPyEndAllowThreads(__tstate);
32099 if (PyErr_Occurred()) SWIG_fail;
32100 }
32101 {
32102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32103 }
32104 return resultobj;
32105 fail:
32106 return NULL;
32107 }
32108
32109
32110 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32111 PyObject *resultobj = 0;
32112 wxWindow *arg1 = (wxWindow *) 0 ;
32113 bool result;
32114 void *argp1 = 0 ;
32115 int res1 = 0 ;
32116 PyObject *swig_obj[1] ;
32117
32118 if (!args) SWIG_fail;
32119 swig_obj[0] = args;
32120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32121 if (!SWIG_IsOK(res1)) {
32122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32123 }
32124 arg1 = reinterpret_cast< wxWindow * >(argp1);
32125 {
32126 PyThreadState* __tstate = wxPyBeginAllowThreads();
32127 result = (bool)((wxWindow const *)arg1)->IsShown();
32128 wxPyEndAllowThreads(__tstate);
32129 if (PyErr_Occurred()) SWIG_fail;
32130 }
32131 {
32132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32133 }
32134 return resultobj;
32135 fail:
32136 return NULL;
32137 }
32138
32139
32140 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32141 PyObject *resultobj = 0;
32142 wxWindow *arg1 = (wxWindow *) 0 ;
32143 bool result;
32144 void *argp1 = 0 ;
32145 int res1 = 0 ;
32146 PyObject *swig_obj[1] ;
32147
32148 if (!args) SWIG_fail;
32149 swig_obj[0] = args;
32150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32151 if (!SWIG_IsOK(res1)) {
32152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32153 }
32154 arg1 = reinterpret_cast< wxWindow * >(argp1);
32155 {
32156 PyThreadState* __tstate = wxPyBeginAllowThreads();
32157 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32158 wxPyEndAllowThreads(__tstate);
32159 if (PyErr_Occurred()) SWIG_fail;
32160 }
32161 {
32162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32163 }
32164 return resultobj;
32165 fail:
32166 return NULL;
32167 }
32168
32169
32170 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32171 PyObject *resultobj = 0;
32172 wxWindow *arg1 = (wxWindow *) 0 ;
32173 long arg2 ;
32174 void *argp1 = 0 ;
32175 int res1 = 0 ;
32176 long val2 ;
32177 int ecode2 = 0 ;
32178 PyObject * obj0 = 0 ;
32179 PyObject * obj1 = 0 ;
32180 char * kwnames[] = {
32181 (char *) "self",(char *) "style", NULL
32182 };
32183
32184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32186 if (!SWIG_IsOK(res1)) {
32187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32188 }
32189 arg1 = reinterpret_cast< wxWindow * >(argp1);
32190 ecode2 = SWIG_AsVal_long(obj1, &val2);
32191 if (!SWIG_IsOK(ecode2)) {
32192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32193 }
32194 arg2 = static_cast< long >(val2);
32195 {
32196 PyThreadState* __tstate = wxPyBeginAllowThreads();
32197 (arg1)->SetWindowStyleFlag(arg2);
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 resultobj = SWIG_Py_Void();
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209 PyObject *resultobj = 0;
32210 wxWindow *arg1 = (wxWindow *) 0 ;
32211 long result;
32212 void *argp1 = 0 ;
32213 int res1 = 0 ;
32214 PyObject *swig_obj[1] ;
32215
32216 if (!args) SWIG_fail;
32217 swig_obj[0] = args;
32218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32219 if (!SWIG_IsOK(res1)) {
32220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32221 }
32222 arg1 = reinterpret_cast< wxWindow * >(argp1);
32223 {
32224 PyThreadState* __tstate = wxPyBeginAllowThreads();
32225 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 resultobj = SWIG_From_long(static_cast< long >(result));
32230 return resultobj;
32231 fail:
32232 return NULL;
32233 }
32234
32235
32236 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32237 PyObject *resultobj = 0;
32238 wxWindow *arg1 = (wxWindow *) 0 ;
32239 int arg2 ;
32240 bool result;
32241 void *argp1 = 0 ;
32242 int res1 = 0 ;
32243 int val2 ;
32244 int ecode2 = 0 ;
32245 PyObject * obj0 = 0 ;
32246 PyObject * obj1 = 0 ;
32247 char * kwnames[] = {
32248 (char *) "self",(char *) "flag", NULL
32249 };
32250
32251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32253 if (!SWIG_IsOK(res1)) {
32254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32255 }
32256 arg1 = reinterpret_cast< wxWindow * >(argp1);
32257 ecode2 = SWIG_AsVal_int(obj1, &val2);
32258 if (!SWIG_IsOK(ecode2)) {
32259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32260 }
32261 arg2 = static_cast< int >(val2);
32262 {
32263 PyThreadState* __tstate = wxPyBeginAllowThreads();
32264 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32265 wxPyEndAllowThreads(__tstate);
32266 if (PyErr_Occurred()) SWIG_fail;
32267 }
32268 {
32269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32270 }
32271 return resultobj;
32272 fail:
32273 return NULL;
32274 }
32275
32276
32277 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32278 PyObject *resultobj = 0;
32279 wxWindow *arg1 = (wxWindow *) 0 ;
32280 bool result;
32281 void *argp1 = 0 ;
32282 int res1 = 0 ;
32283 PyObject *swig_obj[1] ;
32284
32285 if (!args) SWIG_fail;
32286 swig_obj[0] = args;
32287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32288 if (!SWIG_IsOK(res1)) {
32289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32290 }
32291 arg1 = reinterpret_cast< wxWindow * >(argp1);
32292 {
32293 PyThreadState* __tstate = wxPyBeginAllowThreads();
32294 result = (bool)((wxWindow const *)arg1)->IsRetained();
32295 wxPyEndAllowThreads(__tstate);
32296 if (PyErr_Occurred()) SWIG_fail;
32297 }
32298 {
32299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32300 }
32301 return resultobj;
32302 fail:
32303 return NULL;
32304 }
32305
32306
32307 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32308 PyObject *resultobj = 0;
32309 wxWindow *arg1 = (wxWindow *) 0 ;
32310 long arg2 ;
32311 void *argp1 = 0 ;
32312 int res1 = 0 ;
32313 long val2 ;
32314 int ecode2 = 0 ;
32315 PyObject * obj0 = 0 ;
32316 PyObject * obj1 = 0 ;
32317 char * kwnames[] = {
32318 (char *) "self",(char *) "exStyle", NULL
32319 };
32320
32321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32323 if (!SWIG_IsOK(res1)) {
32324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32325 }
32326 arg1 = reinterpret_cast< wxWindow * >(argp1);
32327 ecode2 = SWIG_AsVal_long(obj1, &val2);
32328 if (!SWIG_IsOK(ecode2)) {
32329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32330 }
32331 arg2 = static_cast< long >(val2);
32332 {
32333 PyThreadState* __tstate = wxPyBeginAllowThreads();
32334 (arg1)->SetExtraStyle(arg2);
32335 wxPyEndAllowThreads(__tstate);
32336 if (PyErr_Occurred()) SWIG_fail;
32337 }
32338 resultobj = SWIG_Py_Void();
32339 return resultobj;
32340 fail:
32341 return NULL;
32342 }
32343
32344
32345 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32346 PyObject *resultobj = 0;
32347 wxWindow *arg1 = (wxWindow *) 0 ;
32348 long result;
32349 void *argp1 = 0 ;
32350 int res1 = 0 ;
32351 PyObject *swig_obj[1] ;
32352
32353 if (!args) SWIG_fail;
32354 swig_obj[0] = args;
32355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32356 if (!SWIG_IsOK(res1)) {
32357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32358 }
32359 arg1 = reinterpret_cast< wxWindow * >(argp1);
32360 {
32361 PyThreadState* __tstate = wxPyBeginAllowThreads();
32362 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32363 wxPyEndAllowThreads(__tstate);
32364 if (PyErr_Occurred()) SWIG_fail;
32365 }
32366 resultobj = SWIG_From_long(static_cast< long >(result));
32367 return resultobj;
32368 fail:
32369 return NULL;
32370 }
32371
32372
32373 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32374 PyObject *resultobj = 0;
32375 wxWindow *arg1 = (wxWindow *) 0 ;
32376 bool arg2 = (bool) true ;
32377 void *argp1 = 0 ;
32378 int res1 = 0 ;
32379 bool val2 ;
32380 int ecode2 = 0 ;
32381 PyObject * obj0 = 0 ;
32382 PyObject * obj1 = 0 ;
32383 char * kwnames[] = {
32384 (char *) "self",(char *) "modal", NULL
32385 };
32386
32387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32389 if (!SWIG_IsOK(res1)) {
32390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32391 }
32392 arg1 = reinterpret_cast< wxWindow * >(argp1);
32393 if (obj1) {
32394 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32395 if (!SWIG_IsOK(ecode2)) {
32396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32397 }
32398 arg2 = static_cast< bool >(val2);
32399 }
32400 {
32401 PyThreadState* __tstate = wxPyBeginAllowThreads();
32402 (arg1)->MakeModal(arg2);
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 resultobj = SWIG_Py_Void();
32407 return resultobj;
32408 fail:
32409 return NULL;
32410 }
32411
32412
32413 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj = 0;
32415 wxWindow *arg1 = (wxWindow *) 0 ;
32416 bool arg2 ;
32417 void *argp1 = 0 ;
32418 int res1 = 0 ;
32419 bool val2 ;
32420 int ecode2 = 0 ;
32421 PyObject * obj0 = 0 ;
32422 PyObject * obj1 = 0 ;
32423 char * kwnames[] = {
32424 (char *) "self",(char *) "enableTheme", NULL
32425 };
32426
32427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32429 if (!SWIG_IsOK(res1)) {
32430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32431 }
32432 arg1 = reinterpret_cast< wxWindow * >(argp1);
32433 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32434 if (!SWIG_IsOK(ecode2)) {
32435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32436 }
32437 arg2 = static_cast< bool >(val2);
32438 {
32439 PyThreadState* __tstate = wxPyBeginAllowThreads();
32440 (arg1)->SetThemeEnabled(arg2);
32441 wxPyEndAllowThreads(__tstate);
32442 if (PyErr_Occurred()) SWIG_fail;
32443 }
32444 resultobj = SWIG_Py_Void();
32445 return resultobj;
32446 fail:
32447 return NULL;
32448 }
32449
32450
32451 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32452 PyObject *resultobj = 0;
32453 wxWindow *arg1 = (wxWindow *) 0 ;
32454 bool result;
32455 void *argp1 = 0 ;
32456 int res1 = 0 ;
32457 PyObject *swig_obj[1] ;
32458
32459 if (!args) SWIG_fail;
32460 swig_obj[0] = args;
32461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32462 if (!SWIG_IsOK(res1)) {
32463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32464 }
32465 arg1 = reinterpret_cast< wxWindow * >(argp1);
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 {
32473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32474 }
32475 return resultobj;
32476 fail:
32477 return NULL;
32478 }
32479
32480
32481 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32482 PyObject *resultobj = 0;
32483 wxWindow *arg1 = (wxWindow *) 0 ;
32484 void *argp1 = 0 ;
32485 int res1 = 0 ;
32486 PyObject *swig_obj[1] ;
32487
32488 if (!args) SWIG_fail;
32489 swig_obj[0] = args;
32490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32491 if (!SWIG_IsOK(res1)) {
32492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32493 }
32494 arg1 = reinterpret_cast< wxWindow * >(argp1);
32495 {
32496 PyThreadState* __tstate = wxPyBeginAllowThreads();
32497 (arg1)->SetFocus();
32498 wxPyEndAllowThreads(__tstate);
32499 if (PyErr_Occurred()) SWIG_fail;
32500 }
32501 resultobj = SWIG_Py_Void();
32502 return resultobj;
32503 fail:
32504 return NULL;
32505 }
32506
32507
32508 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32509 PyObject *resultobj = 0;
32510 wxWindow *arg1 = (wxWindow *) 0 ;
32511 void *argp1 = 0 ;
32512 int res1 = 0 ;
32513 PyObject *swig_obj[1] ;
32514
32515 if (!args) SWIG_fail;
32516 swig_obj[0] = args;
32517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32518 if (!SWIG_IsOK(res1)) {
32519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32520 }
32521 arg1 = reinterpret_cast< wxWindow * >(argp1);
32522 {
32523 PyThreadState* __tstate = wxPyBeginAllowThreads();
32524 (arg1)->SetFocusFromKbd();
32525 wxPyEndAllowThreads(__tstate);
32526 if (PyErr_Occurred()) SWIG_fail;
32527 }
32528 resultobj = SWIG_Py_Void();
32529 return resultobj;
32530 fail:
32531 return NULL;
32532 }
32533
32534
32535 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32536 PyObject *resultobj = 0;
32537 wxWindow *result = 0 ;
32538
32539 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32540 {
32541 if (!wxPyCheckForApp()) SWIG_fail;
32542 PyThreadState* __tstate = wxPyBeginAllowThreads();
32543 result = (wxWindow *)wxWindow::FindFocus();
32544 wxPyEndAllowThreads(__tstate);
32545 if (PyErr_Occurred()) SWIG_fail;
32546 }
32547 {
32548 resultobj = wxPyMake_wxObject(result, 0);
32549 }
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32557 PyObject *resultobj = 0;
32558 wxWindow *arg1 = (wxWindow *) 0 ;
32559 bool result;
32560 void *argp1 = 0 ;
32561 int res1 = 0 ;
32562 PyObject *swig_obj[1] ;
32563
32564 if (!args) SWIG_fail;
32565 swig_obj[0] = args;
32566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32567 if (!SWIG_IsOK(res1)) {
32568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32569 }
32570 arg1 = reinterpret_cast< wxWindow * >(argp1);
32571 {
32572 PyThreadState* __tstate = wxPyBeginAllowThreads();
32573 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 {
32578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32579 }
32580 return resultobj;
32581 fail:
32582 return NULL;
32583 }
32584
32585
32586 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32587 PyObject *resultobj = 0;
32588 wxWindow *arg1 = (wxWindow *) 0 ;
32589 bool result;
32590 void *argp1 = 0 ;
32591 int res1 = 0 ;
32592 PyObject *swig_obj[1] ;
32593
32594 if (!args) SWIG_fail;
32595 swig_obj[0] = args;
32596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32597 if (!SWIG_IsOK(res1)) {
32598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32599 }
32600 arg1 = reinterpret_cast< wxWindow * >(argp1);
32601 {
32602 PyThreadState* __tstate = wxPyBeginAllowThreads();
32603 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32604 wxPyEndAllowThreads(__tstate);
32605 if (PyErr_Occurred()) SWIG_fail;
32606 }
32607 {
32608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32609 }
32610 return resultobj;
32611 fail:
32612 return NULL;
32613 }
32614
32615
32616 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32617 PyObject *resultobj = 0;
32618 wxWindow *arg1 = (wxWindow *) 0 ;
32619 wxWindow *result = 0 ;
32620 void *argp1 = 0 ;
32621 int res1 = 0 ;
32622 PyObject *swig_obj[1] ;
32623
32624 if (!args) SWIG_fail;
32625 swig_obj[0] = args;
32626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32627 if (!SWIG_IsOK(res1)) {
32628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32629 }
32630 arg1 = reinterpret_cast< wxWindow * >(argp1);
32631 {
32632 PyThreadState* __tstate = wxPyBeginAllowThreads();
32633 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32634 wxPyEndAllowThreads(__tstate);
32635 if (PyErr_Occurred()) SWIG_fail;
32636 }
32637 {
32638 resultobj = wxPyMake_wxObject(result, 0);
32639 }
32640 return resultobj;
32641 fail:
32642 return NULL;
32643 }
32644
32645
32646 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32647 PyObject *resultobj = 0;
32648 wxWindow *arg1 = (wxWindow *) 0 ;
32649 wxWindow *arg2 = (wxWindow *) 0 ;
32650 wxWindow *result = 0 ;
32651 void *argp1 = 0 ;
32652 int res1 = 0 ;
32653 void *argp2 = 0 ;
32654 int res2 = 0 ;
32655 PyObject * obj0 = 0 ;
32656 PyObject * obj1 = 0 ;
32657 char * kwnames[] = {
32658 (char *) "self",(char *) "child", NULL
32659 };
32660
32661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32663 if (!SWIG_IsOK(res1)) {
32664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32665 }
32666 arg1 = reinterpret_cast< wxWindow * >(argp1);
32667 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32668 if (!SWIG_IsOK(res2)) {
32669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32670 }
32671 arg2 = reinterpret_cast< wxWindow * >(argp2);
32672 {
32673 PyThreadState* __tstate = wxPyBeginAllowThreads();
32674 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32675 wxPyEndAllowThreads(__tstate);
32676 if (PyErr_Occurred()) SWIG_fail;
32677 }
32678 {
32679 resultobj = wxPyMake_wxObject(result, 0);
32680 }
32681 return resultobj;
32682 fail:
32683 return NULL;
32684 }
32685
32686
32687 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32688 PyObject *resultobj = 0;
32689 wxWindow *arg1 = (wxWindow *) 0 ;
32690 wxWindow *arg2 = (wxWindow *) 0 ;
32691 void *argp1 = 0 ;
32692 int res1 = 0 ;
32693 void *argp2 = 0 ;
32694 int res2 = 0 ;
32695 PyObject * obj0 = 0 ;
32696 PyObject * obj1 = 0 ;
32697 char * kwnames[] = {
32698 (char *) "self",(char *) "win", NULL
32699 };
32700
32701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32705 }
32706 arg1 = reinterpret_cast< wxWindow * >(argp1);
32707 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32708 if (!SWIG_IsOK(res2)) {
32709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32710 }
32711 arg2 = reinterpret_cast< wxWindow * >(argp2);
32712 {
32713 PyThreadState* __tstate = wxPyBeginAllowThreads();
32714 (arg1)->SetTmpDefaultItem(arg2);
32715 wxPyEndAllowThreads(__tstate);
32716 if (PyErr_Occurred()) SWIG_fail;
32717 }
32718 resultobj = SWIG_Py_Void();
32719 return resultobj;
32720 fail:
32721 return NULL;
32722 }
32723
32724
32725 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32726 PyObject *resultobj = 0;
32727 wxWindow *arg1 = (wxWindow *) 0 ;
32728 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32729 bool result;
32730 void *argp1 = 0 ;
32731 int res1 = 0 ;
32732 int val2 ;
32733 int ecode2 = 0 ;
32734 PyObject * obj0 = 0 ;
32735 PyObject * obj1 = 0 ;
32736 char * kwnames[] = {
32737 (char *) "self",(char *) "flags", NULL
32738 };
32739
32740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32742 if (!SWIG_IsOK(res1)) {
32743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32744 }
32745 arg1 = reinterpret_cast< wxWindow * >(argp1);
32746 if (obj1) {
32747 ecode2 = SWIG_AsVal_int(obj1, &val2);
32748 if (!SWIG_IsOK(ecode2)) {
32749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32750 }
32751 arg2 = static_cast< int >(val2);
32752 }
32753 {
32754 PyThreadState* __tstate = wxPyBeginAllowThreads();
32755 result = (bool)(arg1)->Navigate(arg2);
32756 wxPyEndAllowThreads(__tstate);
32757 if (PyErr_Occurred()) SWIG_fail;
32758 }
32759 {
32760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32761 }
32762 return resultobj;
32763 fail:
32764 return NULL;
32765 }
32766
32767
32768 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32769 PyObject *resultobj = 0;
32770 wxWindow *arg1 = (wxWindow *) 0 ;
32771 wxWindow *arg2 = (wxWindow *) 0 ;
32772 void *argp1 = 0 ;
32773 int res1 = 0 ;
32774 void *argp2 = 0 ;
32775 int res2 = 0 ;
32776 PyObject * obj0 = 0 ;
32777 PyObject * obj1 = 0 ;
32778 char * kwnames[] = {
32779 (char *) "self",(char *) "win", NULL
32780 };
32781
32782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32784 if (!SWIG_IsOK(res1)) {
32785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32786 }
32787 arg1 = reinterpret_cast< wxWindow * >(argp1);
32788 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32789 if (!SWIG_IsOK(res2)) {
32790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32791 }
32792 arg2 = reinterpret_cast< wxWindow * >(argp2);
32793 {
32794 PyThreadState* __tstate = wxPyBeginAllowThreads();
32795 (arg1)->MoveAfterInTabOrder(arg2);
32796 wxPyEndAllowThreads(__tstate);
32797 if (PyErr_Occurred()) SWIG_fail;
32798 }
32799 resultobj = SWIG_Py_Void();
32800 return resultobj;
32801 fail:
32802 return NULL;
32803 }
32804
32805
32806 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32807 PyObject *resultobj = 0;
32808 wxWindow *arg1 = (wxWindow *) 0 ;
32809 wxWindow *arg2 = (wxWindow *) 0 ;
32810 void *argp1 = 0 ;
32811 int res1 = 0 ;
32812 void *argp2 = 0 ;
32813 int res2 = 0 ;
32814 PyObject * obj0 = 0 ;
32815 PyObject * obj1 = 0 ;
32816 char * kwnames[] = {
32817 (char *) "self",(char *) "win", NULL
32818 };
32819
32820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32822 if (!SWIG_IsOK(res1)) {
32823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32824 }
32825 arg1 = reinterpret_cast< wxWindow * >(argp1);
32826 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32827 if (!SWIG_IsOK(res2)) {
32828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32829 }
32830 arg2 = reinterpret_cast< wxWindow * >(argp2);
32831 {
32832 PyThreadState* __tstate = wxPyBeginAllowThreads();
32833 (arg1)->MoveBeforeInTabOrder(arg2);
32834 wxPyEndAllowThreads(__tstate);
32835 if (PyErr_Occurred()) SWIG_fail;
32836 }
32837 resultobj = SWIG_Py_Void();
32838 return resultobj;
32839 fail:
32840 return NULL;
32841 }
32842
32843
32844 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32845 PyObject *resultobj = 0;
32846 wxWindow *arg1 = (wxWindow *) 0 ;
32847 PyObject *result = 0 ;
32848 void *argp1 = 0 ;
32849 int res1 = 0 ;
32850 PyObject *swig_obj[1] ;
32851
32852 if (!args) SWIG_fail;
32853 swig_obj[0] = args;
32854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32855 if (!SWIG_IsOK(res1)) {
32856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32857 }
32858 arg1 = reinterpret_cast< wxWindow * >(argp1);
32859 {
32860 PyThreadState* __tstate = wxPyBeginAllowThreads();
32861 result = (PyObject *)wxWindow_GetChildren(arg1);
32862 wxPyEndAllowThreads(__tstate);
32863 if (PyErr_Occurred()) SWIG_fail;
32864 }
32865 resultobj = result;
32866 return resultobj;
32867 fail:
32868 return NULL;
32869 }
32870
32871
32872 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32873 PyObject *resultobj = 0;
32874 wxWindow *arg1 = (wxWindow *) 0 ;
32875 wxWindow *result = 0 ;
32876 void *argp1 = 0 ;
32877 int res1 = 0 ;
32878 PyObject *swig_obj[1] ;
32879
32880 if (!args) SWIG_fail;
32881 swig_obj[0] = args;
32882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32883 if (!SWIG_IsOK(res1)) {
32884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32885 }
32886 arg1 = reinterpret_cast< wxWindow * >(argp1);
32887 {
32888 PyThreadState* __tstate = wxPyBeginAllowThreads();
32889 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32890 wxPyEndAllowThreads(__tstate);
32891 if (PyErr_Occurred()) SWIG_fail;
32892 }
32893 {
32894 resultobj = wxPyMake_wxObject(result, 0);
32895 }
32896 return resultobj;
32897 fail:
32898 return NULL;
32899 }
32900
32901
32902 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32903 PyObject *resultobj = 0;
32904 wxWindow *arg1 = (wxWindow *) 0 ;
32905 wxWindow *result = 0 ;
32906 void *argp1 = 0 ;
32907 int res1 = 0 ;
32908 PyObject *swig_obj[1] ;
32909
32910 if (!args) SWIG_fail;
32911 swig_obj[0] = args;
32912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32913 if (!SWIG_IsOK(res1)) {
32914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32915 }
32916 arg1 = reinterpret_cast< wxWindow * >(argp1);
32917 {
32918 PyThreadState* __tstate = wxPyBeginAllowThreads();
32919 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32920 wxPyEndAllowThreads(__tstate);
32921 if (PyErr_Occurred()) SWIG_fail;
32922 }
32923 {
32924 resultobj = wxPyMake_wxObject(result, 0);
32925 }
32926 return resultobj;
32927 fail:
32928 return NULL;
32929 }
32930
32931
32932 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32933 PyObject *resultobj = 0;
32934 wxWindow *arg1 = (wxWindow *) 0 ;
32935 bool result;
32936 void *argp1 = 0 ;
32937 int res1 = 0 ;
32938 PyObject *swig_obj[1] ;
32939
32940 if (!args) SWIG_fail;
32941 swig_obj[0] = args;
32942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32943 if (!SWIG_IsOK(res1)) {
32944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32945 }
32946 arg1 = reinterpret_cast< wxWindow * >(argp1);
32947 {
32948 PyThreadState* __tstate = wxPyBeginAllowThreads();
32949 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32950 wxPyEndAllowThreads(__tstate);
32951 if (PyErr_Occurred()) SWIG_fail;
32952 }
32953 {
32954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32955 }
32956 return resultobj;
32957 fail:
32958 return NULL;
32959 }
32960
32961
32962 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32963 PyObject *resultobj = 0;
32964 wxWindow *arg1 = (wxWindow *) 0 ;
32965 wxWindow *arg2 = (wxWindow *) 0 ;
32966 bool result;
32967 void *argp1 = 0 ;
32968 int res1 = 0 ;
32969 void *argp2 = 0 ;
32970 int res2 = 0 ;
32971 PyObject * obj0 = 0 ;
32972 PyObject * obj1 = 0 ;
32973 char * kwnames[] = {
32974 (char *) "self",(char *) "newParent", NULL
32975 };
32976
32977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
32978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32979 if (!SWIG_IsOK(res1)) {
32980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
32981 }
32982 arg1 = reinterpret_cast< wxWindow * >(argp1);
32983 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32984 if (!SWIG_IsOK(res2)) {
32985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
32986 }
32987 arg2 = reinterpret_cast< wxWindow * >(argp2);
32988 {
32989 PyThreadState* __tstate = wxPyBeginAllowThreads();
32990 result = (bool)(arg1)->Reparent(arg2);
32991 wxPyEndAllowThreads(__tstate);
32992 if (PyErr_Occurred()) SWIG_fail;
32993 }
32994 {
32995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32996 }
32997 return resultobj;
32998 fail:
32999 return NULL;
33000 }
33001
33002
33003 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33004 PyObject *resultobj = 0;
33005 wxWindow *arg1 = (wxWindow *) 0 ;
33006 wxWindow *arg2 = (wxWindow *) 0 ;
33007 void *argp1 = 0 ;
33008 int res1 = 0 ;
33009 void *argp2 = 0 ;
33010 int res2 = 0 ;
33011 PyObject * obj0 = 0 ;
33012 PyObject * obj1 = 0 ;
33013 char * kwnames[] = {
33014 (char *) "self",(char *) "child", NULL
33015 };
33016
33017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33019 if (!SWIG_IsOK(res1)) {
33020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33021 }
33022 arg1 = reinterpret_cast< wxWindow * >(argp1);
33023 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33024 if (!SWIG_IsOK(res2)) {
33025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33026 }
33027 arg2 = reinterpret_cast< wxWindow * >(argp2);
33028 {
33029 PyThreadState* __tstate = wxPyBeginAllowThreads();
33030 (arg1)->AddChild(arg2);
33031 wxPyEndAllowThreads(__tstate);
33032 if (PyErr_Occurred()) SWIG_fail;
33033 }
33034 resultobj = SWIG_Py_Void();
33035 return resultobj;
33036 fail:
33037 return NULL;
33038 }
33039
33040
33041 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33042 PyObject *resultobj = 0;
33043 wxWindow *arg1 = (wxWindow *) 0 ;
33044 wxWindow *arg2 = (wxWindow *) 0 ;
33045 void *argp1 = 0 ;
33046 int res1 = 0 ;
33047 void *argp2 = 0 ;
33048 int res2 = 0 ;
33049 PyObject * obj0 = 0 ;
33050 PyObject * obj1 = 0 ;
33051 char * kwnames[] = {
33052 (char *) "self",(char *) "child", NULL
33053 };
33054
33055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33057 if (!SWIG_IsOK(res1)) {
33058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33059 }
33060 arg1 = reinterpret_cast< wxWindow * >(argp1);
33061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33062 if (!SWIG_IsOK(res2)) {
33063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33064 }
33065 arg2 = reinterpret_cast< wxWindow * >(argp2);
33066 {
33067 PyThreadState* __tstate = wxPyBeginAllowThreads();
33068 (arg1)->RemoveChild(arg2);
33069 wxPyEndAllowThreads(__tstate);
33070 if (PyErr_Occurred()) SWIG_fail;
33071 }
33072 resultobj = SWIG_Py_Void();
33073 return resultobj;
33074 fail:
33075 return NULL;
33076 }
33077
33078
33079 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33080 PyObject *resultobj = 0;
33081 wxWindow *arg1 = (wxWindow *) 0 ;
33082 long arg2 ;
33083 wxWindow *result = 0 ;
33084 void *argp1 = 0 ;
33085 int res1 = 0 ;
33086 long val2 ;
33087 int ecode2 = 0 ;
33088 PyObject * obj0 = 0 ;
33089 PyObject * obj1 = 0 ;
33090 char * kwnames[] = {
33091 (char *) "self",(char *) "winid", NULL
33092 };
33093
33094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33096 if (!SWIG_IsOK(res1)) {
33097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33098 }
33099 arg1 = reinterpret_cast< wxWindow * >(argp1);
33100 ecode2 = SWIG_AsVal_long(obj1, &val2);
33101 if (!SWIG_IsOK(ecode2)) {
33102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33103 }
33104 arg2 = static_cast< long >(val2);
33105 {
33106 PyThreadState* __tstate = wxPyBeginAllowThreads();
33107 result = (wxWindow *)(arg1)->FindWindow(arg2);
33108 wxPyEndAllowThreads(__tstate);
33109 if (PyErr_Occurred()) SWIG_fail;
33110 }
33111 {
33112 resultobj = wxPyMake_wxObject(result, 0);
33113 }
33114 return resultobj;
33115 fail:
33116 return NULL;
33117 }
33118
33119
33120 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33121 PyObject *resultobj = 0;
33122 wxWindow *arg1 = (wxWindow *) 0 ;
33123 wxString *arg2 = 0 ;
33124 wxWindow *result = 0 ;
33125 void *argp1 = 0 ;
33126 int res1 = 0 ;
33127 bool temp2 = false ;
33128 PyObject * obj0 = 0 ;
33129 PyObject * obj1 = 0 ;
33130 char * kwnames[] = {
33131 (char *) "self",(char *) "name", NULL
33132 };
33133
33134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33136 if (!SWIG_IsOK(res1)) {
33137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33138 }
33139 arg1 = reinterpret_cast< wxWindow * >(argp1);
33140 {
33141 arg2 = wxString_in_helper(obj1);
33142 if (arg2 == NULL) SWIG_fail;
33143 temp2 = true;
33144 }
33145 {
33146 PyThreadState* __tstate = wxPyBeginAllowThreads();
33147 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33148 wxPyEndAllowThreads(__tstate);
33149 if (PyErr_Occurred()) SWIG_fail;
33150 }
33151 {
33152 resultobj = wxPyMake_wxObject(result, 0);
33153 }
33154 {
33155 if (temp2)
33156 delete arg2;
33157 }
33158 return resultobj;
33159 fail:
33160 {
33161 if (temp2)
33162 delete arg2;
33163 }
33164 return NULL;
33165 }
33166
33167
33168 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33169 PyObject *resultobj = 0;
33170 wxWindow *arg1 = (wxWindow *) 0 ;
33171 wxEvtHandler *result = 0 ;
33172 void *argp1 = 0 ;
33173 int res1 = 0 ;
33174 PyObject *swig_obj[1] ;
33175
33176 if (!args) SWIG_fail;
33177 swig_obj[0] = args;
33178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33179 if (!SWIG_IsOK(res1)) {
33180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33181 }
33182 arg1 = reinterpret_cast< wxWindow * >(argp1);
33183 {
33184 PyThreadState* __tstate = wxPyBeginAllowThreads();
33185 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33186 wxPyEndAllowThreads(__tstate);
33187 if (PyErr_Occurred()) SWIG_fail;
33188 }
33189 {
33190 resultobj = wxPyMake_wxObject(result, 0);
33191 }
33192 return resultobj;
33193 fail:
33194 return NULL;
33195 }
33196
33197
33198 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33199 PyObject *resultobj = 0;
33200 wxWindow *arg1 = (wxWindow *) 0 ;
33201 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33202 void *argp1 = 0 ;
33203 int res1 = 0 ;
33204 void *argp2 = 0 ;
33205 int res2 = 0 ;
33206 PyObject * obj0 = 0 ;
33207 PyObject * obj1 = 0 ;
33208 char * kwnames[] = {
33209 (char *) "self",(char *) "handler", NULL
33210 };
33211
33212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33214 if (!SWIG_IsOK(res1)) {
33215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33216 }
33217 arg1 = reinterpret_cast< wxWindow * >(argp1);
33218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33219 if (!SWIG_IsOK(res2)) {
33220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33221 }
33222 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33223 {
33224 PyThreadState* __tstate = wxPyBeginAllowThreads();
33225 (arg1)->SetEventHandler(arg2);
33226 wxPyEndAllowThreads(__tstate);
33227 if (PyErr_Occurred()) SWIG_fail;
33228 }
33229 resultobj = SWIG_Py_Void();
33230 return resultobj;
33231 fail:
33232 return NULL;
33233 }
33234
33235
33236 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33237 PyObject *resultobj = 0;
33238 wxWindow *arg1 = (wxWindow *) 0 ;
33239 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33240 void *argp1 = 0 ;
33241 int res1 = 0 ;
33242 void *argp2 = 0 ;
33243 int res2 = 0 ;
33244 PyObject * obj0 = 0 ;
33245 PyObject * obj1 = 0 ;
33246 char * kwnames[] = {
33247 (char *) "self",(char *) "handler", NULL
33248 };
33249
33250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33252 if (!SWIG_IsOK(res1)) {
33253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33254 }
33255 arg1 = reinterpret_cast< wxWindow * >(argp1);
33256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33257 if (!SWIG_IsOK(res2)) {
33258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33259 }
33260 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33261 {
33262 PyThreadState* __tstate = wxPyBeginAllowThreads();
33263 (arg1)->PushEventHandler(arg2);
33264 wxPyEndAllowThreads(__tstate);
33265 if (PyErr_Occurred()) SWIG_fail;
33266 }
33267 resultobj = SWIG_Py_Void();
33268 return resultobj;
33269 fail:
33270 return NULL;
33271 }
33272
33273
33274 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33275 PyObject *resultobj = 0;
33276 wxWindow *arg1 = (wxWindow *) 0 ;
33277 bool arg2 = (bool) false ;
33278 wxEvtHandler *result = 0 ;
33279 void *argp1 = 0 ;
33280 int res1 = 0 ;
33281 bool val2 ;
33282 int ecode2 = 0 ;
33283 PyObject * obj0 = 0 ;
33284 PyObject * obj1 = 0 ;
33285 char * kwnames[] = {
33286 (char *) "self",(char *) "deleteHandler", NULL
33287 };
33288
33289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33291 if (!SWIG_IsOK(res1)) {
33292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33293 }
33294 arg1 = reinterpret_cast< wxWindow * >(argp1);
33295 if (obj1) {
33296 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33297 if (!SWIG_IsOK(ecode2)) {
33298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33299 }
33300 arg2 = static_cast< bool >(val2);
33301 }
33302 {
33303 PyThreadState* __tstate = wxPyBeginAllowThreads();
33304 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33305 wxPyEndAllowThreads(__tstate);
33306 if (PyErr_Occurred()) SWIG_fail;
33307 }
33308 {
33309 resultobj = wxPyMake_wxObject(result, 0);
33310 }
33311 return resultobj;
33312 fail:
33313 return NULL;
33314 }
33315
33316
33317 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33318 PyObject *resultobj = 0;
33319 wxWindow *arg1 = (wxWindow *) 0 ;
33320 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33321 bool result;
33322 void *argp1 = 0 ;
33323 int res1 = 0 ;
33324 void *argp2 = 0 ;
33325 int res2 = 0 ;
33326 PyObject * obj0 = 0 ;
33327 PyObject * obj1 = 0 ;
33328 char * kwnames[] = {
33329 (char *) "self",(char *) "handler", NULL
33330 };
33331
33332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33334 if (!SWIG_IsOK(res1)) {
33335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33336 }
33337 arg1 = reinterpret_cast< wxWindow * >(argp1);
33338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33339 if (!SWIG_IsOK(res2)) {
33340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33341 }
33342 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (bool)(arg1)->RemoveEventHandler(arg2);
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 {
33350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33351 }
33352 return resultobj;
33353 fail:
33354 return NULL;
33355 }
33356
33357
33358 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33359 PyObject *resultobj = 0;
33360 wxWindow *arg1 = (wxWindow *) 0 ;
33361 wxValidator *arg2 = 0 ;
33362 void *argp1 = 0 ;
33363 int res1 = 0 ;
33364 void *argp2 = 0 ;
33365 int res2 = 0 ;
33366 PyObject * obj0 = 0 ;
33367 PyObject * obj1 = 0 ;
33368 char * kwnames[] = {
33369 (char *) "self",(char *) "validator", NULL
33370 };
33371
33372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33374 if (!SWIG_IsOK(res1)) {
33375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33376 }
33377 arg1 = reinterpret_cast< wxWindow * >(argp1);
33378 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33379 if (!SWIG_IsOK(res2)) {
33380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33381 }
33382 if (!argp2) {
33383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33384 }
33385 arg2 = reinterpret_cast< wxValidator * >(argp2);
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 (arg1)->SetValidator((wxValidator const &)*arg2);
33389 wxPyEndAllowThreads(__tstate);
33390 if (PyErr_Occurred()) SWIG_fail;
33391 }
33392 resultobj = SWIG_Py_Void();
33393 return resultobj;
33394 fail:
33395 return NULL;
33396 }
33397
33398
33399 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33400 PyObject *resultobj = 0;
33401 wxWindow *arg1 = (wxWindow *) 0 ;
33402 wxValidator *result = 0 ;
33403 void *argp1 = 0 ;
33404 int res1 = 0 ;
33405 PyObject *swig_obj[1] ;
33406
33407 if (!args) SWIG_fail;
33408 swig_obj[0] = args;
33409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33410 if (!SWIG_IsOK(res1)) {
33411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33412 }
33413 arg1 = reinterpret_cast< wxWindow * >(argp1);
33414 {
33415 PyThreadState* __tstate = wxPyBeginAllowThreads();
33416 result = (wxValidator *)(arg1)->GetValidator();
33417 wxPyEndAllowThreads(__tstate);
33418 if (PyErr_Occurred()) SWIG_fail;
33419 }
33420 {
33421 resultobj = wxPyMake_wxObject(result, (bool)0);
33422 }
33423 return resultobj;
33424 fail:
33425 return NULL;
33426 }
33427
33428
33429 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33430 PyObject *resultobj = 0;
33431 wxWindow *arg1 = (wxWindow *) 0 ;
33432 bool result;
33433 void *argp1 = 0 ;
33434 int res1 = 0 ;
33435 PyObject *swig_obj[1] ;
33436
33437 if (!args) SWIG_fail;
33438 swig_obj[0] = args;
33439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33440 if (!SWIG_IsOK(res1)) {
33441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33442 }
33443 arg1 = reinterpret_cast< wxWindow * >(argp1);
33444 {
33445 PyThreadState* __tstate = wxPyBeginAllowThreads();
33446 result = (bool)(arg1)->Validate();
33447 wxPyEndAllowThreads(__tstate);
33448 if (PyErr_Occurred()) SWIG_fail;
33449 }
33450 {
33451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33452 }
33453 return resultobj;
33454 fail:
33455 return NULL;
33456 }
33457
33458
33459 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33460 PyObject *resultobj = 0;
33461 wxWindow *arg1 = (wxWindow *) 0 ;
33462 bool result;
33463 void *argp1 = 0 ;
33464 int res1 = 0 ;
33465 PyObject *swig_obj[1] ;
33466
33467 if (!args) SWIG_fail;
33468 swig_obj[0] = args;
33469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33470 if (!SWIG_IsOK(res1)) {
33471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33472 }
33473 arg1 = reinterpret_cast< wxWindow * >(argp1);
33474 {
33475 PyThreadState* __tstate = wxPyBeginAllowThreads();
33476 result = (bool)(arg1)->TransferDataToWindow();
33477 wxPyEndAllowThreads(__tstate);
33478 if (PyErr_Occurred()) SWIG_fail;
33479 }
33480 {
33481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33482 }
33483 return resultobj;
33484 fail:
33485 return NULL;
33486 }
33487
33488
33489 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33490 PyObject *resultobj = 0;
33491 wxWindow *arg1 = (wxWindow *) 0 ;
33492 bool result;
33493 void *argp1 = 0 ;
33494 int res1 = 0 ;
33495 PyObject *swig_obj[1] ;
33496
33497 if (!args) SWIG_fail;
33498 swig_obj[0] = args;
33499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33500 if (!SWIG_IsOK(res1)) {
33501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33502 }
33503 arg1 = reinterpret_cast< wxWindow * >(argp1);
33504 {
33505 PyThreadState* __tstate = wxPyBeginAllowThreads();
33506 result = (bool)(arg1)->TransferDataFromWindow();
33507 wxPyEndAllowThreads(__tstate);
33508 if (PyErr_Occurred()) SWIG_fail;
33509 }
33510 {
33511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33512 }
33513 return resultobj;
33514 fail:
33515 return NULL;
33516 }
33517
33518
33519 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33520 PyObject *resultobj = 0;
33521 wxWindow *arg1 = (wxWindow *) 0 ;
33522 void *argp1 = 0 ;
33523 int res1 = 0 ;
33524 PyObject *swig_obj[1] ;
33525
33526 if (!args) SWIG_fail;
33527 swig_obj[0] = args;
33528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33529 if (!SWIG_IsOK(res1)) {
33530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33531 }
33532 arg1 = reinterpret_cast< wxWindow * >(argp1);
33533 {
33534 PyThreadState* __tstate = wxPyBeginAllowThreads();
33535 (arg1)->InitDialog();
33536 wxPyEndAllowThreads(__tstate);
33537 if (PyErr_Occurred()) SWIG_fail;
33538 }
33539 resultobj = SWIG_Py_Void();
33540 return resultobj;
33541 fail:
33542 return NULL;
33543 }
33544
33545
33546 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33547 PyObject *resultobj = 0;
33548 wxWindow *arg1 = (wxWindow *) 0 ;
33549 wxAcceleratorTable *arg2 = 0 ;
33550 void *argp1 = 0 ;
33551 int res1 = 0 ;
33552 void *argp2 = 0 ;
33553 int res2 = 0 ;
33554 PyObject * obj0 = 0 ;
33555 PyObject * obj1 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "self",(char *) "accel", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33562 if (!SWIG_IsOK(res1)) {
33563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33564 }
33565 arg1 = reinterpret_cast< wxWindow * >(argp1);
33566 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33567 if (!SWIG_IsOK(res2)) {
33568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33569 }
33570 if (!argp2) {
33571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33572 }
33573 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33574 {
33575 PyThreadState* __tstate = wxPyBeginAllowThreads();
33576 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33577 wxPyEndAllowThreads(__tstate);
33578 if (PyErr_Occurred()) SWIG_fail;
33579 }
33580 resultobj = SWIG_Py_Void();
33581 return resultobj;
33582 fail:
33583 return NULL;
33584 }
33585
33586
33587 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33588 PyObject *resultobj = 0;
33589 wxWindow *arg1 = (wxWindow *) 0 ;
33590 wxAcceleratorTable *result = 0 ;
33591 void *argp1 = 0 ;
33592 int res1 = 0 ;
33593 PyObject *swig_obj[1] ;
33594
33595 if (!args) SWIG_fail;
33596 swig_obj[0] = args;
33597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33598 if (!SWIG_IsOK(res1)) {
33599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33600 }
33601 arg1 = reinterpret_cast< wxWindow * >(argp1);
33602 {
33603 PyThreadState* __tstate = wxPyBeginAllowThreads();
33604 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33605 wxPyEndAllowThreads(__tstate);
33606 if (PyErr_Occurred()) SWIG_fail;
33607 }
33608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33609 return resultobj;
33610 fail:
33611 return NULL;
33612 }
33613
33614
33615 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33616 PyObject *resultobj = 0;
33617 wxWindow *arg1 = (wxWindow *) 0 ;
33618 int arg2 ;
33619 int arg3 ;
33620 int arg4 ;
33621 bool result;
33622 void *argp1 = 0 ;
33623 int res1 = 0 ;
33624 int val2 ;
33625 int ecode2 = 0 ;
33626 int val3 ;
33627 int ecode3 = 0 ;
33628 int val4 ;
33629 int ecode4 = 0 ;
33630 PyObject * obj0 = 0 ;
33631 PyObject * obj1 = 0 ;
33632 PyObject * obj2 = 0 ;
33633 PyObject * obj3 = 0 ;
33634 char * kwnames[] = {
33635 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33636 };
33637
33638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33640 if (!SWIG_IsOK(res1)) {
33641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33642 }
33643 arg1 = reinterpret_cast< wxWindow * >(argp1);
33644 ecode2 = SWIG_AsVal_int(obj1, &val2);
33645 if (!SWIG_IsOK(ecode2)) {
33646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33647 }
33648 arg2 = static_cast< int >(val2);
33649 ecode3 = SWIG_AsVal_int(obj2, &val3);
33650 if (!SWIG_IsOK(ecode3)) {
33651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33652 }
33653 arg3 = static_cast< int >(val3);
33654 ecode4 = SWIG_AsVal_int(obj3, &val4);
33655 if (!SWIG_IsOK(ecode4)) {
33656 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33657 }
33658 arg4 = static_cast< int >(val4);
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 {
33666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33667 }
33668 return resultobj;
33669 fail:
33670 return NULL;
33671 }
33672
33673
33674 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33675 PyObject *resultobj = 0;
33676 wxWindow *arg1 = (wxWindow *) 0 ;
33677 int arg2 ;
33678 bool result;
33679 void *argp1 = 0 ;
33680 int res1 = 0 ;
33681 int val2 ;
33682 int ecode2 = 0 ;
33683 PyObject * obj0 = 0 ;
33684 PyObject * obj1 = 0 ;
33685 char * kwnames[] = {
33686 (char *) "self",(char *) "hotkeyId", NULL
33687 };
33688
33689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33691 if (!SWIG_IsOK(res1)) {
33692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33693 }
33694 arg1 = reinterpret_cast< wxWindow * >(argp1);
33695 ecode2 = SWIG_AsVal_int(obj1, &val2);
33696 if (!SWIG_IsOK(ecode2)) {
33697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33698 }
33699 arg2 = static_cast< int >(val2);
33700 {
33701 PyThreadState* __tstate = wxPyBeginAllowThreads();
33702 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33703 wxPyEndAllowThreads(__tstate);
33704 if (PyErr_Occurred()) SWIG_fail;
33705 }
33706 {
33707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33708 }
33709 return resultobj;
33710 fail:
33711 return NULL;
33712 }
33713
33714
33715 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33716 PyObject *resultobj = 0;
33717 wxWindow *arg1 = (wxWindow *) 0 ;
33718 wxPoint *arg2 = 0 ;
33719 wxPoint result;
33720 void *argp1 = 0 ;
33721 int res1 = 0 ;
33722 wxPoint temp2 ;
33723 PyObject * obj0 = 0 ;
33724 PyObject * obj1 = 0 ;
33725 char * kwnames[] = {
33726 (char *) "self",(char *) "pt", NULL
33727 };
33728
33729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33731 if (!SWIG_IsOK(res1)) {
33732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33733 }
33734 arg1 = reinterpret_cast< wxWindow * >(argp1);
33735 {
33736 arg2 = &temp2;
33737 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33738 }
33739 {
33740 PyThreadState* __tstate = wxPyBeginAllowThreads();
33741 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33742 wxPyEndAllowThreads(__tstate);
33743 if (PyErr_Occurred()) SWIG_fail;
33744 }
33745 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33746 return resultobj;
33747 fail:
33748 return NULL;
33749 }
33750
33751
33752 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33753 PyObject *resultobj = 0;
33754 wxWindow *arg1 = (wxWindow *) 0 ;
33755 wxSize *arg2 = 0 ;
33756 wxSize result;
33757 void *argp1 = 0 ;
33758 int res1 = 0 ;
33759 wxSize temp2 ;
33760 PyObject * obj0 = 0 ;
33761 PyObject * obj1 = 0 ;
33762 char * kwnames[] = {
33763 (char *) "self",(char *) "sz", NULL
33764 };
33765
33766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33768 if (!SWIG_IsOK(res1)) {
33769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33770 }
33771 arg1 = reinterpret_cast< wxWindow * >(argp1);
33772 {
33773 arg2 = &temp2;
33774 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33775 }
33776 {
33777 PyThreadState* __tstate = wxPyBeginAllowThreads();
33778 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33779 wxPyEndAllowThreads(__tstate);
33780 if (PyErr_Occurred()) SWIG_fail;
33781 }
33782 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33783 return resultobj;
33784 fail:
33785 return NULL;
33786 }
33787
33788
33789 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33790 PyObject *resultobj = 0;
33791 wxWindow *arg1 = (wxWindow *) 0 ;
33792 wxPoint *arg2 = 0 ;
33793 wxPoint result;
33794 void *argp1 = 0 ;
33795 int res1 = 0 ;
33796 wxPoint temp2 ;
33797 PyObject * obj0 = 0 ;
33798 PyObject * obj1 = 0 ;
33799 char * kwnames[] = {
33800 (char *) "self",(char *) "pt", NULL
33801 };
33802
33803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33805 if (!SWIG_IsOK(res1)) {
33806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33807 }
33808 arg1 = reinterpret_cast< wxWindow * >(argp1);
33809 {
33810 arg2 = &temp2;
33811 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33812 }
33813 {
33814 PyThreadState* __tstate = wxPyBeginAllowThreads();
33815 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33816 wxPyEndAllowThreads(__tstate);
33817 if (PyErr_Occurred()) SWIG_fail;
33818 }
33819 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33820 return resultobj;
33821 fail:
33822 return NULL;
33823 }
33824
33825
33826 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33827 PyObject *resultobj = 0;
33828 wxWindow *arg1 = (wxWindow *) 0 ;
33829 wxSize *arg2 = 0 ;
33830 wxSize result;
33831 void *argp1 = 0 ;
33832 int res1 = 0 ;
33833 wxSize temp2 ;
33834 PyObject * obj0 = 0 ;
33835 PyObject * obj1 = 0 ;
33836 char * kwnames[] = {
33837 (char *) "self",(char *) "sz", NULL
33838 };
33839
33840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33842 if (!SWIG_IsOK(res1)) {
33843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33844 }
33845 arg1 = reinterpret_cast< wxWindow * >(argp1);
33846 {
33847 arg2 = &temp2;
33848 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33849 }
33850 {
33851 PyThreadState* __tstate = wxPyBeginAllowThreads();
33852 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33853 wxPyEndAllowThreads(__tstate);
33854 if (PyErr_Occurred()) SWIG_fail;
33855 }
33856 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33857 return resultobj;
33858 fail:
33859 return NULL;
33860 }
33861
33862
33863 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33864 PyObject *resultobj = 0;
33865 wxWindow *arg1 = (wxWindow *) 0 ;
33866 wxPoint *arg2 = 0 ;
33867 wxPoint result;
33868 void *argp1 = 0 ;
33869 int res1 = 0 ;
33870 wxPoint temp2 ;
33871 PyObject * obj0 = 0 ;
33872 PyObject * obj1 = 0 ;
33873 char * kwnames[] = {
33874 (char *) "self",(char *) "pt", NULL
33875 };
33876
33877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33879 if (!SWIG_IsOK(res1)) {
33880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33881 }
33882 arg1 = reinterpret_cast< wxWindow * >(argp1);
33883 {
33884 arg2 = &temp2;
33885 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33886 }
33887 {
33888 PyThreadState* __tstate = wxPyBeginAllowThreads();
33889 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33890 wxPyEndAllowThreads(__tstate);
33891 if (PyErr_Occurred()) SWIG_fail;
33892 }
33893 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33894 return resultobj;
33895 fail:
33896 return NULL;
33897 }
33898
33899
33900 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33901 PyObject *resultobj = 0;
33902 wxWindow *arg1 = (wxWindow *) 0 ;
33903 wxSize *arg2 = 0 ;
33904 wxSize result;
33905 void *argp1 = 0 ;
33906 int res1 = 0 ;
33907 wxSize temp2 ;
33908 PyObject * obj0 = 0 ;
33909 PyObject * obj1 = 0 ;
33910 char * kwnames[] = {
33911 (char *) "self",(char *) "sz", NULL
33912 };
33913
33914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33916 if (!SWIG_IsOK(res1)) {
33917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33918 }
33919 arg1 = reinterpret_cast< wxWindow * >(argp1);
33920 {
33921 arg2 = &temp2;
33922 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33923 }
33924 {
33925 PyThreadState* __tstate = wxPyBeginAllowThreads();
33926 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33927 wxPyEndAllowThreads(__tstate);
33928 if (PyErr_Occurred()) SWIG_fail;
33929 }
33930 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33931 return resultobj;
33932 fail:
33933 return NULL;
33934 }
33935
33936
33937 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33938 PyObject *resultobj = 0;
33939 wxWindow *arg1 = (wxWindow *) 0 ;
33940 int arg2 ;
33941 int arg3 ;
33942 void *argp1 = 0 ;
33943 int res1 = 0 ;
33944 int val2 ;
33945 int ecode2 = 0 ;
33946 int val3 ;
33947 int ecode3 = 0 ;
33948 PyObject * obj0 = 0 ;
33949 PyObject * obj1 = 0 ;
33950 PyObject * obj2 = 0 ;
33951 char * kwnames[] = {
33952 (char *) "self",(char *) "x",(char *) "y", NULL
33953 };
33954
33955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33957 if (!SWIG_IsOK(res1)) {
33958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
33959 }
33960 arg1 = reinterpret_cast< wxWindow * >(argp1);
33961 ecode2 = SWIG_AsVal_int(obj1, &val2);
33962 if (!SWIG_IsOK(ecode2)) {
33963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
33964 }
33965 arg2 = static_cast< int >(val2);
33966 ecode3 = SWIG_AsVal_int(obj2, &val3);
33967 if (!SWIG_IsOK(ecode3)) {
33968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
33969 }
33970 arg3 = static_cast< int >(val3);
33971 {
33972 PyThreadState* __tstate = wxPyBeginAllowThreads();
33973 (arg1)->WarpPointer(arg2,arg3);
33974 wxPyEndAllowThreads(__tstate);
33975 if (PyErr_Occurred()) SWIG_fail;
33976 }
33977 resultobj = SWIG_Py_Void();
33978 return resultobj;
33979 fail:
33980 return NULL;
33981 }
33982
33983
33984 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33985 PyObject *resultobj = 0;
33986 wxWindow *arg1 = (wxWindow *) 0 ;
33987 void *argp1 = 0 ;
33988 int res1 = 0 ;
33989 PyObject *swig_obj[1] ;
33990
33991 if (!args) SWIG_fail;
33992 swig_obj[0] = args;
33993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33994 if (!SWIG_IsOK(res1)) {
33995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33996 }
33997 arg1 = reinterpret_cast< wxWindow * >(argp1);
33998 {
33999 PyThreadState* __tstate = wxPyBeginAllowThreads();
34000 (arg1)->CaptureMouse();
34001 wxPyEndAllowThreads(__tstate);
34002 if (PyErr_Occurred()) SWIG_fail;
34003 }
34004 resultobj = SWIG_Py_Void();
34005 return resultobj;
34006 fail:
34007 return NULL;
34008 }
34009
34010
34011 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34012 PyObject *resultobj = 0;
34013 wxWindow *arg1 = (wxWindow *) 0 ;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 PyObject *swig_obj[1] ;
34017
34018 if (!args) SWIG_fail;
34019 swig_obj[0] = args;
34020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34023 }
34024 arg1 = reinterpret_cast< wxWindow * >(argp1);
34025 {
34026 PyThreadState* __tstate = wxPyBeginAllowThreads();
34027 (arg1)->ReleaseMouse();
34028 wxPyEndAllowThreads(__tstate);
34029 if (PyErr_Occurred()) SWIG_fail;
34030 }
34031 resultobj = SWIG_Py_Void();
34032 return resultobj;
34033 fail:
34034 return NULL;
34035 }
34036
34037
34038 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34039 PyObject *resultobj = 0;
34040 wxWindow *result = 0 ;
34041
34042 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34043 {
34044 if (!wxPyCheckForApp()) SWIG_fail;
34045 PyThreadState* __tstate = wxPyBeginAllowThreads();
34046 result = (wxWindow *)wxWindow::GetCapture();
34047 wxPyEndAllowThreads(__tstate);
34048 if (PyErr_Occurred()) SWIG_fail;
34049 }
34050 {
34051 resultobj = wxPyMake_wxObject(result, 0);
34052 }
34053 return resultobj;
34054 fail:
34055 return NULL;
34056 }
34057
34058
34059 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34060 PyObject *resultobj = 0;
34061 wxWindow *arg1 = (wxWindow *) 0 ;
34062 bool result;
34063 void *argp1 = 0 ;
34064 int res1 = 0 ;
34065 PyObject *swig_obj[1] ;
34066
34067 if (!args) SWIG_fail;
34068 swig_obj[0] = args;
34069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 {
34075 PyThreadState* __tstate = wxPyBeginAllowThreads();
34076 result = (bool)((wxWindow const *)arg1)->HasCapture();
34077 wxPyEndAllowThreads(__tstate);
34078 if (PyErr_Occurred()) SWIG_fail;
34079 }
34080 {
34081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34082 }
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj = 0;
34091 wxWindow *arg1 = (wxWindow *) 0 ;
34092 bool arg2 = (bool) true ;
34093 wxRect *arg3 = (wxRect *) NULL ;
34094 void *argp1 = 0 ;
34095 int res1 = 0 ;
34096 bool val2 ;
34097 int ecode2 = 0 ;
34098 void *argp3 = 0 ;
34099 int res3 = 0 ;
34100 PyObject * obj0 = 0 ;
34101 PyObject * obj1 = 0 ;
34102 PyObject * obj2 = 0 ;
34103 char * kwnames[] = {
34104 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34105 };
34106
34107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34109 if (!SWIG_IsOK(res1)) {
34110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34111 }
34112 arg1 = reinterpret_cast< wxWindow * >(argp1);
34113 if (obj1) {
34114 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34115 if (!SWIG_IsOK(ecode2)) {
34116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34117 }
34118 arg2 = static_cast< bool >(val2);
34119 }
34120 if (obj2) {
34121 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34122 if (!SWIG_IsOK(res3)) {
34123 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34124 }
34125 arg3 = reinterpret_cast< wxRect * >(argp3);
34126 }
34127 {
34128 PyThreadState* __tstate = wxPyBeginAllowThreads();
34129 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34130 wxPyEndAllowThreads(__tstate);
34131 if (PyErr_Occurred()) SWIG_fail;
34132 }
34133 resultobj = SWIG_Py_Void();
34134 return resultobj;
34135 fail:
34136 return NULL;
34137 }
34138
34139
34140 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34141 PyObject *resultobj = 0;
34142 wxWindow *arg1 = (wxWindow *) 0 ;
34143 wxRect *arg2 = 0 ;
34144 bool arg3 = (bool) true ;
34145 void *argp1 = 0 ;
34146 int res1 = 0 ;
34147 wxRect temp2 ;
34148 bool val3 ;
34149 int ecode3 = 0 ;
34150 PyObject * obj0 = 0 ;
34151 PyObject * obj1 = 0 ;
34152 PyObject * obj2 = 0 ;
34153 char * kwnames[] = {
34154 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34155 };
34156
34157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34159 if (!SWIG_IsOK(res1)) {
34160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34161 }
34162 arg1 = reinterpret_cast< wxWindow * >(argp1);
34163 {
34164 arg2 = &temp2;
34165 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34166 }
34167 if (obj2) {
34168 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34169 if (!SWIG_IsOK(ecode3)) {
34170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34171 }
34172 arg3 = static_cast< bool >(val3);
34173 }
34174 {
34175 PyThreadState* __tstate = wxPyBeginAllowThreads();
34176 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34177 wxPyEndAllowThreads(__tstate);
34178 if (PyErr_Occurred()) SWIG_fail;
34179 }
34180 resultobj = SWIG_Py_Void();
34181 return resultobj;
34182 fail:
34183 return NULL;
34184 }
34185
34186
34187 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34188 PyObject *resultobj = 0;
34189 wxWindow *arg1 = (wxWindow *) 0 ;
34190 void *argp1 = 0 ;
34191 int res1 = 0 ;
34192 PyObject *swig_obj[1] ;
34193
34194 if (!args) SWIG_fail;
34195 swig_obj[0] = args;
34196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34197 if (!SWIG_IsOK(res1)) {
34198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34199 }
34200 arg1 = reinterpret_cast< wxWindow * >(argp1);
34201 {
34202 PyThreadState* __tstate = wxPyBeginAllowThreads();
34203 (arg1)->Update();
34204 wxPyEndAllowThreads(__tstate);
34205 if (PyErr_Occurred()) SWIG_fail;
34206 }
34207 resultobj = SWIG_Py_Void();
34208 return resultobj;
34209 fail:
34210 return NULL;
34211 }
34212
34213
34214 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34215 PyObject *resultobj = 0;
34216 wxWindow *arg1 = (wxWindow *) 0 ;
34217 void *argp1 = 0 ;
34218 int res1 = 0 ;
34219 PyObject *swig_obj[1] ;
34220
34221 if (!args) SWIG_fail;
34222 swig_obj[0] = args;
34223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34224 if (!SWIG_IsOK(res1)) {
34225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34226 }
34227 arg1 = reinterpret_cast< wxWindow * >(argp1);
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 (arg1)->ClearBackground();
34231 wxPyEndAllowThreads(__tstate);
34232 if (PyErr_Occurred()) SWIG_fail;
34233 }
34234 resultobj = SWIG_Py_Void();
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34242 PyObject *resultobj = 0;
34243 wxWindow *arg1 = (wxWindow *) 0 ;
34244 void *argp1 = 0 ;
34245 int res1 = 0 ;
34246 PyObject *swig_obj[1] ;
34247
34248 if (!args) SWIG_fail;
34249 swig_obj[0] = args;
34250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34251 if (!SWIG_IsOK(res1)) {
34252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34253 }
34254 arg1 = reinterpret_cast< wxWindow * >(argp1);
34255 {
34256 PyThreadState* __tstate = wxPyBeginAllowThreads();
34257 (arg1)->Freeze();
34258 wxPyEndAllowThreads(__tstate);
34259 if (PyErr_Occurred()) SWIG_fail;
34260 }
34261 resultobj = SWIG_Py_Void();
34262 return resultobj;
34263 fail:
34264 return NULL;
34265 }
34266
34267
34268 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34269 PyObject *resultobj = 0;
34270 wxWindow *arg1 = (wxWindow *) 0 ;
34271 void *argp1 = 0 ;
34272 int res1 = 0 ;
34273 PyObject *swig_obj[1] ;
34274
34275 if (!args) SWIG_fail;
34276 swig_obj[0] = args;
34277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34278 if (!SWIG_IsOK(res1)) {
34279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34280 }
34281 arg1 = reinterpret_cast< wxWindow * >(argp1);
34282 {
34283 PyThreadState* __tstate = wxPyBeginAllowThreads();
34284 (arg1)->Thaw();
34285 wxPyEndAllowThreads(__tstate);
34286 if (PyErr_Occurred()) SWIG_fail;
34287 }
34288 resultobj = SWIG_Py_Void();
34289 return resultobj;
34290 fail:
34291 return NULL;
34292 }
34293
34294
34295 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34296 PyObject *resultobj = 0;
34297 wxWindow *arg1 = (wxWindow *) 0 ;
34298 wxDC *arg2 = 0 ;
34299 void *argp1 = 0 ;
34300 int res1 = 0 ;
34301 void *argp2 = 0 ;
34302 int res2 = 0 ;
34303 PyObject * obj0 = 0 ;
34304 PyObject * obj1 = 0 ;
34305 char * kwnames[] = {
34306 (char *) "self",(char *) "dc", NULL
34307 };
34308
34309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34311 if (!SWIG_IsOK(res1)) {
34312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34313 }
34314 arg1 = reinterpret_cast< wxWindow * >(argp1);
34315 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34316 if (!SWIG_IsOK(res2)) {
34317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34318 }
34319 if (!argp2) {
34320 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34321 }
34322 arg2 = reinterpret_cast< wxDC * >(argp2);
34323 {
34324 PyThreadState* __tstate = wxPyBeginAllowThreads();
34325 (arg1)->PrepareDC(*arg2);
34326 wxPyEndAllowThreads(__tstate);
34327 if (PyErr_Occurred()) SWIG_fail;
34328 }
34329 resultobj = SWIG_Py_Void();
34330 return resultobj;
34331 fail:
34332 return NULL;
34333 }
34334
34335
34336 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34337 PyObject *resultobj = 0;
34338 wxWindow *arg1 = (wxWindow *) 0 ;
34339 wxRegion *result = 0 ;
34340 void *argp1 = 0 ;
34341 int res1 = 0 ;
34342 PyObject *swig_obj[1] ;
34343
34344 if (!args) SWIG_fail;
34345 swig_obj[0] = args;
34346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34347 if (!SWIG_IsOK(res1)) {
34348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34349 }
34350 arg1 = reinterpret_cast< wxWindow * >(argp1);
34351 {
34352 PyThreadState* __tstate = wxPyBeginAllowThreads();
34353 {
34354 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34355 result = (wxRegion *) &_result_ref;
34356 }
34357 wxPyEndAllowThreads(__tstate);
34358 if (PyErr_Occurred()) SWIG_fail;
34359 }
34360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34361 return resultobj;
34362 fail:
34363 return NULL;
34364 }
34365
34366
34367 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34368 PyObject *resultobj = 0;
34369 wxWindow *arg1 = (wxWindow *) 0 ;
34370 wxRect result;
34371 void *argp1 = 0 ;
34372 int res1 = 0 ;
34373 PyObject *swig_obj[1] ;
34374
34375 if (!args) SWIG_fail;
34376 swig_obj[0] = args;
34377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34378 if (!SWIG_IsOK(res1)) {
34379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34380 }
34381 arg1 = reinterpret_cast< wxWindow * >(argp1);
34382 {
34383 PyThreadState* __tstate = wxPyBeginAllowThreads();
34384 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34385 wxPyEndAllowThreads(__tstate);
34386 if (PyErr_Occurred()) SWIG_fail;
34387 }
34388 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34389 return resultobj;
34390 fail:
34391 return NULL;
34392 }
34393
34394
34395 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34396 PyObject *resultobj = 0;
34397 wxWindow *arg1 = (wxWindow *) 0 ;
34398 int arg2 ;
34399 int arg3 ;
34400 int arg4 = (int) 1 ;
34401 int arg5 = (int) 1 ;
34402 bool result;
34403 void *argp1 = 0 ;
34404 int res1 = 0 ;
34405 int val2 ;
34406 int ecode2 = 0 ;
34407 int val3 ;
34408 int ecode3 = 0 ;
34409 int val4 ;
34410 int ecode4 = 0 ;
34411 int val5 ;
34412 int ecode5 = 0 ;
34413 PyObject * obj0 = 0 ;
34414 PyObject * obj1 = 0 ;
34415 PyObject * obj2 = 0 ;
34416 PyObject * obj3 = 0 ;
34417 PyObject * obj4 = 0 ;
34418 char * kwnames[] = {
34419 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34420 };
34421
34422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34424 if (!SWIG_IsOK(res1)) {
34425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34426 }
34427 arg1 = reinterpret_cast< wxWindow * >(argp1);
34428 ecode2 = SWIG_AsVal_int(obj1, &val2);
34429 if (!SWIG_IsOK(ecode2)) {
34430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34431 }
34432 arg2 = static_cast< int >(val2);
34433 ecode3 = SWIG_AsVal_int(obj2, &val3);
34434 if (!SWIG_IsOK(ecode3)) {
34435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34436 }
34437 arg3 = static_cast< int >(val3);
34438 if (obj3) {
34439 ecode4 = SWIG_AsVal_int(obj3, &val4);
34440 if (!SWIG_IsOK(ecode4)) {
34441 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34442 }
34443 arg4 = static_cast< int >(val4);
34444 }
34445 if (obj4) {
34446 ecode5 = SWIG_AsVal_int(obj4, &val5);
34447 if (!SWIG_IsOK(ecode5)) {
34448 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34449 }
34450 arg5 = static_cast< int >(val5);
34451 }
34452 {
34453 PyThreadState* __tstate = wxPyBeginAllowThreads();
34454 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34455 wxPyEndAllowThreads(__tstate);
34456 if (PyErr_Occurred()) SWIG_fail;
34457 }
34458 {
34459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34460 }
34461 return resultobj;
34462 fail:
34463 return NULL;
34464 }
34465
34466
34467 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34468 PyObject *resultobj = 0;
34469 wxWindow *arg1 = (wxWindow *) 0 ;
34470 wxPoint *arg2 = 0 ;
34471 bool result;
34472 void *argp1 = 0 ;
34473 int res1 = 0 ;
34474 wxPoint temp2 ;
34475 PyObject * obj0 = 0 ;
34476 PyObject * obj1 = 0 ;
34477 char * kwnames[] = {
34478 (char *) "self",(char *) "pt", NULL
34479 };
34480
34481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34483 if (!SWIG_IsOK(res1)) {
34484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34485 }
34486 arg1 = reinterpret_cast< wxWindow * >(argp1);
34487 {
34488 arg2 = &temp2;
34489 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34490 }
34491 {
34492 PyThreadState* __tstate = wxPyBeginAllowThreads();
34493 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34494 wxPyEndAllowThreads(__tstate);
34495 if (PyErr_Occurred()) SWIG_fail;
34496 }
34497 {
34498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34499 }
34500 return resultobj;
34501 fail:
34502 return NULL;
34503 }
34504
34505
34506 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34507 PyObject *resultobj = 0;
34508 wxWindow *arg1 = (wxWindow *) 0 ;
34509 wxRect *arg2 = 0 ;
34510 bool result;
34511 void *argp1 = 0 ;
34512 int res1 = 0 ;
34513 wxRect temp2 ;
34514 PyObject * obj0 = 0 ;
34515 PyObject * obj1 = 0 ;
34516 char * kwnames[] = {
34517 (char *) "self",(char *) "rect", NULL
34518 };
34519
34520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34522 if (!SWIG_IsOK(res1)) {
34523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34524 }
34525 arg1 = reinterpret_cast< wxWindow * >(argp1);
34526 {
34527 arg2 = &temp2;
34528 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34529 }
34530 {
34531 PyThreadState* __tstate = wxPyBeginAllowThreads();
34532 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34533 wxPyEndAllowThreads(__tstate);
34534 if (PyErr_Occurred()) SWIG_fail;
34535 }
34536 {
34537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34538 }
34539 return resultobj;
34540 fail:
34541 return NULL;
34542 }
34543
34544
34545 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34546 PyObject *resultobj = 0;
34547 wxWindow *arg1 = (wxWindow *) 0 ;
34548 SwigValueWrapper<wxVisualAttributes > result;
34549 void *argp1 = 0 ;
34550 int res1 = 0 ;
34551 PyObject *swig_obj[1] ;
34552
34553 if (!args) SWIG_fail;
34554 swig_obj[0] = args;
34555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34556 if (!SWIG_IsOK(res1)) {
34557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34558 }
34559 arg1 = reinterpret_cast< wxWindow * >(argp1);
34560 {
34561 PyThreadState* __tstate = wxPyBeginAllowThreads();
34562 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34563 wxPyEndAllowThreads(__tstate);
34564 if (PyErr_Occurred()) SWIG_fail;
34565 }
34566 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34567 return resultobj;
34568 fail:
34569 return NULL;
34570 }
34571
34572
34573 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34574 PyObject *resultobj = 0;
34575 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34576 SwigValueWrapper<wxVisualAttributes > result;
34577 int val1 ;
34578 int ecode1 = 0 ;
34579 PyObject * obj0 = 0 ;
34580 char * kwnames[] = {
34581 (char *) "variant", NULL
34582 };
34583
34584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34585 if (obj0) {
34586 ecode1 = SWIG_AsVal_int(obj0, &val1);
34587 if (!SWIG_IsOK(ecode1)) {
34588 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34589 }
34590 arg1 = static_cast< wxWindowVariant >(val1);
34591 }
34592 {
34593 if (!wxPyCheckForApp()) SWIG_fail;
34594 PyThreadState* __tstate = wxPyBeginAllowThreads();
34595 result = wxWindow::GetClassDefaultAttributes(arg1);
34596 wxPyEndAllowThreads(__tstate);
34597 if (PyErr_Occurred()) SWIG_fail;
34598 }
34599 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34600 return resultobj;
34601 fail:
34602 return NULL;
34603 }
34604
34605
34606 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34607 PyObject *resultobj = 0;
34608 wxWindow *arg1 = (wxWindow *) 0 ;
34609 wxColour *arg2 = 0 ;
34610 bool result;
34611 void *argp1 = 0 ;
34612 int res1 = 0 ;
34613 wxColour temp2 ;
34614 PyObject * obj0 = 0 ;
34615 PyObject * obj1 = 0 ;
34616 char * kwnames[] = {
34617 (char *) "self",(char *) "colour", NULL
34618 };
34619
34620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34622 if (!SWIG_IsOK(res1)) {
34623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34624 }
34625 arg1 = reinterpret_cast< wxWindow * >(argp1);
34626 {
34627 arg2 = &temp2;
34628 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34629 }
34630 {
34631 PyThreadState* __tstate = wxPyBeginAllowThreads();
34632 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34633 wxPyEndAllowThreads(__tstate);
34634 if (PyErr_Occurred()) SWIG_fail;
34635 }
34636 {
34637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34638 }
34639 return resultobj;
34640 fail:
34641 return NULL;
34642 }
34643
34644
34645 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34646 PyObject *resultobj = 0;
34647 wxWindow *arg1 = (wxWindow *) 0 ;
34648 wxColour *arg2 = 0 ;
34649 void *argp1 = 0 ;
34650 int res1 = 0 ;
34651 wxColour temp2 ;
34652 PyObject * obj0 = 0 ;
34653 PyObject * obj1 = 0 ;
34654 char * kwnames[] = {
34655 (char *) "self",(char *) "colour", NULL
34656 };
34657
34658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34660 if (!SWIG_IsOK(res1)) {
34661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34662 }
34663 arg1 = reinterpret_cast< wxWindow * >(argp1);
34664 {
34665 arg2 = &temp2;
34666 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34667 }
34668 {
34669 PyThreadState* __tstate = wxPyBeginAllowThreads();
34670 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34671 wxPyEndAllowThreads(__tstate);
34672 if (PyErr_Occurred()) SWIG_fail;
34673 }
34674 resultobj = SWIG_Py_Void();
34675 return resultobj;
34676 fail:
34677 return NULL;
34678 }
34679
34680
34681 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34682 PyObject *resultobj = 0;
34683 wxWindow *arg1 = (wxWindow *) 0 ;
34684 wxColour *arg2 = 0 ;
34685 bool result;
34686 void *argp1 = 0 ;
34687 int res1 = 0 ;
34688 wxColour temp2 ;
34689 PyObject * obj0 = 0 ;
34690 PyObject * obj1 = 0 ;
34691 char * kwnames[] = {
34692 (char *) "self",(char *) "colour", NULL
34693 };
34694
34695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34697 if (!SWIG_IsOK(res1)) {
34698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34699 }
34700 arg1 = reinterpret_cast< wxWindow * >(argp1);
34701 {
34702 arg2 = &temp2;
34703 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34704 }
34705 {
34706 PyThreadState* __tstate = wxPyBeginAllowThreads();
34707 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34708 wxPyEndAllowThreads(__tstate);
34709 if (PyErr_Occurred()) SWIG_fail;
34710 }
34711 {
34712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34713 }
34714 return resultobj;
34715 fail:
34716 return NULL;
34717 }
34718
34719
34720 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34721 PyObject *resultobj = 0;
34722 wxWindow *arg1 = (wxWindow *) 0 ;
34723 wxColour *arg2 = 0 ;
34724 void *argp1 = 0 ;
34725 int res1 = 0 ;
34726 wxColour temp2 ;
34727 PyObject * obj0 = 0 ;
34728 PyObject * obj1 = 0 ;
34729 char * kwnames[] = {
34730 (char *) "self",(char *) "colour", NULL
34731 };
34732
34733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34735 if (!SWIG_IsOK(res1)) {
34736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34737 }
34738 arg1 = reinterpret_cast< wxWindow * >(argp1);
34739 {
34740 arg2 = &temp2;
34741 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34742 }
34743 {
34744 PyThreadState* __tstate = wxPyBeginAllowThreads();
34745 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 resultobj = SWIG_Py_Void();
34750 return resultobj;
34751 fail:
34752 return NULL;
34753 }
34754
34755
34756 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34757 PyObject *resultobj = 0;
34758 wxWindow *arg1 = (wxWindow *) 0 ;
34759 wxColour result;
34760 void *argp1 = 0 ;
34761 int res1 = 0 ;
34762 PyObject *swig_obj[1] ;
34763
34764 if (!args) SWIG_fail;
34765 swig_obj[0] = args;
34766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34767 if (!SWIG_IsOK(res1)) {
34768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34769 }
34770 arg1 = reinterpret_cast< wxWindow * >(argp1);
34771 {
34772 PyThreadState* __tstate = wxPyBeginAllowThreads();
34773 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34774 wxPyEndAllowThreads(__tstate);
34775 if (PyErr_Occurred()) SWIG_fail;
34776 }
34777 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34778 return resultobj;
34779 fail:
34780 return NULL;
34781 }
34782
34783
34784 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34785 PyObject *resultobj = 0;
34786 wxWindow *arg1 = (wxWindow *) 0 ;
34787 wxColour result;
34788 void *argp1 = 0 ;
34789 int res1 = 0 ;
34790 PyObject *swig_obj[1] ;
34791
34792 if (!args) SWIG_fail;
34793 swig_obj[0] = args;
34794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34795 if (!SWIG_IsOK(res1)) {
34796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34797 }
34798 arg1 = reinterpret_cast< wxWindow * >(argp1);
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 result = ((wxWindow const *)arg1)->GetForegroundColour();
34802 wxPyEndAllowThreads(__tstate);
34803 if (PyErr_Occurred()) SWIG_fail;
34804 }
34805 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34806 return resultobj;
34807 fail:
34808 return NULL;
34809 }
34810
34811
34812 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34813 PyObject *resultobj = 0;
34814 wxWindow *arg1 = (wxWindow *) 0 ;
34815 bool result;
34816 void *argp1 = 0 ;
34817 int res1 = 0 ;
34818 PyObject *swig_obj[1] ;
34819
34820 if (!args) SWIG_fail;
34821 swig_obj[0] = args;
34822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34823 if (!SWIG_IsOK(res1)) {
34824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34825 }
34826 arg1 = reinterpret_cast< wxWindow * >(argp1);
34827 {
34828 PyThreadState* __tstate = wxPyBeginAllowThreads();
34829 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34830 wxPyEndAllowThreads(__tstate);
34831 if (PyErr_Occurred()) SWIG_fail;
34832 }
34833 {
34834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34835 }
34836 return resultobj;
34837 fail:
34838 return NULL;
34839 }
34840
34841
34842 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34843 PyObject *resultobj = 0;
34844 wxWindow *arg1 = (wxWindow *) 0 ;
34845 bool result;
34846 void *argp1 = 0 ;
34847 int res1 = 0 ;
34848 PyObject *swig_obj[1] ;
34849
34850 if (!args) SWIG_fail;
34851 swig_obj[0] = args;
34852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34853 if (!SWIG_IsOK(res1)) {
34854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34855 }
34856 arg1 = reinterpret_cast< wxWindow * >(argp1);
34857 {
34858 PyThreadState* __tstate = wxPyBeginAllowThreads();
34859 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34860 wxPyEndAllowThreads(__tstate);
34861 if (PyErr_Occurred()) SWIG_fail;
34862 }
34863 {
34864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34865 }
34866 return resultobj;
34867 fail:
34868 return NULL;
34869 }
34870
34871
34872 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34873 PyObject *resultobj = 0;
34874 wxWindow *arg1 = (wxWindow *) 0 ;
34875 wxBackgroundStyle arg2 ;
34876 bool result;
34877 void *argp1 = 0 ;
34878 int res1 = 0 ;
34879 int val2 ;
34880 int ecode2 = 0 ;
34881 PyObject * obj0 = 0 ;
34882 PyObject * obj1 = 0 ;
34883 char * kwnames[] = {
34884 (char *) "self",(char *) "style", NULL
34885 };
34886
34887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34889 if (!SWIG_IsOK(res1)) {
34890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34891 }
34892 arg1 = reinterpret_cast< wxWindow * >(argp1);
34893 ecode2 = SWIG_AsVal_int(obj1, &val2);
34894 if (!SWIG_IsOK(ecode2)) {
34895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34896 }
34897 arg2 = static_cast< wxBackgroundStyle >(val2);
34898 {
34899 PyThreadState* __tstate = wxPyBeginAllowThreads();
34900 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34901 wxPyEndAllowThreads(__tstate);
34902 if (PyErr_Occurred()) SWIG_fail;
34903 }
34904 {
34905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34906 }
34907 return resultobj;
34908 fail:
34909 return NULL;
34910 }
34911
34912
34913 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34914 PyObject *resultobj = 0;
34915 wxWindow *arg1 = (wxWindow *) 0 ;
34916 wxBackgroundStyle result;
34917 void *argp1 = 0 ;
34918 int res1 = 0 ;
34919 PyObject *swig_obj[1] ;
34920
34921 if (!args) SWIG_fail;
34922 swig_obj[0] = args;
34923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34924 if (!SWIG_IsOK(res1)) {
34925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34926 }
34927 arg1 = reinterpret_cast< wxWindow * >(argp1);
34928 {
34929 PyThreadState* __tstate = wxPyBeginAllowThreads();
34930 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34931 wxPyEndAllowThreads(__tstate);
34932 if (PyErr_Occurred()) SWIG_fail;
34933 }
34934 resultobj = SWIG_From_int(static_cast< int >(result));
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34942 PyObject *resultobj = 0;
34943 wxWindow *arg1 = (wxWindow *) 0 ;
34944 bool result;
34945 void *argp1 = 0 ;
34946 int res1 = 0 ;
34947 PyObject *swig_obj[1] ;
34948
34949 if (!args) SWIG_fail;
34950 swig_obj[0] = args;
34951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34952 if (!SWIG_IsOK(res1)) {
34953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34954 }
34955 arg1 = reinterpret_cast< wxWindow * >(argp1);
34956 {
34957 PyThreadState* __tstate = wxPyBeginAllowThreads();
34958 result = (bool)(arg1)->HasTransparentBackground();
34959 wxPyEndAllowThreads(__tstate);
34960 if (PyErr_Occurred()) SWIG_fail;
34961 }
34962 {
34963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34964 }
34965 return resultobj;
34966 fail:
34967 return NULL;
34968 }
34969
34970
34971 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34972 PyObject *resultobj = 0;
34973 wxWindow *arg1 = (wxWindow *) 0 ;
34974 wxCursor *arg2 = 0 ;
34975 bool result;
34976 void *argp1 = 0 ;
34977 int res1 = 0 ;
34978 void *argp2 = 0 ;
34979 int res2 = 0 ;
34980 PyObject * obj0 = 0 ;
34981 PyObject * obj1 = 0 ;
34982 char * kwnames[] = {
34983 (char *) "self",(char *) "cursor", NULL
34984 };
34985
34986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
34987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34988 if (!SWIG_IsOK(res1)) {
34989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34990 }
34991 arg1 = reinterpret_cast< wxWindow * >(argp1);
34992 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
34993 if (!SWIG_IsOK(res2)) {
34994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34995 }
34996 if (!argp2) {
34997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34998 }
34999 arg2 = reinterpret_cast< wxCursor * >(argp2);
35000 {
35001 PyThreadState* __tstate = wxPyBeginAllowThreads();
35002 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35003 wxPyEndAllowThreads(__tstate);
35004 if (PyErr_Occurred()) SWIG_fail;
35005 }
35006 {
35007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35008 }
35009 return resultobj;
35010 fail:
35011 return NULL;
35012 }
35013
35014
35015 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35016 PyObject *resultobj = 0;
35017 wxWindow *arg1 = (wxWindow *) 0 ;
35018 wxCursor result;
35019 void *argp1 = 0 ;
35020 int res1 = 0 ;
35021 PyObject *swig_obj[1] ;
35022
35023 if (!args) SWIG_fail;
35024 swig_obj[0] = args;
35025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35026 if (!SWIG_IsOK(res1)) {
35027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35028 }
35029 arg1 = reinterpret_cast< wxWindow * >(argp1);
35030 {
35031 PyThreadState* __tstate = wxPyBeginAllowThreads();
35032 result = (arg1)->GetCursor();
35033 wxPyEndAllowThreads(__tstate);
35034 if (PyErr_Occurred()) SWIG_fail;
35035 }
35036 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35037 return resultobj;
35038 fail:
35039 return NULL;
35040 }
35041
35042
35043 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35044 PyObject *resultobj = 0;
35045 wxWindow *arg1 = (wxWindow *) 0 ;
35046 wxFont *arg2 = 0 ;
35047 bool result;
35048 void *argp1 = 0 ;
35049 int res1 = 0 ;
35050 void *argp2 = 0 ;
35051 int res2 = 0 ;
35052 PyObject * obj0 = 0 ;
35053 PyObject * obj1 = 0 ;
35054 char * kwnames[] = {
35055 (char *) "self",(char *) "font", NULL
35056 };
35057
35058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35060 if (!SWIG_IsOK(res1)) {
35061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35062 }
35063 arg1 = reinterpret_cast< wxWindow * >(argp1);
35064 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35065 if (!SWIG_IsOK(res2)) {
35066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35067 }
35068 if (!argp2) {
35069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35070 }
35071 arg2 = reinterpret_cast< wxFont * >(argp2);
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35075 wxPyEndAllowThreads(__tstate);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 }
35078 {
35079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35080 }
35081 return resultobj;
35082 fail:
35083 return NULL;
35084 }
35085
35086
35087 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35088 PyObject *resultobj = 0;
35089 wxWindow *arg1 = (wxWindow *) 0 ;
35090 wxFont *arg2 = 0 ;
35091 void *argp1 = 0 ;
35092 int res1 = 0 ;
35093 void *argp2 = 0 ;
35094 int res2 = 0 ;
35095 PyObject * obj0 = 0 ;
35096 PyObject * obj1 = 0 ;
35097 char * kwnames[] = {
35098 (char *) "self",(char *) "font", NULL
35099 };
35100
35101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35103 if (!SWIG_IsOK(res1)) {
35104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35105 }
35106 arg1 = reinterpret_cast< wxWindow * >(argp1);
35107 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35108 if (!SWIG_IsOK(res2)) {
35109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35110 }
35111 if (!argp2) {
35112 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35113 }
35114 arg2 = reinterpret_cast< wxFont * >(argp2);
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 (arg1)->SetOwnFont((wxFont const &)*arg2);
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 resultobj = SWIG_Py_Void();
35122 return resultobj;
35123 fail:
35124 return NULL;
35125 }
35126
35127
35128 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35129 PyObject *resultobj = 0;
35130 wxWindow *arg1 = (wxWindow *) 0 ;
35131 wxFont result;
35132 void *argp1 = 0 ;
35133 int res1 = 0 ;
35134 PyObject *swig_obj[1] ;
35135
35136 if (!args) SWIG_fail;
35137 swig_obj[0] = args;
35138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35139 if (!SWIG_IsOK(res1)) {
35140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35141 }
35142 arg1 = reinterpret_cast< wxWindow * >(argp1);
35143 {
35144 PyThreadState* __tstate = wxPyBeginAllowThreads();
35145 result = (arg1)->GetFont();
35146 wxPyEndAllowThreads(__tstate);
35147 if (PyErr_Occurred()) SWIG_fail;
35148 }
35149 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35150 return resultobj;
35151 fail:
35152 return NULL;
35153 }
35154
35155
35156 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35157 PyObject *resultobj = 0;
35158 wxWindow *arg1 = (wxWindow *) 0 ;
35159 wxCaret *arg2 = (wxCaret *) 0 ;
35160 void *argp1 = 0 ;
35161 int res1 = 0 ;
35162 int res2 = 0 ;
35163 PyObject * obj0 = 0 ;
35164 PyObject * obj1 = 0 ;
35165 char * kwnames[] = {
35166 (char *) "self",(char *) "caret", NULL
35167 };
35168
35169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35171 if (!SWIG_IsOK(res1)) {
35172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35173 }
35174 arg1 = reinterpret_cast< wxWindow * >(argp1);
35175 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35176 if (!SWIG_IsOK(res2)) {
35177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35178 }
35179 {
35180 PyThreadState* __tstate = wxPyBeginAllowThreads();
35181 (arg1)->SetCaret(arg2);
35182 wxPyEndAllowThreads(__tstate);
35183 if (PyErr_Occurred()) SWIG_fail;
35184 }
35185 resultobj = SWIG_Py_Void();
35186 return resultobj;
35187 fail:
35188 return NULL;
35189 }
35190
35191
35192 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35193 PyObject *resultobj = 0;
35194 wxWindow *arg1 = (wxWindow *) 0 ;
35195 wxCaret *result = 0 ;
35196 void *argp1 = 0 ;
35197 int res1 = 0 ;
35198 PyObject *swig_obj[1] ;
35199
35200 if (!args) SWIG_fail;
35201 swig_obj[0] = args;
35202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35203 if (!SWIG_IsOK(res1)) {
35204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35205 }
35206 arg1 = reinterpret_cast< wxWindow * >(argp1);
35207 {
35208 PyThreadState* __tstate = wxPyBeginAllowThreads();
35209 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35210 wxPyEndAllowThreads(__tstate);
35211 if (PyErr_Occurred()) SWIG_fail;
35212 }
35213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35221 PyObject *resultobj = 0;
35222 wxWindow *arg1 = (wxWindow *) 0 ;
35223 int result;
35224 void *argp1 = 0 ;
35225 int res1 = 0 ;
35226 PyObject *swig_obj[1] ;
35227
35228 if (!args) SWIG_fail;
35229 swig_obj[0] = args;
35230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35231 if (!SWIG_IsOK(res1)) {
35232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35233 }
35234 arg1 = reinterpret_cast< wxWindow * >(argp1);
35235 {
35236 PyThreadState* __tstate = wxPyBeginAllowThreads();
35237 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35238 wxPyEndAllowThreads(__tstate);
35239 if (PyErr_Occurred()) SWIG_fail;
35240 }
35241 resultobj = SWIG_From_int(static_cast< int >(result));
35242 return resultobj;
35243 fail:
35244 return NULL;
35245 }
35246
35247
35248 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35249 PyObject *resultobj = 0;
35250 wxWindow *arg1 = (wxWindow *) 0 ;
35251 int result;
35252 void *argp1 = 0 ;
35253 int res1 = 0 ;
35254 PyObject *swig_obj[1] ;
35255
35256 if (!args) SWIG_fail;
35257 swig_obj[0] = args;
35258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35259 if (!SWIG_IsOK(res1)) {
35260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35261 }
35262 arg1 = reinterpret_cast< wxWindow * >(argp1);
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 resultobj = SWIG_From_int(static_cast< int >(result));
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35277 PyObject *resultobj = 0;
35278 wxWindow *arg1 = (wxWindow *) 0 ;
35279 wxString *arg2 = 0 ;
35280 int *arg3 = (int *) 0 ;
35281 int *arg4 = (int *) 0 ;
35282 void *argp1 = 0 ;
35283 int res1 = 0 ;
35284 bool temp2 = false ;
35285 int temp3 ;
35286 int res3 = SWIG_TMPOBJ ;
35287 int temp4 ;
35288 int res4 = SWIG_TMPOBJ ;
35289 PyObject * obj0 = 0 ;
35290 PyObject * obj1 = 0 ;
35291 char * kwnames[] = {
35292 (char *) "self",(char *) "string", NULL
35293 };
35294
35295 arg3 = &temp3;
35296 arg4 = &temp4;
35297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35299 if (!SWIG_IsOK(res1)) {
35300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35301 }
35302 arg1 = reinterpret_cast< wxWindow * >(argp1);
35303 {
35304 arg2 = wxString_in_helper(obj1);
35305 if (arg2 == NULL) SWIG_fail;
35306 temp2 = true;
35307 }
35308 {
35309 PyThreadState* __tstate = wxPyBeginAllowThreads();
35310 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35311 wxPyEndAllowThreads(__tstate);
35312 if (PyErr_Occurred()) SWIG_fail;
35313 }
35314 resultobj = SWIG_Py_Void();
35315 if (SWIG_IsTmpObj(res3)) {
35316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35317 } else {
35318 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35319 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35320 }
35321 if (SWIG_IsTmpObj(res4)) {
35322 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35323 } else {
35324 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35326 }
35327 {
35328 if (temp2)
35329 delete arg2;
35330 }
35331 return resultobj;
35332 fail:
35333 {
35334 if (temp2)
35335 delete arg2;
35336 }
35337 return NULL;
35338 }
35339
35340
35341 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35342 PyObject *resultobj = 0;
35343 wxWindow *arg1 = (wxWindow *) 0 ;
35344 wxString *arg2 = 0 ;
35345 int *arg3 = (int *) 0 ;
35346 int *arg4 = (int *) 0 ;
35347 int *arg5 = (int *) 0 ;
35348 int *arg6 = (int *) 0 ;
35349 wxFont *arg7 = (wxFont *) NULL ;
35350 void *argp1 = 0 ;
35351 int res1 = 0 ;
35352 bool temp2 = false ;
35353 int temp3 ;
35354 int res3 = SWIG_TMPOBJ ;
35355 int temp4 ;
35356 int res4 = SWIG_TMPOBJ ;
35357 int temp5 ;
35358 int res5 = SWIG_TMPOBJ ;
35359 int temp6 ;
35360 int res6 = SWIG_TMPOBJ ;
35361 void *argp7 = 0 ;
35362 int res7 = 0 ;
35363 PyObject * obj0 = 0 ;
35364 PyObject * obj1 = 0 ;
35365 PyObject * obj2 = 0 ;
35366 char * kwnames[] = {
35367 (char *) "self",(char *) "string",(char *) "font", NULL
35368 };
35369
35370 arg3 = &temp3;
35371 arg4 = &temp4;
35372 arg5 = &temp5;
35373 arg6 = &temp6;
35374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35376 if (!SWIG_IsOK(res1)) {
35377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35378 }
35379 arg1 = reinterpret_cast< wxWindow * >(argp1);
35380 {
35381 arg2 = wxString_in_helper(obj1);
35382 if (arg2 == NULL) SWIG_fail;
35383 temp2 = true;
35384 }
35385 if (obj2) {
35386 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35387 if (!SWIG_IsOK(res7)) {
35388 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35389 }
35390 arg7 = reinterpret_cast< wxFont * >(argp7);
35391 }
35392 {
35393 PyThreadState* __tstate = wxPyBeginAllowThreads();
35394 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35395 wxPyEndAllowThreads(__tstate);
35396 if (PyErr_Occurred()) SWIG_fail;
35397 }
35398 resultobj = SWIG_Py_Void();
35399 if (SWIG_IsTmpObj(res3)) {
35400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35401 } else {
35402 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35404 }
35405 if (SWIG_IsTmpObj(res4)) {
35406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35407 } else {
35408 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35410 }
35411 if (SWIG_IsTmpObj(res5)) {
35412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35413 } else {
35414 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35416 }
35417 if (SWIG_IsTmpObj(res6)) {
35418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35419 } else {
35420 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35422 }
35423 {
35424 if (temp2)
35425 delete arg2;
35426 }
35427 return resultobj;
35428 fail:
35429 {
35430 if (temp2)
35431 delete arg2;
35432 }
35433 return NULL;
35434 }
35435
35436
35437 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35438 PyObject *resultobj = 0;
35439 wxWindow *arg1 = (wxWindow *) 0 ;
35440 int *arg2 = (int *) 0 ;
35441 int *arg3 = (int *) 0 ;
35442 void *argp1 = 0 ;
35443 int res1 = 0 ;
35444 int temp2 ;
35445 int res2 = 0 ;
35446 int temp3 ;
35447 int res3 = 0 ;
35448 PyObject * obj0 = 0 ;
35449 PyObject * obj1 = 0 ;
35450 PyObject * obj2 = 0 ;
35451 char * kwnames[] = {
35452 (char *) "self",(char *) "x",(char *) "y", NULL
35453 };
35454
35455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35457 if (!SWIG_IsOK(res1)) {
35458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35459 }
35460 arg1 = reinterpret_cast< wxWindow * >(argp1);
35461 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35462 int val;
35463 int ecode = SWIG_AsVal_int(obj1, &val);
35464 if (!SWIG_IsOK(ecode)) {
35465 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35466 }
35467 temp2 = static_cast< int >(val);
35468 arg2 = &temp2;
35469 res2 = SWIG_AddTmpMask(ecode);
35470 }
35471 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35472 int val;
35473 int ecode = SWIG_AsVal_int(obj2, &val);
35474 if (!SWIG_IsOK(ecode)) {
35475 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35476 }
35477 temp3 = static_cast< int >(val);
35478 arg3 = &temp3;
35479 res3 = SWIG_AddTmpMask(ecode);
35480 }
35481 {
35482 PyThreadState* __tstate = wxPyBeginAllowThreads();
35483 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35484 wxPyEndAllowThreads(__tstate);
35485 if (PyErr_Occurred()) SWIG_fail;
35486 }
35487 resultobj = SWIG_Py_Void();
35488 if (SWIG_IsTmpObj(res2)) {
35489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35490 } else {
35491 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35492 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35493 }
35494 if (SWIG_IsTmpObj(res3)) {
35495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35496 } else {
35497 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35499 }
35500 return resultobj;
35501 fail:
35502 return NULL;
35503 }
35504
35505
35506 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35507 PyObject *resultobj = 0;
35508 wxWindow *arg1 = (wxWindow *) 0 ;
35509 int *arg2 = (int *) 0 ;
35510 int *arg3 = (int *) 0 ;
35511 void *argp1 = 0 ;
35512 int res1 = 0 ;
35513 int temp2 ;
35514 int res2 = 0 ;
35515 int temp3 ;
35516 int res3 = 0 ;
35517 PyObject * obj0 = 0 ;
35518 PyObject * obj1 = 0 ;
35519 PyObject * obj2 = 0 ;
35520 char * kwnames[] = {
35521 (char *) "self",(char *) "x",(char *) "y", NULL
35522 };
35523
35524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35526 if (!SWIG_IsOK(res1)) {
35527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35528 }
35529 arg1 = reinterpret_cast< wxWindow * >(argp1);
35530 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35531 int val;
35532 int ecode = SWIG_AsVal_int(obj1, &val);
35533 if (!SWIG_IsOK(ecode)) {
35534 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35535 }
35536 temp2 = static_cast< int >(val);
35537 arg2 = &temp2;
35538 res2 = SWIG_AddTmpMask(ecode);
35539 }
35540 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35541 int val;
35542 int ecode = SWIG_AsVal_int(obj2, &val);
35543 if (!SWIG_IsOK(ecode)) {
35544 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35545 }
35546 temp3 = static_cast< int >(val);
35547 arg3 = &temp3;
35548 res3 = SWIG_AddTmpMask(ecode);
35549 }
35550 {
35551 PyThreadState* __tstate = wxPyBeginAllowThreads();
35552 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35553 wxPyEndAllowThreads(__tstate);
35554 if (PyErr_Occurred()) SWIG_fail;
35555 }
35556 resultobj = SWIG_Py_Void();
35557 if (SWIG_IsTmpObj(res2)) {
35558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35559 } else {
35560 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35562 }
35563 if (SWIG_IsTmpObj(res3)) {
35564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35565 } else {
35566 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35567 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35568 }
35569 return resultobj;
35570 fail:
35571 return NULL;
35572 }
35573
35574
35575 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35576 PyObject *resultobj = 0;
35577 wxWindow *arg1 = (wxWindow *) 0 ;
35578 wxPoint *arg2 = 0 ;
35579 wxPoint result;
35580 void *argp1 = 0 ;
35581 int res1 = 0 ;
35582 wxPoint temp2 ;
35583 PyObject * obj0 = 0 ;
35584 PyObject * obj1 = 0 ;
35585 char * kwnames[] = {
35586 (char *) "self",(char *) "pt", NULL
35587 };
35588
35589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35591 if (!SWIG_IsOK(res1)) {
35592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35593 }
35594 arg1 = reinterpret_cast< wxWindow * >(argp1);
35595 {
35596 arg2 = &temp2;
35597 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35598 }
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35602 wxPyEndAllowThreads(__tstate);
35603 if (PyErr_Occurred()) SWIG_fail;
35604 }
35605 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35606 return resultobj;
35607 fail:
35608 return NULL;
35609 }
35610
35611
35612 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35613 PyObject *resultobj = 0;
35614 wxWindow *arg1 = (wxWindow *) 0 ;
35615 wxPoint *arg2 = 0 ;
35616 wxPoint result;
35617 void *argp1 = 0 ;
35618 int res1 = 0 ;
35619 wxPoint temp2 ;
35620 PyObject * obj0 = 0 ;
35621 PyObject * obj1 = 0 ;
35622 char * kwnames[] = {
35623 (char *) "self",(char *) "pt", NULL
35624 };
35625
35626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35628 if (!SWIG_IsOK(res1)) {
35629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35630 }
35631 arg1 = reinterpret_cast< wxWindow * >(argp1);
35632 {
35633 arg2 = &temp2;
35634 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35635 }
35636 {
35637 PyThreadState* __tstate = wxPyBeginAllowThreads();
35638 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35639 wxPyEndAllowThreads(__tstate);
35640 if (PyErr_Occurred()) SWIG_fail;
35641 }
35642 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35643 return resultobj;
35644 fail:
35645 return NULL;
35646 }
35647
35648
35649 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35650 PyObject *resultobj = 0;
35651 wxWindow *arg1 = (wxWindow *) 0 ;
35652 int arg2 ;
35653 int arg3 ;
35654 wxHitTest result;
35655 void *argp1 = 0 ;
35656 int res1 = 0 ;
35657 int val2 ;
35658 int ecode2 = 0 ;
35659 int val3 ;
35660 int ecode3 = 0 ;
35661 PyObject * obj0 = 0 ;
35662 PyObject * obj1 = 0 ;
35663 PyObject * obj2 = 0 ;
35664 char * kwnames[] = {
35665 (char *) "self",(char *) "x",(char *) "y", NULL
35666 };
35667
35668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35670 if (!SWIG_IsOK(res1)) {
35671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35672 }
35673 arg1 = reinterpret_cast< wxWindow * >(argp1);
35674 ecode2 = SWIG_AsVal_int(obj1, &val2);
35675 if (!SWIG_IsOK(ecode2)) {
35676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35677 }
35678 arg2 = static_cast< int >(val2);
35679 ecode3 = SWIG_AsVal_int(obj2, &val3);
35680 if (!SWIG_IsOK(ecode3)) {
35681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35682 }
35683 arg3 = static_cast< int >(val3);
35684 {
35685 PyThreadState* __tstate = wxPyBeginAllowThreads();
35686 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35687 wxPyEndAllowThreads(__tstate);
35688 if (PyErr_Occurred()) SWIG_fail;
35689 }
35690 resultobj = SWIG_From_int(static_cast< int >(result));
35691 return resultobj;
35692 fail:
35693 return NULL;
35694 }
35695
35696
35697 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35698 PyObject *resultobj = 0;
35699 wxWindow *arg1 = (wxWindow *) 0 ;
35700 wxPoint *arg2 = 0 ;
35701 wxHitTest result;
35702 void *argp1 = 0 ;
35703 int res1 = 0 ;
35704 wxPoint temp2 ;
35705 PyObject * obj0 = 0 ;
35706 PyObject * obj1 = 0 ;
35707 char * kwnames[] = {
35708 (char *) "self",(char *) "pt", NULL
35709 };
35710
35711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35713 if (!SWIG_IsOK(res1)) {
35714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35715 }
35716 arg1 = reinterpret_cast< wxWindow * >(argp1);
35717 {
35718 arg2 = &temp2;
35719 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35720 }
35721 {
35722 PyThreadState* __tstate = wxPyBeginAllowThreads();
35723 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35724 wxPyEndAllowThreads(__tstate);
35725 if (PyErr_Occurred()) SWIG_fail;
35726 }
35727 resultobj = SWIG_From_int(static_cast< int >(result));
35728 return resultobj;
35729 fail:
35730 return NULL;
35731 }
35732
35733
35734 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35735 PyObject *resultobj = 0;
35736 wxWindow *arg1 = (wxWindow *) 0 ;
35737 long arg2 ;
35738 wxBorder result;
35739 void *argp1 = 0 ;
35740 int res1 = 0 ;
35741 long val2 ;
35742 int ecode2 = 0 ;
35743
35744 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35746 if (!SWIG_IsOK(res1)) {
35747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35748 }
35749 arg1 = reinterpret_cast< wxWindow * >(argp1);
35750 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35751 if (!SWIG_IsOK(ecode2)) {
35752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35753 }
35754 arg2 = static_cast< long >(val2);
35755 {
35756 PyThreadState* __tstate = wxPyBeginAllowThreads();
35757 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35758 wxPyEndAllowThreads(__tstate);
35759 if (PyErr_Occurred()) SWIG_fail;
35760 }
35761 resultobj = SWIG_From_int(static_cast< int >(result));
35762 return resultobj;
35763 fail:
35764 return NULL;
35765 }
35766
35767
35768 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35769 PyObject *resultobj = 0;
35770 wxWindow *arg1 = (wxWindow *) 0 ;
35771 wxBorder result;
35772 void *argp1 = 0 ;
35773 int res1 = 0 ;
35774
35775 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35777 if (!SWIG_IsOK(res1)) {
35778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35779 }
35780 arg1 = reinterpret_cast< wxWindow * >(argp1);
35781 {
35782 PyThreadState* __tstate = wxPyBeginAllowThreads();
35783 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35784 wxPyEndAllowThreads(__tstate);
35785 if (PyErr_Occurred()) SWIG_fail;
35786 }
35787 resultobj = SWIG_From_int(static_cast< int >(result));
35788 return resultobj;
35789 fail:
35790 return NULL;
35791 }
35792
35793
35794 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35795 int argc;
35796 PyObject *argv[3];
35797
35798 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35799 --argc;
35800 if (argc == 1) {
35801 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35802 }
35803 if (argc == 2) {
35804 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35805 }
35806
35807 fail:
35808 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35809 return NULL;
35810 }
35811
35812
35813 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35814 PyObject *resultobj = 0;
35815 wxWindow *arg1 = (wxWindow *) 0 ;
35816 long arg2 = (long) wxUPDATE_UI_NONE ;
35817 void *argp1 = 0 ;
35818 int res1 = 0 ;
35819 long val2 ;
35820 int ecode2 = 0 ;
35821 PyObject * obj0 = 0 ;
35822 PyObject * obj1 = 0 ;
35823 char * kwnames[] = {
35824 (char *) "self",(char *) "flags", NULL
35825 };
35826
35827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35829 if (!SWIG_IsOK(res1)) {
35830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35831 }
35832 arg1 = reinterpret_cast< wxWindow * >(argp1);
35833 if (obj1) {
35834 ecode2 = SWIG_AsVal_long(obj1, &val2);
35835 if (!SWIG_IsOK(ecode2)) {
35836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35837 }
35838 arg2 = static_cast< long >(val2);
35839 }
35840 {
35841 PyThreadState* __tstate = wxPyBeginAllowThreads();
35842 (arg1)->UpdateWindowUI(arg2);
35843 wxPyEndAllowThreads(__tstate);
35844 if (PyErr_Occurred()) SWIG_fail;
35845 }
35846 resultobj = SWIG_Py_Void();
35847 return resultobj;
35848 fail:
35849 return NULL;
35850 }
35851
35852
35853 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35854 PyObject *resultobj = 0;
35855 wxWindow *arg1 = (wxWindow *) 0 ;
35856 wxMenu *arg2 = (wxMenu *) 0 ;
35857 int arg3 = (int) -1 ;
35858 int arg4 = (int) -1 ;
35859 bool result;
35860 void *argp1 = 0 ;
35861 int res1 = 0 ;
35862 void *argp2 = 0 ;
35863 int res2 = 0 ;
35864 int val3 ;
35865 int ecode3 = 0 ;
35866 int val4 ;
35867 int ecode4 = 0 ;
35868 PyObject * obj0 = 0 ;
35869 PyObject * obj1 = 0 ;
35870 PyObject * obj2 = 0 ;
35871 PyObject * obj3 = 0 ;
35872 char * kwnames[] = {
35873 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35874 };
35875
35876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35878 if (!SWIG_IsOK(res1)) {
35879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35880 }
35881 arg1 = reinterpret_cast< wxWindow * >(argp1);
35882 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35883 if (!SWIG_IsOK(res2)) {
35884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35885 }
35886 arg2 = reinterpret_cast< wxMenu * >(argp2);
35887 if (obj2) {
35888 ecode3 = SWIG_AsVal_int(obj2, &val3);
35889 if (!SWIG_IsOK(ecode3)) {
35890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35891 }
35892 arg3 = static_cast< int >(val3);
35893 }
35894 if (obj3) {
35895 ecode4 = SWIG_AsVal_int(obj3, &val4);
35896 if (!SWIG_IsOK(ecode4)) {
35897 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35898 }
35899 arg4 = static_cast< int >(val4);
35900 }
35901 {
35902 PyThreadState* __tstate = wxPyBeginAllowThreads();
35903 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35904 wxPyEndAllowThreads(__tstate);
35905 if (PyErr_Occurred()) SWIG_fail;
35906 }
35907 {
35908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35909 }
35910 return resultobj;
35911 fail:
35912 return NULL;
35913 }
35914
35915
35916 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35917 PyObject *resultobj = 0;
35918 wxWindow *arg1 = (wxWindow *) 0 ;
35919 wxMenu *arg2 = (wxMenu *) 0 ;
35920 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35921 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35922 bool result;
35923 void *argp1 = 0 ;
35924 int res1 = 0 ;
35925 void *argp2 = 0 ;
35926 int res2 = 0 ;
35927 wxPoint temp3 ;
35928 PyObject * obj0 = 0 ;
35929 PyObject * obj1 = 0 ;
35930 PyObject * obj2 = 0 ;
35931 char * kwnames[] = {
35932 (char *) "self",(char *) "menu",(char *) "pos", NULL
35933 };
35934
35935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35937 if (!SWIG_IsOK(res1)) {
35938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35939 }
35940 arg1 = reinterpret_cast< wxWindow * >(argp1);
35941 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35942 if (!SWIG_IsOK(res2)) {
35943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35944 }
35945 arg2 = reinterpret_cast< wxMenu * >(argp2);
35946 if (obj2) {
35947 {
35948 arg3 = &temp3;
35949 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35950 }
35951 }
35952 {
35953 PyThreadState* __tstate = wxPyBeginAllowThreads();
35954 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
35955 wxPyEndAllowThreads(__tstate);
35956 if (PyErr_Occurred()) SWIG_fail;
35957 }
35958 {
35959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35960 }
35961 return resultobj;
35962 fail:
35963 return NULL;
35964 }
35965
35966
35967 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35968 PyObject *resultobj = 0;
35969 wxWindow *arg1 = (wxWindow *) 0 ;
35970 long result;
35971 void *argp1 = 0 ;
35972 int res1 = 0 ;
35973 PyObject *swig_obj[1] ;
35974
35975 if (!args) SWIG_fail;
35976 swig_obj[0] = args;
35977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35978 if (!SWIG_IsOK(res1)) {
35979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35980 }
35981 arg1 = reinterpret_cast< wxWindow * >(argp1);
35982 {
35983 PyThreadState* __tstate = wxPyBeginAllowThreads();
35984 result = (long)wxWindow_GetHandle(arg1);
35985 wxPyEndAllowThreads(__tstate);
35986 if (PyErr_Occurred()) SWIG_fail;
35987 }
35988 resultobj = SWIG_From_long(static_cast< long >(result));
35989 return resultobj;
35990 fail:
35991 return NULL;
35992 }
35993
35994
35995 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35996 PyObject *resultobj = 0;
35997 wxWindow *arg1 = (wxWindow *) 0 ;
35998 long arg2 ;
35999 void *argp1 = 0 ;
36000 int res1 = 0 ;
36001 long val2 ;
36002 int ecode2 = 0 ;
36003 PyObject * obj0 = 0 ;
36004 PyObject * obj1 = 0 ;
36005 char * kwnames[] = {
36006 (char *) "self",(char *) "handle", NULL
36007 };
36008
36009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36011 if (!SWIG_IsOK(res1)) {
36012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36013 }
36014 arg1 = reinterpret_cast< wxWindow * >(argp1);
36015 ecode2 = SWIG_AsVal_long(obj1, &val2);
36016 if (!SWIG_IsOK(ecode2)) {
36017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36018 }
36019 arg2 = static_cast< long >(val2);
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 wxWindow_AssociateHandle(arg1,arg2);
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 resultobj = SWIG_Py_Void();
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36034 PyObject *resultobj = 0;
36035 wxWindow *arg1 = (wxWindow *) 0 ;
36036 void *argp1 = 0 ;
36037 int res1 = 0 ;
36038 PyObject *swig_obj[1] ;
36039
36040 if (!args) SWIG_fail;
36041 swig_obj[0] = args;
36042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36043 if (!SWIG_IsOK(res1)) {
36044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36045 }
36046 arg1 = reinterpret_cast< wxWindow * >(argp1);
36047 {
36048 PyThreadState* __tstate = wxPyBeginAllowThreads();
36049 (arg1)->DissociateHandle();
36050 wxPyEndAllowThreads(__tstate);
36051 if (PyErr_Occurred()) SWIG_fail;
36052 }
36053 resultobj = SWIG_Py_Void();
36054 return resultobj;
36055 fail:
36056 return NULL;
36057 }
36058
36059
36060 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36061 PyObject *resultobj = 0;
36062 wxWindow *arg1 = (wxWindow *) 0 ;
36063 int arg2 ;
36064 bool result;
36065 void *argp1 = 0 ;
36066 int res1 = 0 ;
36067 int val2 ;
36068 int ecode2 = 0 ;
36069 PyObject * obj0 = 0 ;
36070 PyObject * obj1 = 0 ;
36071 char * kwnames[] = {
36072 (char *) "self",(char *) "orient", NULL
36073 };
36074
36075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36077 if (!SWIG_IsOK(res1)) {
36078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36079 }
36080 arg1 = reinterpret_cast< wxWindow * >(argp1);
36081 ecode2 = SWIG_AsVal_int(obj1, &val2);
36082 if (!SWIG_IsOK(ecode2)) {
36083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36084 }
36085 arg2 = static_cast< int >(val2);
36086 {
36087 PyThreadState* __tstate = wxPyBeginAllowThreads();
36088 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36089 wxPyEndAllowThreads(__tstate);
36090 if (PyErr_Occurred()) SWIG_fail;
36091 }
36092 {
36093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36094 }
36095 return resultobj;
36096 fail:
36097 return NULL;
36098 }
36099
36100
36101 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36102 PyObject *resultobj = 0;
36103 wxWindow *arg1 = (wxWindow *) 0 ;
36104 int arg2 ;
36105 int arg3 ;
36106 int arg4 ;
36107 int arg5 ;
36108 bool arg6 = (bool) true ;
36109 void *argp1 = 0 ;
36110 int res1 = 0 ;
36111 int val2 ;
36112 int ecode2 = 0 ;
36113 int val3 ;
36114 int ecode3 = 0 ;
36115 int val4 ;
36116 int ecode4 = 0 ;
36117 int val5 ;
36118 int ecode5 = 0 ;
36119 bool val6 ;
36120 int ecode6 = 0 ;
36121 PyObject * obj0 = 0 ;
36122 PyObject * obj1 = 0 ;
36123 PyObject * obj2 = 0 ;
36124 PyObject * obj3 = 0 ;
36125 PyObject * obj4 = 0 ;
36126 PyObject * obj5 = 0 ;
36127 char * kwnames[] = {
36128 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36129 };
36130
36131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36133 if (!SWIG_IsOK(res1)) {
36134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36135 }
36136 arg1 = reinterpret_cast< wxWindow * >(argp1);
36137 ecode2 = SWIG_AsVal_int(obj1, &val2);
36138 if (!SWIG_IsOK(ecode2)) {
36139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36140 }
36141 arg2 = static_cast< int >(val2);
36142 ecode3 = SWIG_AsVal_int(obj2, &val3);
36143 if (!SWIG_IsOK(ecode3)) {
36144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36145 }
36146 arg3 = static_cast< int >(val3);
36147 ecode4 = SWIG_AsVal_int(obj3, &val4);
36148 if (!SWIG_IsOK(ecode4)) {
36149 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36150 }
36151 arg4 = static_cast< int >(val4);
36152 ecode5 = SWIG_AsVal_int(obj4, &val5);
36153 if (!SWIG_IsOK(ecode5)) {
36154 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36155 }
36156 arg5 = static_cast< int >(val5);
36157 if (obj5) {
36158 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36159 if (!SWIG_IsOK(ecode6)) {
36160 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36161 }
36162 arg6 = static_cast< bool >(val6);
36163 }
36164 {
36165 PyThreadState* __tstate = wxPyBeginAllowThreads();
36166 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36167 wxPyEndAllowThreads(__tstate);
36168 if (PyErr_Occurred()) SWIG_fail;
36169 }
36170 resultobj = SWIG_Py_Void();
36171 return resultobj;
36172 fail:
36173 return NULL;
36174 }
36175
36176
36177 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36178 PyObject *resultobj = 0;
36179 wxWindow *arg1 = (wxWindow *) 0 ;
36180 int arg2 ;
36181 int arg3 ;
36182 bool arg4 = (bool) true ;
36183 void *argp1 = 0 ;
36184 int res1 = 0 ;
36185 int val2 ;
36186 int ecode2 = 0 ;
36187 int val3 ;
36188 int ecode3 = 0 ;
36189 bool val4 ;
36190 int ecode4 = 0 ;
36191 PyObject * obj0 = 0 ;
36192 PyObject * obj1 = 0 ;
36193 PyObject * obj2 = 0 ;
36194 PyObject * obj3 = 0 ;
36195 char * kwnames[] = {
36196 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36197 };
36198
36199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36201 if (!SWIG_IsOK(res1)) {
36202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36203 }
36204 arg1 = reinterpret_cast< wxWindow * >(argp1);
36205 ecode2 = SWIG_AsVal_int(obj1, &val2);
36206 if (!SWIG_IsOK(ecode2)) {
36207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36208 }
36209 arg2 = static_cast< int >(val2);
36210 ecode3 = SWIG_AsVal_int(obj2, &val3);
36211 if (!SWIG_IsOK(ecode3)) {
36212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36213 }
36214 arg3 = static_cast< int >(val3);
36215 if (obj3) {
36216 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36217 if (!SWIG_IsOK(ecode4)) {
36218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36219 }
36220 arg4 = static_cast< bool >(val4);
36221 }
36222 {
36223 PyThreadState* __tstate = wxPyBeginAllowThreads();
36224 (arg1)->SetScrollPos(arg2,arg3,arg4);
36225 wxPyEndAllowThreads(__tstate);
36226 if (PyErr_Occurred()) SWIG_fail;
36227 }
36228 resultobj = SWIG_Py_Void();
36229 return resultobj;
36230 fail:
36231 return NULL;
36232 }
36233
36234
36235 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36236 PyObject *resultobj = 0;
36237 wxWindow *arg1 = (wxWindow *) 0 ;
36238 int arg2 ;
36239 int result;
36240 void *argp1 = 0 ;
36241 int res1 = 0 ;
36242 int val2 ;
36243 int ecode2 = 0 ;
36244 PyObject * obj0 = 0 ;
36245 PyObject * obj1 = 0 ;
36246 char * kwnames[] = {
36247 (char *) "self",(char *) "orientation", NULL
36248 };
36249
36250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36252 if (!SWIG_IsOK(res1)) {
36253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36254 }
36255 arg1 = reinterpret_cast< wxWindow * >(argp1);
36256 ecode2 = SWIG_AsVal_int(obj1, &val2);
36257 if (!SWIG_IsOK(ecode2)) {
36258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36259 }
36260 arg2 = static_cast< int >(val2);
36261 {
36262 PyThreadState* __tstate = wxPyBeginAllowThreads();
36263 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 resultobj = SWIG_From_int(static_cast< int >(result));
36268 return resultobj;
36269 fail:
36270 return NULL;
36271 }
36272
36273
36274 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36275 PyObject *resultobj = 0;
36276 wxWindow *arg1 = (wxWindow *) 0 ;
36277 int arg2 ;
36278 int result;
36279 void *argp1 = 0 ;
36280 int res1 = 0 ;
36281 int val2 ;
36282 int ecode2 = 0 ;
36283 PyObject * obj0 = 0 ;
36284 PyObject * obj1 = 0 ;
36285 char * kwnames[] = {
36286 (char *) "self",(char *) "orientation", NULL
36287 };
36288
36289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36291 if (!SWIG_IsOK(res1)) {
36292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36293 }
36294 arg1 = reinterpret_cast< wxWindow * >(argp1);
36295 ecode2 = SWIG_AsVal_int(obj1, &val2);
36296 if (!SWIG_IsOK(ecode2)) {
36297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36298 }
36299 arg2 = static_cast< int >(val2);
36300 {
36301 PyThreadState* __tstate = wxPyBeginAllowThreads();
36302 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36303 wxPyEndAllowThreads(__tstate);
36304 if (PyErr_Occurred()) SWIG_fail;
36305 }
36306 resultobj = SWIG_From_int(static_cast< int >(result));
36307 return resultobj;
36308 fail:
36309 return NULL;
36310 }
36311
36312
36313 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36314 PyObject *resultobj = 0;
36315 wxWindow *arg1 = (wxWindow *) 0 ;
36316 int arg2 ;
36317 int result;
36318 void *argp1 = 0 ;
36319 int res1 = 0 ;
36320 int val2 ;
36321 int ecode2 = 0 ;
36322 PyObject * obj0 = 0 ;
36323 PyObject * obj1 = 0 ;
36324 char * kwnames[] = {
36325 (char *) "self",(char *) "orientation", NULL
36326 };
36327
36328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36330 if (!SWIG_IsOK(res1)) {
36331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36332 }
36333 arg1 = reinterpret_cast< wxWindow * >(argp1);
36334 ecode2 = SWIG_AsVal_int(obj1, &val2);
36335 if (!SWIG_IsOK(ecode2)) {
36336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36337 }
36338 arg2 = static_cast< int >(val2);
36339 {
36340 PyThreadState* __tstate = wxPyBeginAllowThreads();
36341 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36342 wxPyEndAllowThreads(__tstate);
36343 if (PyErr_Occurred()) SWIG_fail;
36344 }
36345 resultobj = SWIG_From_int(static_cast< int >(result));
36346 return resultobj;
36347 fail:
36348 return NULL;
36349 }
36350
36351
36352 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36353 PyObject *resultobj = 0;
36354 wxWindow *arg1 = (wxWindow *) 0 ;
36355 int arg2 ;
36356 int arg3 ;
36357 wxRect *arg4 = (wxRect *) NULL ;
36358 void *argp1 = 0 ;
36359 int res1 = 0 ;
36360 int val2 ;
36361 int ecode2 = 0 ;
36362 int val3 ;
36363 int ecode3 = 0 ;
36364 void *argp4 = 0 ;
36365 int res4 = 0 ;
36366 PyObject * obj0 = 0 ;
36367 PyObject * obj1 = 0 ;
36368 PyObject * obj2 = 0 ;
36369 PyObject * obj3 = 0 ;
36370 char * kwnames[] = {
36371 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36372 };
36373
36374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36376 if (!SWIG_IsOK(res1)) {
36377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36378 }
36379 arg1 = reinterpret_cast< wxWindow * >(argp1);
36380 ecode2 = SWIG_AsVal_int(obj1, &val2);
36381 if (!SWIG_IsOK(ecode2)) {
36382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36383 }
36384 arg2 = static_cast< int >(val2);
36385 ecode3 = SWIG_AsVal_int(obj2, &val3);
36386 if (!SWIG_IsOK(ecode3)) {
36387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36388 }
36389 arg3 = static_cast< int >(val3);
36390 if (obj3) {
36391 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36392 if (!SWIG_IsOK(res4)) {
36393 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36394 }
36395 arg4 = reinterpret_cast< wxRect * >(argp4);
36396 }
36397 {
36398 PyThreadState* __tstate = wxPyBeginAllowThreads();
36399 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36400 wxPyEndAllowThreads(__tstate);
36401 if (PyErr_Occurred()) SWIG_fail;
36402 }
36403 resultobj = SWIG_Py_Void();
36404 return resultobj;
36405 fail:
36406 return NULL;
36407 }
36408
36409
36410 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36411 PyObject *resultobj = 0;
36412 wxWindow *arg1 = (wxWindow *) 0 ;
36413 int arg2 ;
36414 bool result;
36415 void *argp1 = 0 ;
36416 int res1 = 0 ;
36417 int val2 ;
36418 int ecode2 = 0 ;
36419 PyObject * obj0 = 0 ;
36420 PyObject * obj1 = 0 ;
36421 char * kwnames[] = {
36422 (char *) "self",(char *) "lines", NULL
36423 };
36424
36425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36427 if (!SWIG_IsOK(res1)) {
36428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36429 }
36430 arg1 = reinterpret_cast< wxWindow * >(argp1);
36431 ecode2 = SWIG_AsVal_int(obj1, &val2);
36432 if (!SWIG_IsOK(ecode2)) {
36433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36434 }
36435 arg2 = static_cast< int >(val2);
36436 {
36437 PyThreadState* __tstate = wxPyBeginAllowThreads();
36438 result = (bool)(arg1)->ScrollLines(arg2);
36439 wxPyEndAllowThreads(__tstate);
36440 if (PyErr_Occurred()) SWIG_fail;
36441 }
36442 {
36443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36444 }
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj = 0;
36453 wxWindow *arg1 = (wxWindow *) 0 ;
36454 int arg2 ;
36455 bool result;
36456 void *argp1 = 0 ;
36457 int res1 = 0 ;
36458 int val2 ;
36459 int ecode2 = 0 ;
36460 PyObject * obj0 = 0 ;
36461 PyObject * obj1 = 0 ;
36462 char * kwnames[] = {
36463 (char *) "self",(char *) "pages", NULL
36464 };
36465
36466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36468 if (!SWIG_IsOK(res1)) {
36469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36470 }
36471 arg1 = reinterpret_cast< wxWindow * >(argp1);
36472 ecode2 = SWIG_AsVal_int(obj1, &val2);
36473 if (!SWIG_IsOK(ecode2)) {
36474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36475 }
36476 arg2 = static_cast< int >(val2);
36477 {
36478 PyThreadState* __tstate = wxPyBeginAllowThreads();
36479 result = (bool)(arg1)->ScrollPages(arg2);
36480 wxPyEndAllowThreads(__tstate);
36481 if (PyErr_Occurred()) SWIG_fail;
36482 }
36483 {
36484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36485 }
36486 return resultobj;
36487 fail:
36488 return NULL;
36489 }
36490
36491
36492 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36493 PyObject *resultobj = 0;
36494 wxWindow *arg1 = (wxWindow *) 0 ;
36495 bool result;
36496 void *argp1 = 0 ;
36497 int res1 = 0 ;
36498 PyObject *swig_obj[1] ;
36499
36500 if (!args) SWIG_fail;
36501 swig_obj[0] = args;
36502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36503 if (!SWIG_IsOK(res1)) {
36504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36505 }
36506 arg1 = reinterpret_cast< wxWindow * >(argp1);
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 result = (bool)(arg1)->LineUp();
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 {
36514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36515 }
36516 return resultobj;
36517 fail:
36518 return NULL;
36519 }
36520
36521
36522 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36523 PyObject *resultobj = 0;
36524 wxWindow *arg1 = (wxWindow *) 0 ;
36525 bool result;
36526 void *argp1 = 0 ;
36527 int res1 = 0 ;
36528 PyObject *swig_obj[1] ;
36529
36530 if (!args) SWIG_fail;
36531 swig_obj[0] = args;
36532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36533 if (!SWIG_IsOK(res1)) {
36534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36535 }
36536 arg1 = reinterpret_cast< wxWindow * >(argp1);
36537 {
36538 PyThreadState* __tstate = wxPyBeginAllowThreads();
36539 result = (bool)(arg1)->LineDown();
36540 wxPyEndAllowThreads(__tstate);
36541 if (PyErr_Occurred()) SWIG_fail;
36542 }
36543 {
36544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36545 }
36546 return resultobj;
36547 fail:
36548 return NULL;
36549 }
36550
36551
36552 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36553 PyObject *resultobj = 0;
36554 wxWindow *arg1 = (wxWindow *) 0 ;
36555 bool result;
36556 void *argp1 = 0 ;
36557 int res1 = 0 ;
36558 PyObject *swig_obj[1] ;
36559
36560 if (!args) SWIG_fail;
36561 swig_obj[0] = args;
36562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36563 if (!SWIG_IsOK(res1)) {
36564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36565 }
36566 arg1 = reinterpret_cast< wxWindow * >(argp1);
36567 {
36568 PyThreadState* __tstate = wxPyBeginAllowThreads();
36569 result = (bool)(arg1)->PageUp();
36570 wxPyEndAllowThreads(__tstate);
36571 if (PyErr_Occurred()) SWIG_fail;
36572 }
36573 {
36574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36575 }
36576 return resultobj;
36577 fail:
36578 return NULL;
36579 }
36580
36581
36582 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36583 PyObject *resultobj = 0;
36584 wxWindow *arg1 = (wxWindow *) 0 ;
36585 bool result;
36586 void *argp1 = 0 ;
36587 int res1 = 0 ;
36588 PyObject *swig_obj[1] ;
36589
36590 if (!args) SWIG_fail;
36591 swig_obj[0] = args;
36592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36593 if (!SWIG_IsOK(res1)) {
36594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36595 }
36596 arg1 = reinterpret_cast< wxWindow * >(argp1);
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (bool)(arg1)->PageDown();
36600 wxPyEndAllowThreads(__tstate);
36601 if (PyErr_Occurred()) SWIG_fail;
36602 }
36603 {
36604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36605 }
36606 return resultobj;
36607 fail:
36608 return NULL;
36609 }
36610
36611
36612 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36613 PyObject *resultobj = 0;
36614 wxWindow *arg1 = (wxWindow *) 0 ;
36615 wxString *arg2 = 0 ;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 bool temp2 = false ;
36619 PyObject * obj0 = 0 ;
36620 PyObject * obj1 = 0 ;
36621 char * kwnames[] = {
36622 (char *) "self",(char *) "text", NULL
36623 };
36624
36625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36627 if (!SWIG_IsOK(res1)) {
36628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36629 }
36630 arg1 = reinterpret_cast< wxWindow * >(argp1);
36631 {
36632 arg2 = wxString_in_helper(obj1);
36633 if (arg2 == NULL) SWIG_fail;
36634 temp2 = true;
36635 }
36636 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 (arg1)->SetHelpText((wxString const &)*arg2);
36639 wxPyEndAllowThreads(__tstate);
36640 if (PyErr_Occurred()) SWIG_fail;
36641 }
36642 resultobj = SWIG_Py_Void();
36643 {
36644 if (temp2)
36645 delete arg2;
36646 }
36647 return resultobj;
36648 fail:
36649 {
36650 if (temp2)
36651 delete arg2;
36652 }
36653 return NULL;
36654 }
36655
36656
36657 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36658 PyObject *resultobj = 0;
36659 wxWindow *arg1 = (wxWindow *) 0 ;
36660 wxString *arg2 = 0 ;
36661 void *argp1 = 0 ;
36662 int res1 = 0 ;
36663 bool temp2 = false ;
36664 PyObject * obj0 = 0 ;
36665 PyObject * obj1 = 0 ;
36666 char * kwnames[] = {
36667 (char *) "self",(char *) "text", NULL
36668 };
36669
36670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36672 if (!SWIG_IsOK(res1)) {
36673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36674 }
36675 arg1 = reinterpret_cast< wxWindow * >(argp1);
36676 {
36677 arg2 = wxString_in_helper(obj1);
36678 if (arg2 == NULL) SWIG_fail;
36679 temp2 = true;
36680 }
36681 {
36682 PyThreadState* __tstate = wxPyBeginAllowThreads();
36683 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36684 wxPyEndAllowThreads(__tstate);
36685 if (PyErr_Occurred()) SWIG_fail;
36686 }
36687 resultobj = SWIG_Py_Void();
36688 {
36689 if (temp2)
36690 delete arg2;
36691 }
36692 return resultobj;
36693 fail:
36694 {
36695 if (temp2)
36696 delete arg2;
36697 }
36698 return NULL;
36699 }
36700
36701
36702 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36703 PyObject *resultobj = 0;
36704 wxWindow *arg1 = (wxWindow *) 0 ;
36705 wxString result;
36706 void *argp1 = 0 ;
36707 int res1 = 0 ;
36708 PyObject *swig_obj[1] ;
36709
36710 if (!args) SWIG_fail;
36711 swig_obj[0] = args;
36712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36713 if (!SWIG_IsOK(res1)) {
36714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36715 }
36716 arg1 = reinterpret_cast< wxWindow * >(argp1);
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 result = ((wxWindow const *)arg1)->GetHelpText();
36720 wxPyEndAllowThreads(__tstate);
36721 if (PyErr_Occurred()) SWIG_fail;
36722 }
36723 {
36724 #if wxUSE_UNICODE
36725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36726 #else
36727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36728 #endif
36729 }
36730 return resultobj;
36731 fail:
36732 return NULL;
36733 }
36734
36735
36736 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36737 PyObject *resultobj = 0;
36738 wxWindow *arg1 = (wxWindow *) 0 ;
36739 wxString *arg2 = 0 ;
36740 void *argp1 = 0 ;
36741 int res1 = 0 ;
36742 bool temp2 = false ;
36743 PyObject * obj0 = 0 ;
36744 PyObject * obj1 = 0 ;
36745 char * kwnames[] = {
36746 (char *) "self",(char *) "tip", NULL
36747 };
36748
36749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36751 if (!SWIG_IsOK(res1)) {
36752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36753 }
36754 arg1 = reinterpret_cast< wxWindow * >(argp1);
36755 {
36756 arg2 = wxString_in_helper(obj1);
36757 if (arg2 == NULL) SWIG_fail;
36758 temp2 = true;
36759 }
36760 {
36761 PyThreadState* __tstate = wxPyBeginAllowThreads();
36762 (arg1)->SetToolTip((wxString const &)*arg2);
36763 wxPyEndAllowThreads(__tstate);
36764 if (PyErr_Occurred()) SWIG_fail;
36765 }
36766 resultobj = SWIG_Py_Void();
36767 {
36768 if (temp2)
36769 delete arg2;
36770 }
36771 return resultobj;
36772 fail:
36773 {
36774 if (temp2)
36775 delete arg2;
36776 }
36777 return NULL;
36778 }
36779
36780
36781 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36782 PyObject *resultobj = 0;
36783 wxWindow *arg1 = (wxWindow *) 0 ;
36784 wxToolTip *arg2 = (wxToolTip *) 0 ;
36785 void *argp1 = 0 ;
36786 int res1 = 0 ;
36787 int res2 = 0 ;
36788 PyObject * obj0 = 0 ;
36789 PyObject * obj1 = 0 ;
36790 char * kwnames[] = {
36791 (char *) "self",(char *) "tip", NULL
36792 };
36793
36794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36796 if (!SWIG_IsOK(res1)) {
36797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36798 }
36799 arg1 = reinterpret_cast< wxWindow * >(argp1);
36800 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36801 if (!SWIG_IsOK(res2)) {
36802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36803 }
36804 {
36805 PyThreadState* __tstate = wxPyBeginAllowThreads();
36806 (arg1)->SetToolTip(arg2);
36807 wxPyEndAllowThreads(__tstate);
36808 if (PyErr_Occurred()) SWIG_fail;
36809 }
36810 resultobj = SWIG_Py_Void();
36811 return resultobj;
36812 fail:
36813 return NULL;
36814 }
36815
36816
36817 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36818 PyObject *resultobj = 0;
36819 wxWindow *arg1 = (wxWindow *) 0 ;
36820 wxToolTip *result = 0 ;
36821 void *argp1 = 0 ;
36822 int res1 = 0 ;
36823 PyObject *swig_obj[1] ;
36824
36825 if (!args) SWIG_fail;
36826 swig_obj[0] = args;
36827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36828 if (!SWIG_IsOK(res1)) {
36829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36830 }
36831 arg1 = reinterpret_cast< wxWindow * >(argp1);
36832 {
36833 PyThreadState* __tstate = wxPyBeginAllowThreads();
36834 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36835 wxPyEndAllowThreads(__tstate);
36836 if (PyErr_Occurred()) SWIG_fail;
36837 }
36838 {
36839 resultobj = wxPyMake_wxObject(result, (bool)0);
36840 }
36841 return resultobj;
36842 fail:
36843 return NULL;
36844 }
36845
36846
36847 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36848 PyObject *resultobj = 0;
36849 wxWindow *arg1 = (wxWindow *) 0 ;
36850 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36851 void *argp1 = 0 ;
36852 int res1 = 0 ;
36853 int res2 = 0 ;
36854 PyObject * obj0 = 0 ;
36855 PyObject * obj1 = 0 ;
36856 char * kwnames[] = {
36857 (char *) "self",(char *) "dropTarget", NULL
36858 };
36859
36860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36862 if (!SWIG_IsOK(res1)) {
36863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36864 }
36865 arg1 = reinterpret_cast< wxWindow * >(argp1);
36866 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36867 if (!SWIG_IsOK(res2)) {
36868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36869 }
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 (arg1)->SetDropTarget(arg2);
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 resultobj = SWIG_Py_Void();
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36884 PyObject *resultobj = 0;
36885 wxWindow *arg1 = (wxWindow *) 0 ;
36886 wxPyDropTarget *result = 0 ;
36887 void *argp1 = 0 ;
36888 int res1 = 0 ;
36889 PyObject *swig_obj[1] ;
36890
36891 if (!args) SWIG_fail;
36892 swig_obj[0] = args;
36893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36894 if (!SWIG_IsOK(res1)) {
36895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36896 }
36897 arg1 = reinterpret_cast< wxWindow * >(argp1);
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36905 return resultobj;
36906 fail:
36907 return NULL;
36908 }
36909
36910
36911 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36912 PyObject *resultobj = 0;
36913 wxWindow *arg1 = (wxWindow *) 0 ;
36914 bool arg2 ;
36915 void *argp1 = 0 ;
36916 int res1 = 0 ;
36917 bool val2 ;
36918 int ecode2 = 0 ;
36919 PyObject * obj0 = 0 ;
36920 PyObject * obj1 = 0 ;
36921 char * kwnames[] = {
36922 (char *) "self",(char *) "accept", NULL
36923 };
36924
36925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36927 if (!SWIG_IsOK(res1)) {
36928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36929 }
36930 arg1 = reinterpret_cast< wxWindow * >(argp1);
36931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36932 if (!SWIG_IsOK(ecode2)) {
36933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36934 }
36935 arg2 = static_cast< bool >(val2);
36936 {
36937 PyThreadState* __tstate = wxPyBeginAllowThreads();
36938 wxWindow_DragAcceptFiles(arg1,arg2);
36939 wxPyEndAllowThreads(__tstate);
36940 if (PyErr_Occurred()) SWIG_fail;
36941 }
36942 resultobj = SWIG_Py_Void();
36943 return resultobj;
36944 fail:
36945 return NULL;
36946 }
36947
36948
36949 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36950 PyObject *resultobj = 0;
36951 wxWindow *arg1 = (wxWindow *) 0 ;
36952 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
36953 void *argp1 = 0 ;
36954 int res1 = 0 ;
36955 int res2 = 0 ;
36956 PyObject * obj0 = 0 ;
36957 PyObject * obj1 = 0 ;
36958 char * kwnames[] = {
36959 (char *) "self",(char *) "constraints", NULL
36960 };
36961
36962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
36963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36964 if (!SWIG_IsOK(res1)) {
36965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
36966 }
36967 arg1 = reinterpret_cast< wxWindow * >(argp1);
36968 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
36969 if (!SWIG_IsOK(res2)) {
36970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
36971 }
36972 {
36973 PyThreadState* __tstate = wxPyBeginAllowThreads();
36974 (arg1)->SetConstraints(arg2);
36975 wxPyEndAllowThreads(__tstate);
36976 if (PyErr_Occurred()) SWIG_fail;
36977 }
36978 resultobj = SWIG_Py_Void();
36979 return resultobj;
36980 fail:
36981 return NULL;
36982 }
36983
36984
36985 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36986 PyObject *resultobj = 0;
36987 wxWindow *arg1 = (wxWindow *) 0 ;
36988 wxLayoutConstraints *result = 0 ;
36989 void *argp1 = 0 ;
36990 int res1 = 0 ;
36991 PyObject *swig_obj[1] ;
36992
36993 if (!args) SWIG_fail;
36994 swig_obj[0] = args;
36995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36996 if (!SWIG_IsOK(res1)) {
36997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
36998 }
36999 arg1 = reinterpret_cast< wxWindow * >(argp1);
37000 {
37001 PyThreadState* __tstate = wxPyBeginAllowThreads();
37002 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37003 wxPyEndAllowThreads(__tstate);
37004 if (PyErr_Occurred()) SWIG_fail;
37005 }
37006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37007 return resultobj;
37008 fail:
37009 return NULL;
37010 }
37011
37012
37013 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37014 PyObject *resultobj = 0;
37015 wxWindow *arg1 = (wxWindow *) 0 ;
37016 bool arg2 ;
37017 void *argp1 = 0 ;
37018 int res1 = 0 ;
37019 bool val2 ;
37020 int ecode2 = 0 ;
37021 PyObject * obj0 = 0 ;
37022 PyObject * obj1 = 0 ;
37023 char * kwnames[] = {
37024 (char *) "self",(char *) "autoLayout", NULL
37025 };
37026
37027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37029 if (!SWIG_IsOK(res1)) {
37030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37031 }
37032 arg1 = reinterpret_cast< wxWindow * >(argp1);
37033 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37034 if (!SWIG_IsOK(ecode2)) {
37035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37036 }
37037 arg2 = static_cast< bool >(val2);
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 (arg1)->SetAutoLayout(arg2);
37041 wxPyEndAllowThreads(__tstate);
37042 if (PyErr_Occurred()) SWIG_fail;
37043 }
37044 resultobj = SWIG_Py_Void();
37045 return resultobj;
37046 fail:
37047 return NULL;
37048 }
37049
37050
37051 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37052 PyObject *resultobj = 0;
37053 wxWindow *arg1 = (wxWindow *) 0 ;
37054 bool result;
37055 void *argp1 = 0 ;
37056 int res1 = 0 ;
37057 PyObject *swig_obj[1] ;
37058
37059 if (!args) SWIG_fail;
37060 swig_obj[0] = args;
37061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37062 if (!SWIG_IsOK(res1)) {
37063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37064 }
37065 arg1 = reinterpret_cast< wxWindow * >(argp1);
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37069 wxPyEndAllowThreads(__tstate);
37070 if (PyErr_Occurred()) SWIG_fail;
37071 }
37072 {
37073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37074 }
37075 return resultobj;
37076 fail:
37077 return NULL;
37078 }
37079
37080
37081 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37082 PyObject *resultobj = 0;
37083 wxWindow *arg1 = (wxWindow *) 0 ;
37084 bool result;
37085 void *argp1 = 0 ;
37086 int res1 = 0 ;
37087 PyObject *swig_obj[1] ;
37088
37089 if (!args) SWIG_fail;
37090 swig_obj[0] = args;
37091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37092 if (!SWIG_IsOK(res1)) {
37093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37094 }
37095 arg1 = reinterpret_cast< wxWindow * >(argp1);
37096 {
37097 PyThreadState* __tstate = wxPyBeginAllowThreads();
37098 result = (bool)(arg1)->Layout();
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 {
37103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37104 }
37105 return resultobj;
37106 fail:
37107 return NULL;
37108 }
37109
37110
37111 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37112 PyObject *resultobj = 0;
37113 wxWindow *arg1 = (wxWindow *) 0 ;
37114 wxSizer *arg2 = (wxSizer *) 0 ;
37115 bool arg3 = (bool) true ;
37116 void *argp1 = 0 ;
37117 int res1 = 0 ;
37118 int res2 = 0 ;
37119 bool val3 ;
37120 int ecode3 = 0 ;
37121 PyObject * obj0 = 0 ;
37122 PyObject * obj1 = 0 ;
37123 PyObject * obj2 = 0 ;
37124 char * kwnames[] = {
37125 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37126 };
37127
37128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37130 if (!SWIG_IsOK(res1)) {
37131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37132 }
37133 arg1 = reinterpret_cast< wxWindow * >(argp1);
37134 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37135 if (!SWIG_IsOK(res2)) {
37136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37137 }
37138 if (obj2) {
37139 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37140 if (!SWIG_IsOK(ecode3)) {
37141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37142 }
37143 arg3 = static_cast< bool >(val3);
37144 }
37145 {
37146 PyThreadState* __tstate = wxPyBeginAllowThreads();
37147 (arg1)->SetSizer(arg2,arg3);
37148 wxPyEndAllowThreads(__tstate);
37149 if (PyErr_Occurred()) SWIG_fail;
37150 }
37151 resultobj = SWIG_Py_Void();
37152 return resultobj;
37153 fail:
37154 return NULL;
37155 }
37156
37157
37158 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37159 PyObject *resultobj = 0;
37160 wxWindow *arg1 = (wxWindow *) 0 ;
37161 wxSizer *arg2 = (wxSizer *) 0 ;
37162 bool arg3 = (bool) true ;
37163 void *argp1 = 0 ;
37164 int res1 = 0 ;
37165 int res2 = 0 ;
37166 bool val3 ;
37167 int ecode3 = 0 ;
37168 PyObject * obj0 = 0 ;
37169 PyObject * obj1 = 0 ;
37170 PyObject * obj2 = 0 ;
37171 char * kwnames[] = {
37172 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37173 };
37174
37175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37177 if (!SWIG_IsOK(res1)) {
37178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37179 }
37180 arg1 = reinterpret_cast< wxWindow * >(argp1);
37181 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37182 if (!SWIG_IsOK(res2)) {
37183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37184 }
37185 if (obj2) {
37186 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37187 if (!SWIG_IsOK(ecode3)) {
37188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37189 }
37190 arg3 = static_cast< bool >(val3);
37191 }
37192 {
37193 PyThreadState* __tstate = wxPyBeginAllowThreads();
37194 (arg1)->SetSizerAndFit(arg2,arg3);
37195 wxPyEndAllowThreads(__tstate);
37196 if (PyErr_Occurred()) SWIG_fail;
37197 }
37198 resultobj = SWIG_Py_Void();
37199 return resultobj;
37200 fail:
37201 return NULL;
37202 }
37203
37204
37205 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37206 PyObject *resultobj = 0;
37207 wxWindow *arg1 = (wxWindow *) 0 ;
37208 wxSizer *result = 0 ;
37209 void *argp1 = 0 ;
37210 int res1 = 0 ;
37211 PyObject *swig_obj[1] ;
37212
37213 if (!args) SWIG_fail;
37214 swig_obj[0] = args;
37215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37216 if (!SWIG_IsOK(res1)) {
37217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37218 }
37219 arg1 = reinterpret_cast< wxWindow * >(argp1);
37220 {
37221 PyThreadState* __tstate = wxPyBeginAllowThreads();
37222 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37223 wxPyEndAllowThreads(__tstate);
37224 if (PyErr_Occurred()) SWIG_fail;
37225 }
37226 {
37227 resultobj = wxPyMake_wxObject(result, (bool)0);
37228 }
37229 return resultobj;
37230 fail:
37231 return NULL;
37232 }
37233
37234
37235 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37236 PyObject *resultobj = 0;
37237 wxWindow *arg1 = (wxWindow *) 0 ;
37238 wxSizer *arg2 = (wxSizer *) 0 ;
37239 void *argp1 = 0 ;
37240 int res1 = 0 ;
37241 void *argp2 = 0 ;
37242 int res2 = 0 ;
37243 PyObject * obj0 = 0 ;
37244 PyObject * obj1 = 0 ;
37245 char * kwnames[] = {
37246 (char *) "self",(char *) "sizer", NULL
37247 };
37248
37249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37251 if (!SWIG_IsOK(res1)) {
37252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37253 }
37254 arg1 = reinterpret_cast< wxWindow * >(argp1);
37255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37256 if (!SWIG_IsOK(res2)) {
37257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37258 }
37259 arg2 = reinterpret_cast< wxSizer * >(argp2);
37260 {
37261 PyThreadState* __tstate = wxPyBeginAllowThreads();
37262 (arg1)->SetContainingSizer(arg2);
37263 wxPyEndAllowThreads(__tstate);
37264 if (PyErr_Occurred()) SWIG_fail;
37265 }
37266 resultobj = SWIG_Py_Void();
37267 return resultobj;
37268 fail:
37269 return NULL;
37270 }
37271
37272
37273 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37274 PyObject *resultobj = 0;
37275 wxWindow *arg1 = (wxWindow *) 0 ;
37276 wxSizer *result = 0 ;
37277 void *argp1 = 0 ;
37278 int res1 = 0 ;
37279 PyObject *swig_obj[1] ;
37280
37281 if (!args) SWIG_fail;
37282 swig_obj[0] = args;
37283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37284 if (!SWIG_IsOK(res1)) {
37285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37286 }
37287 arg1 = reinterpret_cast< wxWindow * >(argp1);
37288 {
37289 PyThreadState* __tstate = wxPyBeginAllowThreads();
37290 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37291 wxPyEndAllowThreads(__tstate);
37292 if (PyErr_Occurred()) SWIG_fail;
37293 }
37294 {
37295 resultobj = wxPyMake_wxObject(result, (bool)0);
37296 }
37297 return resultobj;
37298 fail:
37299 return NULL;
37300 }
37301
37302
37303 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37304 PyObject *resultobj = 0;
37305 wxWindow *arg1 = (wxWindow *) 0 ;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 PyObject *swig_obj[1] ;
37309
37310 if (!args) SWIG_fail;
37311 swig_obj[0] = args;
37312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37313 if (!SWIG_IsOK(res1)) {
37314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37315 }
37316 arg1 = reinterpret_cast< wxWindow * >(argp1);
37317 {
37318 PyThreadState* __tstate = wxPyBeginAllowThreads();
37319 (arg1)->InheritAttributes();
37320 wxPyEndAllowThreads(__tstate);
37321 if (PyErr_Occurred()) SWIG_fail;
37322 }
37323 resultobj = SWIG_Py_Void();
37324 return resultobj;
37325 fail:
37326 return NULL;
37327 }
37328
37329
37330 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37331 PyObject *resultobj = 0;
37332 wxWindow *arg1 = (wxWindow *) 0 ;
37333 bool result;
37334 void *argp1 = 0 ;
37335 int res1 = 0 ;
37336 PyObject *swig_obj[1] ;
37337
37338 if (!args) SWIG_fail;
37339 swig_obj[0] = args;
37340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37341 if (!SWIG_IsOK(res1)) {
37342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37343 }
37344 arg1 = reinterpret_cast< wxWindow * >(argp1);
37345 {
37346 PyThreadState* __tstate = wxPyBeginAllowThreads();
37347 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37348 wxPyEndAllowThreads(__tstate);
37349 if (PyErr_Occurred()) SWIG_fail;
37350 }
37351 {
37352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37353 }
37354 return resultobj;
37355 fail:
37356 return NULL;
37357 }
37358
37359
37360 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37361 PyObject *obj;
37362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37363 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37364 return SWIG_Py_Void();
37365 }
37366
37367 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37368 return SWIG_Python_InitShadowInstance(args);
37369 }
37370
37371 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37372 PyObject *resultobj = 0;
37373 long arg1 ;
37374 wxWindow *arg2 = (wxWindow *) NULL ;
37375 wxWindow *result = 0 ;
37376 long val1 ;
37377 int ecode1 = 0 ;
37378 void *argp2 = 0 ;
37379 int res2 = 0 ;
37380 PyObject * obj0 = 0 ;
37381 PyObject * obj1 = 0 ;
37382 char * kwnames[] = {
37383 (char *) "id",(char *) "parent", NULL
37384 };
37385
37386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37387 ecode1 = SWIG_AsVal_long(obj0, &val1);
37388 if (!SWIG_IsOK(ecode1)) {
37389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37390 }
37391 arg1 = static_cast< long >(val1);
37392 if (obj1) {
37393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37394 if (!SWIG_IsOK(res2)) {
37395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37396 }
37397 arg2 = reinterpret_cast< wxWindow * >(argp2);
37398 }
37399 {
37400 if (!wxPyCheckForApp()) SWIG_fail;
37401 PyThreadState* __tstate = wxPyBeginAllowThreads();
37402 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37403 wxPyEndAllowThreads(__tstate);
37404 if (PyErr_Occurred()) SWIG_fail;
37405 }
37406 {
37407 resultobj = wxPyMake_wxObject(result, 0);
37408 }
37409 return resultobj;
37410 fail:
37411 return NULL;
37412 }
37413
37414
37415 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37416 PyObject *resultobj = 0;
37417 wxString *arg1 = 0 ;
37418 wxWindow *arg2 = (wxWindow *) NULL ;
37419 wxWindow *result = 0 ;
37420 bool temp1 = false ;
37421 void *argp2 = 0 ;
37422 int res2 = 0 ;
37423 PyObject * obj0 = 0 ;
37424 PyObject * obj1 = 0 ;
37425 char * kwnames[] = {
37426 (char *) "name",(char *) "parent", NULL
37427 };
37428
37429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37430 {
37431 arg1 = wxString_in_helper(obj0);
37432 if (arg1 == NULL) SWIG_fail;
37433 temp1 = true;
37434 }
37435 if (obj1) {
37436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37437 if (!SWIG_IsOK(res2)) {
37438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37439 }
37440 arg2 = reinterpret_cast< wxWindow * >(argp2);
37441 }
37442 {
37443 if (!wxPyCheckForApp()) SWIG_fail;
37444 PyThreadState* __tstate = wxPyBeginAllowThreads();
37445 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37446 wxPyEndAllowThreads(__tstate);
37447 if (PyErr_Occurred()) SWIG_fail;
37448 }
37449 {
37450 resultobj = wxPyMake_wxObject(result, 0);
37451 }
37452 {
37453 if (temp1)
37454 delete arg1;
37455 }
37456 return resultobj;
37457 fail:
37458 {
37459 if (temp1)
37460 delete arg1;
37461 }
37462 return NULL;
37463 }
37464
37465
37466 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37467 PyObject *resultobj = 0;
37468 wxString *arg1 = 0 ;
37469 wxWindow *arg2 = (wxWindow *) NULL ;
37470 wxWindow *result = 0 ;
37471 bool temp1 = false ;
37472 void *argp2 = 0 ;
37473 int res2 = 0 ;
37474 PyObject * obj0 = 0 ;
37475 PyObject * obj1 = 0 ;
37476 char * kwnames[] = {
37477 (char *) "label",(char *) "parent", NULL
37478 };
37479
37480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37481 {
37482 arg1 = wxString_in_helper(obj0);
37483 if (arg1 == NULL) SWIG_fail;
37484 temp1 = true;
37485 }
37486 if (obj1) {
37487 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37488 if (!SWIG_IsOK(res2)) {
37489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37490 }
37491 arg2 = reinterpret_cast< wxWindow * >(argp2);
37492 }
37493 {
37494 if (!wxPyCheckForApp()) SWIG_fail;
37495 PyThreadState* __tstate = wxPyBeginAllowThreads();
37496 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37497 wxPyEndAllowThreads(__tstate);
37498 if (PyErr_Occurred()) SWIG_fail;
37499 }
37500 {
37501 resultobj = wxPyMake_wxObject(result, 0);
37502 }
37503 {
37504 if (temp1)
37505 delete arg1;
37506 }
37507 return resultobj;
37508 fail:
37509 {
37510 if (temp1)
37511 delete arg1;
37512 }
37513 return NULL;
37514 }
37515
37516
37517 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37518 PyObject *resultobj = 0;
37519 wxWindow *arg1 = (wxWindow *) 0 ;
37520 unsigned long arg2 ;
37521 wxWindow *result = 0 ;
37522 void *argp1 = 0 ;
37523 int res1 = 0 ;
37524 unsigned long val2 ;
37525 int ecode2 = 0 ;
37526 PyObject * obj0 = 0 ;
37527 PyObject * obj1 = 0 ;
37528 char * kwnames[] = {
37529 (char *) "parent",(char *) "_hWnd", NULL
37530 };
37531
37532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37534 if (!SWIG_IsOK(res1)) {
37535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37536 }
37537 arg1 = reinterpret_cast< wxWindow * >(argp1);
37538 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37539 if (!SWIG_IsOK(ecode2)) {
37540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37541 }
37542 arg2 = static_cast< unsigned long >(val2);
37543 {
37544 PyThreadState* __tstate = wxPyBeginAllowThreads();
37545 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37546 wxPyEndAllowThreads(__tstate);
37547 if (PyErr_Occurred()) SWIG_fail;
37548 }
37549 {
37550 resultobj = wxPyMake_wxObject(result, 0);
37551 }
37552 return resultobj;
37553 fail:
37554 return NULL;
37555 }
37556
37557
37558 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37559 PyObject *resultobj = 0;
37560 PyObject *result = 0 ;
37561
37562 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37563 {
37564 PyThreadState* __tstate = wxPyBeginAllowThreads();
37565 result = (PyObject *)GetTopLevelWindows();
37566 wxPyEndAllowThreads(__tstate);
37567 if (PyErr_Occurred()) SWIG_fail;
37568 }
37569 resultobj = result;
37570 return resultobj;
37571 fail:
37572 return NULL;
37573 }
37574
37575
37576 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37577 PyObject *resultobj = 0;
37578 wxValidator *result = 0 ;
37579
37580 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37581 {
37582 PyThreadState* __tstate = wxPyBeginAllowThreads();
37583 result = (wxValidator *)new wxValidator();
37584 wxPyEndAllowThreads(__tstate);
37585 if (PyErr_Occurred()) SWIG_fail;
37586 }
37587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37588 return resultobj;
37589 fail:
37590 return NULL;
37591 }
37592
37593
37594 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37595 PyObject *resultobj = 0;
37596 wxValidator *arg1 = (wxValidator *) 0 ;
37597 wxValidator *result = 0 ;
37598 void *argp1 = 0 ;
37599 int res1 = 0 ;
37600 PyObject *swig_obj[1] ;
37601
37602 if (!args) SWIG_fail;
37603 swig_obj[0] = args;
37604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37605 if (!SWIG_IsOK(res1)) {
37606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37607 }
37608 arg1 = reinterpret_cast< wxValidator * >(argp1);
37609 {
37610 PyThreadState* __tstate = wxPyBeginAllowThreads();
37611 result = (wxValidator *)(arg1)->Clone();
37612 wxPyEndAllowThreads(__tstate);
37613 if (PyErr_Occurred()) SWIG_fail;
37614 }
37615 {
37616 resultobj = wxPyMake_wxObject(result, 0);
37617 }
37618 return resultobj;
37619 fail:
37620 return NULL;
37621 }
37622
37623
37624 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37625 PyObject *resultobj = 0;
37626 wxValidator *arg1 = (wxValidator *) 0 ;
37627 wxWindow *arg2 = (wxWindow *) 0 ;
37628 bool result;
37629 void *argp1 = 0 ;
37630 int res1 = 0 ;
37631 void *argp2 = 0 ;
37632 int res2 = 0 ;
37633 PyObject * obj0 = 0 ;
37634 PyObject * obj1 = 0 ;
37635 char * kwnames[] = {
37636 (char *) "self",(char *) "parent", NULL
37637 };
37638
37639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37641 if (!SWIG_IsOK(res1)) {
37642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37643 }
37644 arg1 = reinterpret_cast< wxValidator * >(argp1);
37645 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37646 if (!SWIG_IsOK(res2)) {
37647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37648 }
37649 arg2 = reinterpret_cast< wxWindow * >(argp2);
37650 {
37651 PyThreadState* __tstate = wxPyBeginAllowThreads();
37652 result = (bool)(arg1)->Validate(arg2);
37653 wxPyEndAllowThreads(__tstate);
37654 if (PyErr_Occurred()) SWIG_fail;
37655 }
37656 {
37657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37658 }
37659 return resultobj;
37660 fail:
37661 return NULL;
37662 }
37663
37664
37665 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37666 PyObject *resultobj = 0;
37667 wxValidator *arg1 = (wxValidator *) 0 ;
37668 bool result;
37669 void *argp1 = 0 ;
37670 int res1 = 0 ;
37671 PyObject *swig_obj[1] ;
37672
37673 if (!args) SWIG_fail;
37674 swig_obj[0] = args;
37675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37676 if (!SWIG_IsOK(res1)) {
37677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37678 }
37679 arg1 = reinterpret_cast< wxValidator * >(argp1);
37680 {
37681 PyThreadState* __tstate = wxPyBeginAllowThreads();
37682 result = (bool)(arg1)->TransferToWindow();
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 {
37687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37688 }
37689 return resultobj;
37690 fail:
37691 return NULL;
37692 }
37693
37694
37695 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37696 PyObject *resultobj = 0;
37697 wxValidator *arg1 = (wxValidator *) 0 ;
37698 bool result;
37699 void *argp1 = 0 ;
37700 int res1 = 0 ;
37701 PyObject *swig_obj[1] ;
37702
37703 if (!args) SWIG_fail;
37704 swig_obj[0] = args;
37705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37706 if (!SWIG_IsOK(res1)) {
37707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37708 }
37709 arg1 = reinterpret_cast< wxValidator * >(argp1);
37710 {
37711 PyThreadState* __tstate = wxPyBeginAllowThreads();
37712 result = (bool)(arg1)->TransferFromWindow();
37713 wxPyEndAllowThreads(__tstate);
37714 if (PyErr_Occurred()) SWIG_fail;
37715 }
37716 {
37717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37718 }
37719 return resultobj;
37720 fail:
37721 return NULL;
37722 }
37723
37724
37725 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37726 PyObject *resultobj = 0;
37727 wxValidator *arg1 = (wxValidator *) 0 ;
37728 wxWindow *result = 0 ;
37729 void *argp1 = 0 ;
37730 int res1 = 0 ;
37731 PyObject *swig_obj[1] ;
37732
37733 if (!args) SWIG_fail;
37734 swig_obj[0] = args;
37735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37736 if (!SWIG_IsOK(res1)) {
37737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37738 }
37739 arg1 = reinterpret_cast< wxValidator * >(argp1);
37740 {
37741 PyThreadState* __tstate = wxPyBeginAllowThreads();
37742 result = (wxWindow *)(arg1)->GetWindow();
37743 wxPyEndAllowThreads(__tstate);
37744 if (PyErr_Occurred()) SWIG_fail;
37745 }
37746 {
37747 resultobj = wxPyMake_wxObject(result, 0);
37748 }
37749 return resultobj;
37750 fail:
37751 return NULL;
37752 }
37753
37754
37755 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37756 PyObject *resultobj = 0;
37757 wxValidator *arg1 = (wxValidator *) 0 ;
37758 wxWindow *arg2 = (wxWindow *) 0 ;
37759 void *argp1 = 0 ;
37760 int res1 = 0 ;
37761 void *argp2 = 0 ;
37762 int res2 = 0 ;
37763 PyObject * obj0 = 0 ;
37764 PyObject * obj1 = 0 ;
37765 char * kwnames[] = {
37766 (char *) "self",(char *) "window", NULL
37767 };
37768
37769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37771 if (!SWIG_IsOK(res1)) {
37772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37773 }
37774 arg1 = reinterpret_cast< wxValidator * >(argp1);
37775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37776 if (!SWIG_IsOK(res2)) {
37777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37778 }
37779 arg2 = reinterpret_cast< wxWindow * >(argp2);
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 (arg1)->SetWindow(arg2);
37783 wxPyEndAllowThreads(__tstate);
37784 if (PyErr_Occurred()) SWIG_fail;
37785 }
37786 resultobj = SWIG_Py_Void();
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37794 PyObject *resultobj = 0;
37795 bool result;
37796
37797 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37798 {
37799 PyThreadState* __tstate = wxPyBeginAllowThreads();
37800 result = (bool)wxValidator::IsSilent();
37801 wxPyEndAllowThreads(__tstate);
37802 if (PyErr_Occurred()) SWIG_fail;
37803 }
37804 {
37805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37806 }
37807 return resultobj;
37808 fail:
37809 return NULL;
37810 }
37811
37812
37813 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37814 PyObject *resultobj = 0;
37815 int arg1 = (int) true ;
37816 int val1 ;
37817 int ecode1 = 0 ;
37818 PyObject * obj0 = 0 ;
37819 char * kwnames[] = {
37820 (char *) "doIt", NULL
37821 };
37822
37823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37824 if (obj0) {
37825 ecode1 = SWIG_AsVal_int(obj0, &val1);
37826 if (!SWIG_IsOK(ecode1)) {
37827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37828 }
37829 arg1 = static_cast< int >(val1);
37830 }
37831 {
37832 PyThreadState* __tstate = wxPyBeginAllowThreads();
37833 wxValidator::SetBellOnError(arg1);
37834 wxPyEndAllowThreads(__tstate);
37835 if (PyErr_Occurred()) SWIG_fail;
37836 }
37837 resultobj = SWIG_Py_Void();
37838 return resultobj;
37839 fail:
37840 return NULL;
37841 }
37842
37843
37844 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37845 PyObject *obj;
37846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37847 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37848 return SWIG_Py_Void();
37849 }
37850
37851 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37852 return SWIG_Python_InitShadowInstance(args);
37853 }
37854
37855 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37856 PyObject *resultobj = 0;
37857 wxPyValidator *result = 0 ;
37858
37859 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37860 {
37861 PyThreadState* __tstate = wxPyBeginAllowThreads();
37862 result = (wxPyValidator *)new wxPyValidator();
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37867 return resultobj;
37868 fail:
37869 return NULL;
37870 }
37871
37872
37873 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37874 PyObject *resultobj = 0;
37875 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37876 PyObject *arg2 = (PyObject *) 0 ;
37877 PyObject *arg3 = (PyObject *) 0 ;
37878 int arg4 = (int) true ;
37879 void *argp1 = 0 ;
37880 int res1 = 0 ;
37881 int val4 ;
37882 int ecode4 = 0 ;
37883 PyObject * obj0 = 0 ;
37884 PyObject * obj1 = 0 ;
37885 PyObject * obj2 = 0 ;
37886 PyObject * obj3 = 0 ;
37887 char * kwnames[] = {
37888 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37889 };
37890
37891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37893 if (!SWIG_IsOK(res1)) {
37894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37895 }
37896 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37897 arg2 = obj1;
37898 arg3 = obj2;
37899 if (obj3) {
37900 ecode4 = SWIG_AsVal_int(obj3, &val4);
37901 if (!SWIG_IsOK(ecode4)) {
37902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37903 }
37904 arg4 = static_cast< int >(val4);
37905 }
37906 {
37907 PyThreadState* __tstate = wxPyBeginAllowThreads();
37908 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37909 wxPyEndAllowThreads(__tstate);
37910 if (PyErr_Occurred()) SWIG_fail;
37911 }
37912 resultobj = SWIG_Py_Void();
37913 return resultobj;
37914 fail:
37915 return NULL;
37916 }
37917
37918
37919 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37920 PyObject *obj;
37921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37922 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37923 return SWIG_Py_Void();
37924 }
37925
37926 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37927 return SWIG_Python_InitShadowInstance(args);
37928 }
37929
37930 SWIGINTERN int DefaultValidator_set(PyObject *) {
37931 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37932 return 1;
37933 }
37934
37935
37936 SWIGINTERN PyObject *DefaultValidator_get(void) {
37937 PyObject *pyobj = 0;
37938
37939 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
37940 return pyobj;
37941 }
37942
37943
37944 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37945 PyObject *resultobj = 0;
37946 wxString const &arg1_defvalue = wxPyEmptyString ;
37947 wxString *arg1 = (wxString *) &arg1_defvalue ;
37948 long arg2 = (long) 0 ;
37949 wxMenu *result = 0 ;
37950 bool temp1 = false ;
37951 long val2 ;
37952 int ecode2 = 0 ;
37953 PyObject * obj0 = 0 ;
37954 PyObject * obj1 = 0 ;
37955 char * kwnames[] = {
37956 (char *) "title",(char *) "style", NULL
37957 };
37958
37959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
37960 if (obj0) {
37961 {
37962 arg1 = wxString_in_helper(obj0);
37963 if (arg1 == NULL) SWIG_fail;
37964 temp1 = true;
37965 }
37966 }
37967 if (obj1) {
37968 ecode2 = SWIG_AsVal_long(obj1, &val2);
37969 if (!SWIG_IsOK(ecode2)) {
37970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
37971 }
37972 arg2 = static_cast< long >(val2);
37973 }
37974 {
37975 if (!wxPyCheckForApp()) SWIG_fail;
37976 PyThreadState* __tstate = wxPyBeginAllowThreads();
37977 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
37978 wxPyEndAllowThreads(__tstate);
37979 if (PyErr_Occurred()) SWIG_fail;
37980 }
37981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
37982 {
37983 if (temp1)
37984 delete arg1;
37985 }
37986 return resultobj;
37987 fail:
37988 {
37989 if (temp1)
37990 delete arg1;
37991 }
37992 return NULL;
37993 }
37994
37995
37996 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37997 PyObject *resultobj = 0;
37998 wxMenu *arg1 = (wxMenu *) 0 ;
37999 int arg2 ;
38000 wxString *arg3 = 0 ;
38001 wxString const &arg4_defvalue = wxPyEmptyString ;
38002 wxString *arg4 = (wxString *) &arg4_defvalue ;
38003 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38004 wxMenuItem *result = 0 ;
38005 void *argp1 = 0 ;
38006 int res1 = 0 ;
38007 int val2 ;
38008 int ecode2 = 0 ;
38009 bool temp3 = false ;
38010 bool temp4 = false ;
38011 int val5 ;
38012 int ecode5 = 0 ;
38013 PyObject * obj0 = 0 ;
38014 PyObject * obj1 = 0 ;
38015 PyObject * obj2 = 0 ;
38016 PyObject * obj3 = 0 ;
38017 PyObject * obj4 = 0 ;
38018 char * kwnames[] = {
38019 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38020 };
38021
38022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38024 if (!SWIG_IsOK(res1)) {
38025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38026 }
38027 arg1 = reinterpret_cast< wxMenu * >(argp1);
38028 ecode2 = SWIG_AsVal_int(obj1, &val2);
38029 if (!SWIG_IsOK(ecode2)) {
38030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38031 }
38032 arg2 = static_cast< int >(val2);
38033 {
38034 arg3 = wxString_in_helper(obj2);
38035 if (arg3 == NULL) SWIG_fail;
38036 temp3 = true;
38037 }
38038 if (obj3) {
38039 {
38040 arg4 = wxString_in_helper(obj3);
38041 if (arg4 == NULL) SWIG_fail;
38042 temp4 = true;
38043 }
38044 }
38045 if (obj4) {
38046 ecode5 = SWIG_AsVal_int(obj4, &val5);
38047 if (!SWIG_IsOK(ecode5)) {
38048 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38049 }
38050 arg5 = static_cast< wxItemKind >(val5);
38051 }
38052 {
38053 PyThreadState* __tstate = wxPyBeginAllowThreads();
38054 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38055 wxPyEndAllowThreads(__tstate);
38056 if (PyErr_Occurred()) SWIG_fail;
38057 }
38058 {
38059 resultobj = wxPyMake_wxObject(result, (bool)0);
38060 }
38061 {
38062 if (temp3)
38063 delete arg3;
38064 }
38065 {
38066 if (temp4)
38067 delete arg4;
38068 }
38069 return resultobj;
38070 fail:
38071 {
38072 if (temp3)
38073 delete arg3;
38074 }
38075 {
38076 if (temp4)
38077 delete arg4;
38078 }
38079 return NULL;
38080 }
38081
38082
38083 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38084 PyObject *resultobj = 0;
38085 wxMenu *arg1 = (wxMenu *) 0 ;
38086 wxMenuItem *result = 0 ;
38087 void *argp1 = 0 ;
38088 int res1 = 0 ;
38089 PyObject *swig_obj[1] ;
38090
38091 if (!args) SWIG_fail;
38092 swig_obj[0] = args;
38093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38094 if (!SWIG_IsOK(res1)) {
38095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38096 }
38097 arg1 = reinterpret_cast< wxMenu * >(argp1);
38098 {
38099 PyThreadState* __tstate = wxPyBeginAllowThreads();
38100 result = (wxMenuItem *)(arg1)->AppendSeparator();
38101 wxPyEndAllowThreads(__tstate);
38102 if (PyErr_Occurred()) SWIG_fail;
38103 }
38104 {
38105 resultobj = wxPyMake_wxObject(result, (bool)0);
38106 }
38107 return resultobj;
38108 fail:
38109 return NULL;
38110 }
38111
38112
38113 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38114 PyObject *resultobj = 0;
38115 wxMenu *arg1 = (wxMenu *) 0 ;
38116 int arg2 ;
38117 wxString *arg3 = 0 ;
38118 wxString const &arg4_defvalue = wxPyEmptyString ;
38119 wxString *arg4 = (wxString *) &arg4_defvalue ;
38120 wxMenuItem *result = 0 ;
38121 void *argp1 = 0 ;
38122 int res1 = 0 ;
38123 int val2 ;
38124 int ecode2 = 0 ;
38125 bool temp3 = false ;
38126 bool temp4 = false ;
38127 PyObject * obj0 = 0 ;
38128 PyObject * obj1 = 0 ;
38129 PyObject * obj2 = 0 ;
38130 PyObject * obj3 = 0 ;
38131 char * kwnames[] = {
38132 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38133 };
38134
38135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38137 if (!SWIG_IsOK(res1)) {
38138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38139 }
38140 arg1 = reinterpret_cast< wxMenu * >(argp1);
38141 ecode2 = SWIG_AsVal_int(obj1, &val2);
38142 if (!SWIG_IsOK(ecode2)) {
38143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38144 }
38145 arg2 = static_cast< int >(val2);
38146 {
38147 arg3 = wxString_in_helper(obj2);
38148 if (arg3 == NULL) SWIG_fail;
38149 temp3 = true;
38150 }
38151 if (obj3) {
38152 {
38153 arg4 = wxString_in_helper(obj3);
38154 if (arg4 == NULL) SWIG_fail;
38155 temp4 = true;
38156 }
38157 }
38158 {
38159 PyThreadState* __tstate = wxPyBeginAllowThreads();
38160 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38161 wxPyEndAllowThreads(__tstate);
38162 if (PyErr_Occurred()) SWIG_fail;
38163 }
38164 {
38165 resultobj = wxPyMake_wxObject(result, (bool)0);
38166 }
38167 {
38168 if (temp3)
38169 delete arg3;
38170 }
38171 {
38172 if (temp4)
38173 delete arg4;
38174 }
38175 return resultobj;
38176 fail:
38177 {
38178 if (temp3)
38179 delete arg3;
38180 }
38181 {
38182 if (temp4)
38183 delete arg4;
38184 }
38185 return NULL;
38186 }
38187
38188
38189 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38190 PyObject *resultobj = 0;
38191 wxMenu *arg1 = (wxMenu *) 0 ;
38192 int arg2 ;
38193 wxString *arg3 = 0 ;
38194 wxString const &arg4_defvalue = wxPyEmptyString ;
38195 wxString *arg4 = (wxString *) &arg4_defvalue ;
38196 wxMenuItem *result = 0 ;
38197 void *argp1 = 0 ;
38198 int res1 = 0 ;
38199 int val2 ;
38200 int ecode2 = 0 ;
38201 bool temp3 = false ;
38202 bool temp4 = false ;
38203 PyObject * obj0 = 0 ;
38204 PyObject * obj1 = 0 ;
38205 PyObject * obj2 = 0 ;
38206 PyObject * obj3 = 0 ;
38207 char * kwnames[] = {
38208 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38209 };
38210
38211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38213 if (!SWIG_IsOK(res1)) {
38214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38215 }
38216 arg1 = reinterpret_cast< wxMenu * >(argp1);
38217 ecode2 = SWIG_AsVal_int(obj1, &val2);
38218 if (!SWIG_IsOK(ecode2)) {
38219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38220 }
38221 arg2 = static_cast< int >(val2);
38222 {
38223 arg3 = wxString_in_helper(obj2);
38224 if (arg3 == NULL) SWIG_fail;
38225 temp3 = true;
38226 }
38227 if (obj3) {
38228 {
38229 arg4 = wxString_in_helper(obj3);
38230 if (arg4 == NULL) SWIG_fail;
38231 temp4 = true;
38232 }
38233 }
38234 {
38235 PyThreadState* __tstate = wxPyBeginAllowThreads();
38236 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38237 wxPyEndAllowThreads(__tstate);
38238 if (PyErr_Occurred()) SWIG_fail;
38239 }
38240 {
38241 resultobj = wxPyMake_wxObject(result, (bool)0);
38242 }
38243 {
38244 if (temp3)
38245 delete arg3;
38246 }
38247 {
38248 if (temp4)
38249 delete arg4;
38250 }
38251 return resultobj;
38252 fail:
38253 {
38254 if (temp3)
38255 delete arg3;
38256 }
38257 {
38258 if (temp4)
38259 delete arg4;
38260 }
38261 return NULL;
38262 }
38263
38264
38265 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38266 PyObject *resultobj = 0;
38267 wxMenu *arg1 = (wxMenu *) 0 ;
38268 int arg2 ;
38269 wxString *arg3 = 0 ;
38270 wxMenu *arg4 = (wxMenu *) 0 ;
38271 wxString const &arg5_defvalue = wxPyEmptyString ;
38272 wxString *arg5 = (wxString *) &arg5_defvalue ;
38273 wxMenuItem *result = 0 ;
38274 void *argp1 = 0 ;
38275 int res1 = 0 ;
38276 int val2 ;
38277 int ecode2 = 0 ;
38278 bool temp3 = false ;
38279 void *argp4 = 0 ;
38280 int res4 = 0 ;
38281 bool temp5 = false ;
38282 PyObject * obj0 = 0 ;
38283 PyObject * obj1 = 0 ;
38284 PyObject * obj2 = 0 ;
38285 PyObject * obj3 = 0 ;
38286 PyObject * obj4 = 0 ;
38287 char * kwnames[] = {
38288 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38289 };
38290
38291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38293 if (!SWIG_IsOK(res1)) {
38294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38295 }
38296 arg1 = reinterpret_cast< wxMenu * >(argp1);
38297 ecode2 = SWIG_AsVal_int(obj1, &val2);
38298 if (!SWIG_IsOK(ecode2)) {
38299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38300 }
38301 arg2 = static_cast< int >(val2);
38302 {
38303 arg3 = wxString_in_helper(obj2);
38304 if (arg3 == NULL) SWIG_fail;
38305 temp3 = true;
38306 }
38307 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38308 if (!SWIG_IsOK(res4)) {
38309 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38310 }
38311 arg4 = reinterpret_cast< wxMenu * >(argp4);
38312 if (obj4) {
38313 {
38314 arg5 = wxString_in_helper(obj4);
38315 if (arg5 == NULL) SWIG_fail;
38316 temp5 = true;
38317 }
38318 }
38319 {
38320 PyThreadState* __tstate = wxPyBeginAllowThreads();
38321 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38322 wxPyEndAllowThreads(__tstate);
38323 if (PyErr_Occurred()) SWIG_fail;
38324 }
38325 {
38326 resultobj = wxPyMake_wxObject(result, (bool)0);
38327 }
38328 {
38329 if (temp3)
38330 delete arg3;
38331 }
38332 {
38333 if (temp5)
38334 delete arg5;
38335 }
38336 return resultobj;
38337 fail:
38338 {
38339 if (temp3)
38340 delete arg3;
38341 }
38342 {
38343 if (temp5)
38344 delete arg5;
38345 }
38346 return NULL;
38347 }
38348
38349
38350 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38351 PyObject *resultobj = 0;
38352 wxMenu *arg1 = (wxMenu *) 0 ;
38353 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38354 wxMenuItem *result = 0 ;
38355 void *argp1 = 0 ;
38356 int res1 = 0 ;
38357 int res2 = 0 ;
38358 PyObject * obj0 = 0 ;
38359 PyObject * obj1 = 0 ;
38360 char * kwnames[] = {
38361 (char *) "self",(char *) "item", NULL
38362 };
38363
38364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38366 if (!SWIG_IsOK(res1)) {
38367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38368 }
38369 arg1 = reinterpret_cast< wxMenu * >(argp1);
38370 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38371 if (!SWIG_IsOK(res2)) {
38372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38373 }
38374 {
38375 PyThreadState* __tstate = wxPyBeginAllowThreads();
38376 result = (wxMenuItem *)(arg1)->Append(arg2);
38377 wxPyEndAllowThreads(__tstate);
38378 if (PyErr_Occurred()) SWIG_fail;
38379 }
38380 {
38381 resultobj = wxPyMake_wxObject(result, (bool)0);
38382 }
38383 return resultobj;
38384 fail:
38385 return NULL;
38386 }
38387
38388
38389 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38390 PyObject *resultobj = 0;
38391 wxMenu *arg1 = (wxMenu *) 0 ;
38392 size_t arg2 ;
38393 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38394 wxMenuItem *result = 0 ;
38395 void *argp1 = 0 ;
38396 int res1 = 0 ;
38397 size_t val2 ;
38398 int ecode2 = 0 ;
38399 int res3 = 0 ;
38400 PyObject * obj0 = 0 ;
38401 PyObject * obj1 = 0 ;
38402 PyObject * obj2 = 0 ;
38403 char * kwnames[] = {
38404 (char *) "self",(char *) "pos",(char *) "item", NULL
38405 };
38406
38407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38409 if (!SWIG_IsOK(res1)) {
38410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38411 }
38412 arg1 = reinterpret_cast< wxMenu * >(argp1);
38413 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38414 if (!SWIG_IsOK(ecode2)) {
38415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38416 }
38417 arg2 = static_cast< size_t >(val2);
38418 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38419 if (!SWIG_IsOK(res3)) {
38420 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38421 }
38422 {
38423 PyThreadState* __tstate = wxPyBeginAllowThreads();
38424 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38425 wxPyEndAllowThreads(__tstate);
38426 if (PyErr_Occurred()) SWIG_fail;
38427 }
38428 {
38429 resultobj = wxPyMake_wxObject(result, (bool)0);
38430 }
38431 return resultobj;
38432 fail:
38433 return NULL;
38434 }
38435
38436
38437 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38438 PyObject *resultobj = 0;
38439 wxMenu *arg1 = (wxMenu *) 0 ;
38440 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38441 wxMenuItem *result = 0 ;
38442 void *argp1 = 0 ;
38443 int res1 = 0 ;
38444 int res2 = 0 ;
38445 PyObject * obj0 = 0 ;
38446 PyObject * obj1 = 0 ;
38447 char * kwnames[] = {
38448 (char *) "self",(char *) "item", NULL
38449 };
38450
38451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38453 if (!SWIG_IsOK(res1)) {
38454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38455 }
38456 arg1 = reinterpret_cast< wxMenu * >(argp1);
38457 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38458 if (!SWIG_IsOK(res2)) {
38459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38460 }
38461 {
38462 PyThreadState* __tstate = wxPyBeginAllowThreads();
38463 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38464 wxPyEndAllowThreads(__tstate);
38465 if (PyErr_Occurred()) SWIG_fail;
38466 }
38467 {
38468 resultobj = wxPyMake_wxObject(result, (bool)0);
38469 }
38470 return resultobj;
38471 fail:
38472 return NULL;
38473 }
38474
38475
38476 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38477 PyObject *resultobj = 0;
38478 wxMenu *arg1 = (wxMenu *) 0 ;
38479 void *argp1 = 0 ;
38480 int res1 = 0 ;
38481 PyObject *swig_obj[1] ;
38482
38483 if (!args) SWIG_fail;
38484 swig_obj[0] = args;
38485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38486 if (!SWIG_IsOK(res1)) {
38487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38488 }
38489 arg1 = reinterpret_cast< wxMenu * >(argp1);
38490 {
38491 PyThreadState* __tstate = wxPyBeginAllowThreads();
38492 (arg1)->Break();
38493 wxPyEndAllowThreads(__tstate);
38494 if (PyErr_Occurred()) SWIG_fail;
38495 }
38496 resultobj = SWIG_Py_Void();
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj = 0;
38505 wxMenu *arg1 = (wxMenu *) 0 ;
38506 size_t arg2 ;
38507 int arg3 ;
38508 wxString *arg4 = 0 ;
38509 wxString const &arg5_defvalue = wxPyEmptyString ;
38510 wxString *arg5 = (wxString *) &arg5_defvalue ;
38511 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38512 wxMenuItem *result = 0 ;
38513 void *argp1 = 0 ;
38514 int res1 = 0 ;
38515 size_t val2 ;
38516 int ecode2 = 0 ;
38517 int val3 ;
38518 int ecode3 = 0 ;
38519 bool temp4 = false ;
38520 bool temp5 = false ;
38521 int val6 ;
38522 int ecode6 = 0 ;
38523 PyObject * obj0 = 0 ;
38524 PyObject * obj1 = 0 ;
38525 PyObject * obj2 = 0 ;
38526 PyObject * obj3 = 0 ;
38527 PyObject * obj4 = 0 ;
38528 PyObject * obj5 = 0 ;
38529 char * kwnames[] = {
38530 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38531 };
38532
38533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38535 if (!SWIG_IsOK(res1)) {
38536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38537 }
38538 arg1 = reinterpret_cast< wxMenu * >(argp1);
38539 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38540 if (!SWIG_IsOK(ecode2)) {
38541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38542 }
38543 arg2 = static_cast< size_t >(val2);
38544 ecode3 = SWIG_AsVal_int(obj2, &val3);
38545 if (!SWIG_IsOK(ecode3)) {
38546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38547 }
38548 arg3 = static_cast< int >(val3);
38549 {
38550 arg4 = wxString_in_helper(obj3);
38551 if (arg4 == NULL) SWIG_fail;
38552 temp4 = true;
38553 }
38554 if (obj4) {
38555 {
38556 arg5 = wxString_in_helper(obj4);
38557 if (arg5 == NULL) SWIG_fail;
38558 temp5 = true;
38559 }
38560 }
38561 if (obj5) {
38562 ecode6 = SWIG_AsVal_int(obj5, &val6);
38563 if (!SWIG_IsOK(ecode6)) {
38564 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38565 }
38566 arg6 = static_cast< wxItemKind >(val6);
38567 }
38568 {
38569 PyThreadState* __tstate = wxPyBeginAllowThreads();
38570 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38571 wxPyEndAllowThreads(__tstate);
38572 if (PyErr_Occurred()) SWIG_fail;
38573 }
38574 {
38575 resultobj = wxPyMake_wxObject(result, (bool)0);
38576 }
38577 {
38578 if (temp4)
38579 delete arg4;
38580 }
38581 {
38582 if (temp5)
38583 delete arg5;
38584 }
38585 return resultobj;
38586 fail:
38587 {
38588 if (temp4)
38589 delete arg4;
38590 }
38591 {
38592 if (temp5)
38593 delete arg5;
38594 }
38595 return NULL;
38596 }
38597
38598
38599 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38600 PyObject *resultobj = 0;
38601 wxMenu *arg1 = (wxMenu *) 0 ;
38602 size_t arg2 ;
38603 wxMenuItem *result = 0 ;
38604 void *argp1 = 0 ;
38605 int res1 = 0 ;
38606 size_t val2 ;
38607 int ecode2 = 0 ;
38608 PyObject * obj0 = 0 ;
38609 PyObject * obj1 = 0 ;
38610 char * kwnames[] = {
38611 (char *) "self",(char *) "pos", NULL
38612 };
38613
38614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38616 if (!SWIG_IsOK(res1)) {
38617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38618 }
38619 arg1 = reinterpret_cast< wxMenu * >(argp1);
38620 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38621 if (!SWIG_IsOK(ecode2)) {
38622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38623 }
38624 arg2 = static_cast< size_t >(val2);
38625 {
38626 PyThreadState* __tstate = wxPyBeginAllowThreads();
38627 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38628 wxPyEndAllowThreads(__tstate);
38629 if (PyErr_Occurred()) SWIG_fail;
38630 }
38631 {
38632 resultobj = wxPyMake_wxObject(result, (bool)0);
38633 }
38634 return resultobj;
38635 fail:
38636 return NULL;
38637 }
38638
38639
38640 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38641 PyObject *resultobj = 0;
38642 wxMenu *arg1 = (wxMenu *) 0 ;
38643 size_t arg2 ;
38644 int arg3 ;
38645 wxString *arg4 = 0 ;
38646 wxString const &arg5_defvalue = wxPyEmptyString ;
38647 wxString *arg5 = (wxString *) &arg5_defvalue ;
38648 wxMenuItem *result = 0 ;
38649 void *argp1 = 0 ;
38650 int res1 = 0 ;
38651 size_t val2 ;
38652 int ecode2 = 0 ;
38653 int val3 ;
38654 int ecode3 = 0 ;
38655 bool temp4 = false ;
38656 bool temp5 = false ;
38657 PyObject * obj0 = 0 ;
38658 PyObject * obj1 = 0 ;
38659 PyObject * obj2 = 0 ;
38660 PyObject * obj3 = 0 ;
38661 PyObject * obj4 = 0 ;
38662 char * kwnames[] = {
38663 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38664 };
38665
38666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38668 if (!SWIG_IsOK(res1)) {
38669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38670 }
38671 arg1 = reinterpret_cast< wxMenu * >(argp1);
38672 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38673 if (!SWIG_IsOK(ecode2)) {
38674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38675 }
38676 arg2 = static_cast< size_t >(val2);
38677 ecode3 = SWIG_AsVal_int(obj2, &val3);
38678 if (!SWIG_IsOK(ecode3)) {
38679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38680 }
38681 arg3 = static_cast< int >(val3);
38682 {
38683 arg4 = wxString_in_helper(obj3);
38684 if (arg4 == NULL) SWIG_fail;
38685 temp4 = true;
38686 }
38687 if (obj4) {
38688 {
38689 arg5 = wxString_in_helper(obj4);
38690 if (arg5 == NULL) SWIG_fail;
38691 temp5 = true;
38692 }
38693 }
38694 {
38695 PyThreadState* __tstate = wxPyBeginAllowThreads();
38696 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38697 wxPyEndAllowThreads(__tstate);
38698 if (PyErr_Occurred()) SWIG_fail;
38699 }
38700 {
38701 resultobj = wxPyMake_wxObject(result, (bool)0);
38702 }
38703 {
38704 if (temp4)
38705 delete arg4;
38706 }
38707 {
38708 if (temp5)
38709 delete arg5;
38710 }
38711 return resultobj;
38712 fail:
38713 {
38714 if (temp4)
38715 delete arg4;
38716 }
38717 {
38718 if (temp5)
38719 delete arg5;
38720 }
38721 return NULL;
38722 }
38723
38724
38725 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38726 PyObject *resultobj = 0;
38727 wxMenu *arg1 = (wxMenu *) 0 ;
38728 size_t arg2 ;
38729 int arg3 ;
38730 wxString *arg4 = 0 ;
38731 wxString const &arg5_defvalue = wxPyEmptyString ;
38732 wxString *arg5 = (wxString *) &arg5_defvalue ;
38733 wxMenuItem *result = 0 ;
38734 void *argp1 = 0 ;
38735 int res1 = 0 ;
38736 size_t val2 ;
38737 int ecode2 = 0 ;
38738 int val3 ;
38739 int ecode3 = 0 ;
38740 bool temp4 = false ;
38741 bool temp5 = false ;
38742 PyObject * obj0 = 0 ;
38743 PyObject * obj1 = 0 ;
38744 PyObject * obj2 = 0 ;
38745 PyObject * obj3 = 0 ;
38746 PyObject * obj4 = 0 ;
38747 char * kwnames[] = {
38748 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38749 };
38750
38751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38753 if (!SWIG_IsOK(res1)) {
38754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38755 }
38756 arg1 = reinterpret_cast< wxMenu * >(argp1);
38757 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38758 if (!SWIG_IsOK(ecode2)) {
38759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38760 }
38761 arg2 = static_cast< size_t >(val2);
38762 ecode3 = SWIG_AsVal_int(obj2, &val3);
38763 if (!SWIG_IsOK(ecode3)) {
38764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38765 }
38766 arg3 = static_cast< int >(val3);
38767 {
38768 arg4 = wxString_in_helper(obj3);
38769 if (arg4 == NULL) SWIG_fail;
38770 temp4 = true;
38771 }
38772 if (obj4) {
38773 {
38774 arg5 = wxString_in_helper(obj4);
38775 if (arg5 == NULL) SWIG_fail;
38776 temp5 = true;
38777 }
38778 }
38779 {
38780 PyThreadState* __tstate = wxPyBeginAllowThreads();
38781 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38782 wxPyEndAllowThreads(__tstate);
38783 if (PyErr_Occurred()) SWIG_fail;
38784 }
38785 {
38786 resultobj = wxPyMake_wxObject(result, (bool)0);
38787 }
38788 {
38789 if (temp4)
38790 delete arg4;
38791 }
38792 {
38793 if (temp5)
38794 delete arg5;
38795 }
38796 return resultobj;
38797 fail:
38798 {
38799 if (temp4)
38800 delete arg4;
38801 }
38802 {
38803 if (temp5)
38804 delete arg5;
38805 }
38806 return NULL;
38807 }
38808
38809
38810 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38811 PyObject *resultobj = 0;
38812 wxMenu *arg1 = (wxMenu *) 0 ;
38813 size_t arg2 ;
38814 int arg3 ;
38815 wxString *arg4 = 0 ;
38816 wxMenu *arg5 = (wxMenu *) 0 ;
38817 wxString const &arg6_defvalue = wxPyEmptyString ;
38818 wxString *arg6 = (wxString *) &arg6_defvalue ;
38819 wxMenuItem *result = 0 ;
38820 void *argp1 = 0 ;
38821 int res1 = 0 ;
38822 size_t val2 ;
38823 int ecode2 = 0 ;
38824 int val3 ;
38825 int ecode3 = 0 ;
38826 bool temp4 = false ;
38827 void *argp5 = 0 ;
38828 int res5 = 0 ;
38829 bool temp6 = false ;
38830 PyObject * obj0 = 0 ;
38831 PyObject * obj1 = 0 ;
38832 PyObject * obj2 = 0 ;
38833 PyObject * obj3 = 0 ;
38834 PyObject * obj4 = 0 ;
38835 PyObject * obj5 = 0 ;
38836 char * kwnames[] = {
38837 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38838 };
38839
38840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38842 if (!SWIG_IsOK(res1)) {
38843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38844 }
38845 arg1 = reinterpret_cast< wxMenu * >(argp1);
38846 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38847 if (!SWIG_IsOK(ecode2)) {
38848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38849 }
38850 arg2 = static_cast< size_t >(val2);
38851 ecode3 = SWIG_AsVal_int(obj2, &val3);
38852 if (!SWIG_IsOK(ecode3)) {
38853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38854 }
38855 arg3 = static_cast< int >(val3);
38856 {
38857 arg4 = wxString_in_helper(obj3);
38858 if (arg4 == NULL) SWIG_fail;
38859 temp4 = true;
38860 }
38861 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38862 if (!SWIG_IsOK(res5)) {
38863 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38864 }
38865 arg5 = reinterpret_cast< wxMenu * >(argp5);
38866 if (obj5) {
38867 {
38868 arg6 = wxString_in_helper(obj5);
38869 if (arg6 == NULL) SWIG_fail;
38870 temp6 = true;
38871 }
38872 }
38873 {
38874 PyThreadState* __tstate = wxPyBeginAllowThreads();
38875 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38876 wxPyEndAllowThreads(__tstate);
38877 if (PyErr_Occurred()) SWIG_fail;
38878 }
38879 {
38880 resultobj = wxPyMake_wxObject(result, (bool)0);
38881 }
38882 {
38883 if (temp4)
38884 delete arg4;
38885 }
38886 {
38887 if (temp6)
38888 delete arg6;
38889 }
38890 return resultobj;
38891 fail:
38892 {
38893 if (temp4)
38894 delete arg4;
38895 }
38896 {
38897 if (temp6)
38898 delete arg6;
38899 }
38900 return NULL;
38901 }
38902
38903
38904 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38905 PyObject *resultobj = 0;
38906 wxMenu *arg1 = (wxMenu *) 0 ;
38907 int arg2 ;
38908 wxString *arg3 = 0 ;
38909 wxString const &arg4_defvalue = wxPyEmptyString ;
38910 wxString *arg4 = (wxString *) &arg4_defvalue ;
38911 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38912 wxMenuItem *result = 0 ;
38913 void *argp1 = 0 ;
38914 int res1 = 0 ;
38915 int val2 ;
38916 int ecode2 = 0 ;
38917 bool temp3 = false ;
38918 bool temp4 = false ;
38919 int val5 ;
38920 int ecode5 = 0 ;
38921 PyObject * obj0 = 0 ;
38922 PyObject * obj1 = 0 ;
38923 PyObject * obj2 = 0 ;
38924 PyObject * obj3 = 0 ;
38925 PyObject * obj4 = 0 ;
38926 char * kwnames[] = {
38927 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38928 };
38929
38930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38932 if (!SWIG_IsOK(res1)) {
38933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38934 }
38935 arg1 = reinterpret_cast< wxMenu * >(argp1);
38936 ecode2 = SWIG_AsVal_int(obj1, &val2);
38937 if (!SWIG_IsOK(ecode2)) {
38938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
38939 }
38940 arg2 = static_cast< int >(val2);
38941 {
38942 arg3 = wxString_in_helper(obj2);
38943 if (arg3 == NULL) SWIG_fail;
38944 temp3 = true;
38945 }
38946 if (obj3) {
38947 {
38948 arg4 = wxString_in_helper(obj3);
38949 if (arg4 == NULL) SWIG_fail;
38950 temp4 = true;
38951 }
38952 }
38953 if (obj4) {
38954 ecode5 = SWIG_AsVal_int(obj4, &val5);
38955 if (!SWIG_IsOK(ecode5)) {
38956 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
38957 }
38958 arg5 = static_cast< wxItemKind >(val5);
38959 }
38960 {
38961 PyThreadState* __tstate = wxPyBeginAllowThreads();
38962 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38963 wxPyEndAllowThreads(__tstate);
38964 if (PyErr_Occurred()) SWIG_fail;
38965 }
38966 {
38967 resultobj = wxPyMake_wxObject(result, (bool)0);
38968 }
38969 {
38970 if (temp3)
38971 delete arg3;
38972 }
38973 {
38974 if (temp4)
38975 delete arg4;
38976 }
38977 return resultobj;
38978 fail:
38979 {
38980 if (temp3)
38981 delete arg3;
38982 }
38983 {
38984 if (temp4)
38985 delete arg4;
38986 }
38987 return NULL;
38988 }
38989
38990
38991 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38992 PyObject *resultobj = 0;
38993 wxMenu *arg1 = (wxMenu *) 0 ;
38994 wxMenuItem *result = 0 ;
38995 void *argp1 = 0 ;
38996 int res1 = 0 ;
38997 PyObject *swig_obj[1] ;
38998
38999 if (!args) SWIG_fail;
39000 swig_obj[0] = args;
39001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39002 if (!SWIG_IsOK(res1)) {
39003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39004 }
39005 arg1 = reinterpret_cast< wxMenu * >(argp1);
39006 {
39007 PyThreadState* __tstate = wxPyBeginAllowThreads();
39008 result = (wxMenuItem *)(arg1)->PrependSeparator();
39009 wxPyEndAllowThreads(__tstate);
39010 if (PyErr_Occurred()) SWIG_fail;
39011 }
39012 {
39013 resultobj = wxPyMake_wxObject(result, (bool)0);
39014 }
39015 return resultobj;
39016 fail:
39017 return NULL;
39018 }
39019
39020
39021 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39022 PyObject *resultobj = 0;
39023 wxMenu *arg1 = (wxMenu *) 0 ;
39024 int arg2 ;
39025 wxString *arg3 = 0 ;
39026 wxString const &arg4_defvalue = wxPyEmptyString ;
39027 wxString *arg4 = (wxString *) &arg4_defvalue ;
39028 wxMenuItem *result = 0 ;
39029 void *argp1 = 0 ;
39030 int res1 = 0 ;
39031 int val2 ;
39032 int ecode2 = 0 ;
39033 bool temp3 = false ;
39034 bool temp4 = false ;
39035 PyObject * obj0 = 0 ;
39036 PyObject * obj1 = 0 ;
39037 PyObject * obj2 = 0 ;
39038 PyObject * obj3 = 0 ;
39039 char * kwnames[] = {
39040 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39041 };
39042
39043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39045 if (!SWIG_IsOK(res1)) {
39046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39047 }
39048 arg1 = reinterpret_cast< wxMenu * >(argp1);
39049 ecode2 = SWIG_AsVal_int(obj1, &val2);
39050 if (!SWIG_IsOK(ecode2)) {
39051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39052 }
39053 arg2 = static_cast< int >(val2);
39054 {
39055 arg3 = wxString_in_helper(obj2);
39056 if (arg3 == NULL) SWIG_fail;
39057 temp3 = true;
39058 }
39059 if (obj3) {
39060 {
39061 arg4 = wxString_in_helper(obj3);
39062 if (arg4 == NULL) SWIG_fail;
39063 temp4 = true;
39064 }
39065 }
39066 {
39067 PyThreadState* __tstate = wxPyBeginAllowThreads();
39068 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39069 wxPyEndAllowThreads(__tstate);
39070 if (PyErr_Occurred()) SWIG_fail;
39071 }
39072 {
39073 resultobj = wxPyMake_wxObject(result, (bool)0);
39074 }
39075 {
39076 if (temp3)
39077 delete arg3;
39078 }
39079 {
39080 if (temp4)
39081 delete arg4;
39082 }
39083 return resultobj;
39084 fail:
39085 {
39086 if (temp3)
39087 delete arg3;
39088 }
39089 {
39090 if (temp4)
39091 delete arg4;
39092 }
39093 return NULL;
39094 }
39095
39096
39097 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39098 PyObject *resultobj = 0;
39099 wxMenu *arg1 = (wxMenu *) 0 ;
39100 int arg2 ;
39101 wxString *arg3 = 0 ;
39102 wxString const &arg4_defvalue = wxPyEmptyString ;
39103 wxString *arg4 = (wxString *) &arg4_defvalue ;
39104 wxMenuItem *result = 0 ;
39105 void *argp1 = 0 ;
39106 int res1 = 0 ;
39107 int val2 ;
39108 int ecode2 = 0 ;
39109 bool temp3 = false ;
39110 bool temp4 = false ;
39111 PyObject * obj0 = 0 ;
39112 PyObject * obj1 = 0 ;
39113 PyObject * obj2 = 0 ;
39114 PyObject * obj3 = 0 ;
39115 char * kwnames[] = {
39116 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39117 };
39118
39119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39121 if (!SWIG_IsOK(res1)) {
39122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39123 }
39124 arg1 = reinterpret_cast< wxMenu * >(argp1);
39125 ecode2 = SWIG_AsVal_int(obj1, &val2);
39126 if (!SWIG_IsOK(ecode2)) {
39127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39128 }
39129 arg2 = static_cast< int >(val2);
39130 {
39131 arg3 = wxString_in_helper(obj2);
39132 if (arg3 == NULL) SWIG_fail;
39133 temp3 = true;
39134 }
39135 if (obj3) {
39136 {
39137 arg4 = wxString_in_helper(obj3);
39138 if (arg4 == NULL) SWIG_fail;
39139 temp4 = true;
39140 }
39141 }
39142 {
39143 PyThreadState* __tstate = wxPyBeginAllowThreads();
39144 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39145 wxPyEndAllowThreads(__tstate);
39146 if (PyErr_Occurred()) SWIG_fail;
39147 }
39148 {
39149 resultobj = wxPyMake_wxObject(result, (bool)0);
39150 }
39151 {
39152 if (temp3)
39153 delete arg3;
39154 }
39155 {
39156 if (temp4)
39157 delete arg4;
39158 }
39159 return resultobj;
39160 fail:
39161 {
39162 if (temp3)
39163 delete arg3;
39164 }
39165 {
39166 if (temp4)
39167 delete arg4;
39168 }
39169 return NULL;
39170 }
39171
39172
39173 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39174 PyObject *resultobj = 0;
39175 wxMenu *arg1 = (wxMenu *) 0 ;
39176 int arg2 ;
39177 wxString *arg3 = 0 ;
39178 wxMenu *arg4 = (wxMenu *) 0 ;
39179 wxString const &arg5_defvalue = wxPyEmptyString ;
39180 wxString *arg5 = (wxString *) &arg5_defvalue ;
39181 wxMenuItem *result = 0 ;
39182 void *argp1 = 0 ;
39183 int res1 = 0 ;
39184 int val2 ;
39185 int ecode2 = 0 ;
39186 bool temp3 = false ;
39187 void *argp4 = 0 ;
39188 int res4 = 0 ;
39189 bool temp5 = false ;
39190 PyObject * obj0 = 0 ;
39191 PyObject * obj1 = 0 ;
39192 PyObject * obj2 = 0 ;
39193 PyObject * obj3 = 0 ;
39194 PyObject * obj4 = 0 ;
39195 char * kwnames[] = {
39196 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39197 };
39198
39199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39201 if (!SWIG_IsOK(res1)) {
39202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39203 }
39204 arg1 = reinterpret_cast< wxMenu * >(argp1);
39205 ecode2 = SWIG_AsVal_int(obj1, &val2);
39206 if (!SWIG_IsOK(ecode2)) {
39207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39208 }
39209 arg2 = static_cast< int >(val2);
39210 {
39211 arg3 = wxString_in_helper(obj2);
39212 if (arg3 == NULL) SWIG_fail;
39213 temp3 = true;
39214 }
39215 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39216 if (!SWIG_IsOK(res4)) {
39217 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39218 }
39219 arg4 = reinterpret_cast< wxMenu * >(argp4);
39220 if (obj4) {
39221 {
39222 arg5 = wxString_in_helper(obj4);
39223 if (arg5 == NULL) SWIG_fail;
39224 temp5 = true;
39225 }
39226 }
39227 {
39228 PyThreadState* __tstate = wxPyBeginAllowThreads();
39229 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39230 wxPyEndAllowThreads(__tstate);
39231 if (PyErr_Occurred()) SWIG_fail;
39232 }
39233 {
39234 resultobj = wxPyMake_wxObject(result, (bool)0);
39235 }
39236 {
39237 if (temp3)
39238 delete arg3;
39239 }
39240 {
39241 if (temp5)
39242 delete arg5;
39243 }
39244 return resultobj;
39245 fail:
39246 {
39247 if (temp3)
39248 delete arg3;
39249 }
39250 {
39251 if (temp5)
39252 delete arg5;
39253 }
39254 return NULL;
39255 }
39256
39257
39258 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39259 PyObject *resultobj = 0;
39260 wxMenu *arg1 = (wxMenu *) 0 ;
39261 int arg2 ;
39262 wxMenuItem *result = 0 ;
39263 void *argp1 = 0 ;
39264 int res1 = 0 ;
39265 int val2 ;
39266 int ecode2 = 0 ;
39267 PyObject * obj0 = 0 ;
39268 PyObject * obj1 = 0 ;
39269 char * kwnames[] = {
39270 (char *) "self",(char *) "id", NULL
39271 };
39272
39273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39275 if (!SWIG_IsOK(res1)) {
39276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39277 }
39278 arg1 = reinterpret_cast< wxMenu * >(argp1);
39279 ecode2 = SWIG_AsVal_int(obj1, &val2);
39280 if (!SWIG_IsOK(ecode2)) {
39281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39282 }
39283 arg2 = static_cast< int >(val2);
39284 {
39285 PyThreadState* __tstate = wxPyBeginAllowThreads();
39286 result = (wxMenuItem *)(arg1)->Remove(arg2);
39287 wxPyEndAllowThreads(__tstate);
39288 if (PyErr_Occurred()) SWIG_fail;
39289 }
39290 {
39291 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39292 }
39293 return resultobj;
39294 fail:
39295 return NULL;
39296 }
39297
39298
39299 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39300 PyObject *resultobj = 0;
39301 wxMenu *arg1 = (wxMenu *) 0 ;
39302 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39303 wxMenuItem *result = 0 ;
39304 void *argp1 = 0 ;
39305 int res1 = 0 ;
39306 void *argp2 = 0 ;
39307 int res2 = 0 ;
39308 PyObject * obj0 = 0 ;
39309 PyObject * obj1 = 0 ;
39310 char * kwnames[] = {
39311 (char *) "self",(char *) "item", NULL
39312 };
39313
39314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39316 if (!SWIG_IsOK(res1)) {
39317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39318 }
39319 arg1 = reinterpret_cast< wxMenu * >(argp1);
39320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39321 if (!SWIG_IsOK(res2)) {
39322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39323 }
39324 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 result = (wxMenuItem *)(arg1)->Remove(arg2);
39328 wxPyEndAllowThreads(__tstate);
39329 if (PyErr_Occurred()) SWIG_fail;
39330 }
39331 {
39332 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39333 }
39334 return resultobj;
39335 fail:
39336 return NULL;
39337 }
39338
39339
39340 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39341 PyObject *resultobj = 0;
39342 wxMenu *arg1 = (wxMenu *) 0 ;
39343 int arg2 ;
39344 bool result;
39345 void *argp1 = 0 ;
39346 int res1 = 0 ;
39347 int val2 ;
39348 int ecode2 = 0 ;
39349 PyObject * obj0 = 0 ;
39350 PyObject * obj1 = 0 ;
39351 char * kwnames[] = {
39352 (char *) "self",(char *) "id", NULL
39353 };
39354
39355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39357 if (!SWIG_IsOK(res1)) {
39358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39359 }
39360 arg1 = reinterpret_cast< wxMenu * >(argp1);
39361 ecode2 = SWIG_AsVal_int(obj1, &val2);
39362 if (!SWIG_IsOK(ecode2)) {
39363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39364 }
39365 arg2 = static_cast< int >(val2);
39366 {
39367 PyThreadState* __tstate = wxPyBeginAllowThreads();
39368 result = (bool)(arg1)->Delete(arg2);
39369 wxPyEndAllowThreads(__tstate);
39370 if (PyErr_Occurred()) SWIG_fail;
39371 }
39372 {
39373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39374 }
39375 return resultobj;
39376 fail:
39377 return NULL;
39378 }
39379
39380
39381 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39382 PyObject *resultobj = 0;
39383 wxMenu *arg1 = (wxMenu *) 0 ;
39384 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39385 bool result;
39386 void *argp1 = 0 ;
39387 int res1 = 0 ;
39388 void *argp2 = 0 ;
39389 int res2 = 0 ;
39390 PyObject * obj0 = 0 ;
39391 PyObject * obj1 = 0 ;
39392 char * kwnames[] = {
39393 (char *) "self",(char *) "item", NULL
39394 };
39395
39396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39398 if (!SWIG_IsOK(res1)) {
39399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39400 }
39401 arg1 = reinterpret_cast< wxMenu * >(argp1);
39402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39403 if (!SWIG_IsOK(res2)) {
39404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39405 }
39406 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39407 {
39408 PyThreadState* __tstate = wxPyBeginAllowThreads();
39409 result = (bool)(arg1)->Delete(arg2);
39410 wxPyEndAllowThreads(__tstate);
39411 if (PyErr_Occurred()) SWIG_fail;
39412 }
39413 {
39414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39415 }
39416 return resultobj;
39417 fail:
39418 return NULL;
39419 }
39420
39421
39422 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39423 PyObject *resultobj = 0;
39424 wxMenu *arg1 = (wxMenu *) 0 ;
39425 void *argp1 = 0 ;
39426 int res1 = 0 ;
39427 PyObject *swig_obj[1] ;
39428
39429 if (!args) SWIG_fail;
39430 swig_obj[0] = args;
39431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39432 if (!SWIG_IsOK(res1)) {
39433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39434 }
39435 arg1 = reinterpret_cast< wxMenu * >(argp1);
39436 {
39437 PyThreadState* __tstate = wxPyBeginAllowThreads();
39438 wxMenu_Destroy(arg1);
39439 wxPyEndAllowThreads(__tstate);
39440 if (PyErr_Occurred()) SWIG_fail;
39441 }
39442 resultobj = SWIG_Py_Void();
39443 return resultobj;
39444 fail:
39445 return NULL;
39446 }
39447
39448
39449 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39450 PyObject *resultobj = 0;
39451 wxMenu *arg1 = (wxMenu *) 0 ;
39452 int arg2 ;
39453 bool result;
39454 void *argp1 = 0 ;
39455 int res1 = 0 ;
39456 int val2 ;
39457 int ecode2 = 0 ;
39458 PyObject * obj0 = 0 ;
39459 PyObject * obj1 = 0 ;
39460 char * kwnames[] = {
39461 (char *) "self",(char *) "id", NULL
39462 };
39463
39464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39466 if (!SWIG_IsOK(res1)) {
39467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39468 }
39469 arg1 = reinterpret_cast< wxMenu * >(argp1);
39470 ecode2 = SWIG_AsVal_int(obj1, &val2);
39471 if (!SWIG_IsOK(ecode2)) {
39472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39473 }
39474 arg2 = static_cast< int >(val2);
39475 {
39476 PyThreadState* __tstate = wxPyBeginAllowThreads();
39477 result = (bool)(arg1)->Destroy(arg2);
39478 wxPyEndAllowThreads(__tstate);
39479 if (PyErr_Occurred()) SWIG_fail;
39480 }
39481 {
39482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39483 }
39484 return resultobj;
39485 fail:
39486 return NULL;
39487 }
39488
39489
39490 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39491 PyObject *resultobj = 0;
39492 wxMenu *arg1 = (wxMenu *) 0 ;
39493 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39494 bool result;
39495 void *argp1 = 0 ;
39496 int res1 = 0 ;
39497 void *argp2 = 0 ;
39498 int res2 = 0 ;
39499 PyObject * obj0 = 0 ;
39500 PyObject * obj1 = 0 ;
39501 char * kwnames[] = {
39502 (char *) "self",(char *) "item", NULL
39503 };
39504
39505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39507 if (!SWIG_IsOK(res1)) {
39508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39509 }
39510 arg1 = reinterpret_cast< wxMenu * >(argp1);
39511 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39512 if (!SWIG_IsOK(res2)) {
39513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39514 }
39515 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39516 {
39517 PyThreadState* __tstate = wxPyBeginAllowThreads();
39518 result = (bool)(arg1)->Destroy(arg2);
39519 wxPyEndAllowThreads(__tstate);
39520 if (PyErr_Occurred()) SWIG_fail;
39521 }
39522 {
39523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39524 }
39525 return resultobj;
39526 fail:
39527 return NULL;
39528 }
39529
39530
39531 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39532 PyObject *resultobj = 0;
39533 wxMenu *arg1 = (wxMenu *) 0 ;
39534 size_t result;
39535 void *argp1 = 0 ;
39536 int res1 = 0 ;
39537 PyObject *swig_obj[1] ;
39538
39539 if (!args) SWIG_fail;
39540 swig_obj[0] = args;
39541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39542 if (!SWIG_IsOK(res1)) {
39543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39544 }
39545 arg1 = reinterpret_cast< wxMenu * >(argp1);
39546 {
39547 PyThreadState* __tstate = wxPyBeginAllowThreads();
39548 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39549 wxPyEndAllowThreads(__tstate);
39550 if (PyErr_Occurred()) SWIG_fail;
39551 }
39552 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39553 return resultobj;
39554 fail:
39555 return NULL;
39556 }
39557
39558
39559 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39560 PyObject *resultobj = 0;
39561 wxMenu *arg1 = (wxMenu *) 0 ;
39562 PyObject *result = 0 ;
39563 void *argp1 = 0 ;
39564 int res1 = 0 ;
39565 PyObject *swig_obj[1] ;
39566
39567 if (!args) SWIG_fail;
39568 swig_obj[0] = args;
39569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39570 if (!SWIG_IsOK(res1)) {
39571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39572 }
39573 arg1 = reinterpret_cast< wxMenu * >(argp1);
39574 {
39575 PyThreadState* __tstate = wxPyBeginAllowThreads();
39576 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39577 wxPyEndAllowThreads(__tstate);
39578 if (PyErr_Occurred()) SWIG_fail;
39579 }
39580 resultobj = result;
39581 return resultobj;
39582 fail:
39583 return NULL;
39584 }
39585
39586
39587 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39588 PyObject *resultobj = 0;
39589 wxMenu *arg1 = (wxMenu *) 0 ;
39590 wxString *arg2 = 0 ;
39591 int result;
39592 void *argp1 = 0 ;
39593 int res1 = 0 ;
39594 bool temp2 = false ;
39595 PyObject * obj0 = 0 ;
39596 PyObject * obj1 = 0 ;
39597 char * kwnames[] = {
39598 (char *) "self",(char *) "item", NULL
39599 };
39600
39601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39603 if (!SWIG_IsOK(res1)) {
39604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39605 }
39606 arg1 = reinterpret_cast< wxMenu * >(argp1);
39607 {
39608 arg2 = wxString_in_helper(obj1);
39609 if (arg2 == NULL) SWIG_fail;
39610 temp2 = true;
39611 }
39612 {
39613 PyThreadState* __tstate = wxPyBeginAllowThreads();
39614 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39615 wxPyEndAllowThreads(__tstate);
39616 if (PyErr_Occurred()) SWIG_fail;
39617 }
39618 resultobj = SWIG_From_int(static_cast< int >(result));
39619 {
39620 if (temp2)
39621 delete arg2;
39622 }
39623 return resultobj;
39624 fail:
39625 {
39626 if (temp2)
39627 delete arg2;
39628 }
39629 return NULL;
39630 }
39631
39632
39633 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39634 PyObject *resultobj = 0;
39635 wxMenu *arg1 = (wxMenu *) 0 ;
39636 int arg2 ;
39637 wxMenuItem *result = 0 ;
39638 void *argp1 = 0 ;
39639 int res1 = 0 ;
39640 int val2 ;
39641 int ecode2 = 0 ;
39642 PyObject * obj0 = 0 ;
39643 PyObject * obj1 = 0 ;
39644 char * kwnames[] = {
39645 (char *) "self",(char *) "id", NULL
39646 };
39647
39648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39650 if (!SWIG_IsOK(res1)) {
39651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39652 }
39653 arg1 = reinterpret_cast< wxMenu * >(argp1);
39654 ecode2 = SWIG_AsVal_int(obj1, &val2);
39655 if (!SWIG_IsOK(ecode2)) {
39656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39657 }
39658 arg2 = static_cast< int >(val2);
39659 {
39660 PyThreadState* __tstate = wxPyBeginAllowThreads();
39661 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39662 wxPyEndAllowThreads(__tstate);
39663 if (PyErr_Occurred()) SWIG_fail;
39664 }
39665 {
39666 resultobj = wxPyMake_wxObject(result, (bool)0);
39667 }
39668 return resultobj;
39669 fail:
39670 return NULL;
39671 }
39672
39673
39674 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39675 PyObject *resultobj = 0;
39676 wxMenu *arg1 = (wxMenu *) 0 ;
39677 size_t arg2 ;
39678 wxMenuItem *result = 0 ;
39679 void *argp1 = 0 ;
39680 int res1 = 0 ;
39681 size_t val2 ;
39682 int ecode2 = 0 ;
39683 PyObject * obj0 = 0 ;
39684 PyObject * obj1 = 0 ;
39685 char * kwnames[] = {
39686 (char *) "self",(char *) "position", NULL
39687 };
39688
39689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39691 if (!SWIG_IsOK(res1)) {
39692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39693 }
39694 arg1 = reinterpret_cast< wxMenu * >(argp1);
39695 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39696 if (!SWIG_IsOK(ecode2)) {
39697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39698 }
39699 arg2 = static_cast< size_t >(val2);
39700 {
39701 PyThreadState* __tstate = wxPyBeginAllowThreads();
39702 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39703 wxPyEndAllowThreads(__tstate);
39704 if (PyErr_Occurred()) SWIG_fail;
39705 }
39706 {
39707 resultobj = wxPyMake_wxObject(result, (bool)0);
39708 }
39709 return resultobj;
39710 fail:
39711 return NULL;
39712 }
39713
39714
39715 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39716 PyObject *resultobj = 0;
39717 wxMenu *arg1 = (wxMenu *) 0 ;
39718 int arg2 ;
39719 bool arg3 ;
39720 void *argp1 = 0 ;
39721 int res1 = 0 ;
39722 int val2 ;
39723 int ecode2 = 0 ;
39724 bool val3 ;
39725 int ecode3 = 0 ;
39726 PyObject * obj0 = 0 ;
39727 PyObject * obj1 = 0 ;
39728 PyObject * obj2 = 0 ;
39729 char * kwnames[] = {
39730 (char *) "self",(char *) "id",(char *) "enable", NULL
39731 };
39732
39733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39735 if (!SWIG_IsOK(res1)) {
39736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39737 }
39738 arg1 = reinterpret_cast< wxMenu * >(argp1);
39739 ecode2 = SWIG_AsVal_int(obj1, &val2);
39740 if (!SWIG_IsOK(ecode2)) {
39741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39742 }
39743 arg2 = static_cast< int >(val2);
39744 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39745 if (!SWIG_IsOK(ecode3)) {
39746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39747 }
39748 arg3 = static_cast< bool >(val3);
39749 {
39750 PyThreadState* __tstate = wxPyBeginAllowThreads();
39751 (arg1)->Enable(arg2,arg3);
39752 wxPyEndAllowThreads(__tstate);
39753 if (PyErr_Occurred()) SWIG_fail;
39754 }
39755 resultobj = SWIG_Py_Void();
39756 return resultobj;
39757 fail:
39758 return NULL;
39759 }
39760
39761
39762 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39763 PyObject *resultobj = 0;
39764 wxMenu *arg1 = (wxMenu *) 0 ;
39765 int arg2 ;
39766 bool result;
39767 void *argp1 = 0 ;
39768 int res1 = 0 ;
39769 int val2 ;
39770 int ecode2 = 0 ;
39771 PyObject * obj0 = 0 ;
39772 PyObject * obj1 = 0 ;
39773 char * kwnames[] = {
39774 (char *) "self",(char *) "id", NULL
39775 };
39776
39777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39779 if (!SWIG_IsOK(res1)) {
39780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39781 }
39782 arg1 = reinterpret_cast< wxMenu * >(argp1);
39783 ecode2 = SWIG_AsVal_int(obj1, &val2);
39784 if (!SWIG_IsOK(ecode2)) {
39785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39786 }
39787 arg2 = static_cast< int >(val2);
39788 {
39789 PyThreadState* __tstate = wxPyBeginAllowThreads();
39790 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39791 wxPyEndAllowThreads(__tstate);
39792 if (PyErr_Occurred()) SWIG_fail;
39793 }
39794 {
39795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39796 }
39797 return resultobj;
39798 fail:
39799 return NULL;
39800 }
39801
39802
39803 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39804 PyObject *resultobj = 0;
39805 wxMenu *arg1 = (wxMenu *) 0 ;
39806 int arg2 ;
39807 bool arg3 ;
39808 void *argp1 = 0 ;
39809 int res1 = 0 ;
39810 int val2 ;
39811 int ecode2 = 0 ;
39812 bool val3 ;
39813 int ecode3 = 0 ;
39814 PyObject * obj0 = 0 ;
39815 PyObject * obj1 = 0 ;
39816 PyObject * obj2 = 0 ;
39817 char * kwnames[] = {
39818 (char *) "self",(char *) "id",(char *) "check", NULL
39819 };
39820
39821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) 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_Check" "', 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_Check" "', expected argument " "2"" of type '" "int""'");
39830 }
39831 arg2 = static_cast< int >(val2);
39832 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39833 if (!SWIG_IsOK(ecode3)) {
39834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39835 }
39836 arg3 = static_cast< bool >(val3);
39837 {
39838 PyThreadState* __tstate = wxPyBeginAllowThreads();
39839 (arg1)->Check(arg2,arg3);
39840 wxPyEndAllowThreads(__tstate);
39841 if (PyErr_Occurred()) SWIG_fail;
39842 }
39843 resultobj = SWIG_Py_Void();
39844 return resultobj;
39845 fail:
39846 return NULL;
39847 }
39848
39849
39850 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39851 PyObject *resultobj = 0;
39852 wxMenu *arg1 = (wxMenu *) 0 ;
39853 int arg2 ;
39854 bool result;
39855 void *argp1 = 0 ;
39856 int res1 = 0 ;
39857 int val2 ;
39858 int ecode2 = 0 ;
39859 PyObject * obj0 = 0 ;
39860 PyObject * obj1 = 0 ;
39861 char * kwnames[] = {
39862 (char *) "self",(char *) "id", NULL
39863 };
39864
39865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39867 if (!SWIG_IsOK(res1)) {
39868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39869 }
39870 arg1 = reinterpret_cast< wxMenu * >(argp1);
39871 ecode2 = SWIG_AsVal_int(obj1, &val2);
39872 if (!SWIG_IsOK(ecode2)) {
39873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39874 }
39875 arg2 = static_cast< int >(val2);
39876 {
39877 PyThreadState* __tstate = wxPyBeginAllowThreads();
39878 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39879 wxPyEndAllowThreads(__tstate);
39880 if (PyErr_Occurred()) SWIG_fail;
39881 }
39882 {
39883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39884 }
39885 return resultobj;
39886 fail:
39887 return NULL;
39888 }
39889
39890
39891 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39892 PyObject *resultobj = 0;
39893 wxMenu *arg1 = (wxMenu *) 0 ;
39894 int arg2 ;
39895 wxString *arg3 = 0 ;
39896 void *argp1 = 0 ;
39897 int res1 = 0 ;
39898 int val2 ;
39899 int ecode2 = 0 ;
39900 bool temp3 = false ;
39901 PyObject * obj0 = 0 ;
39902 PyObject * obj1 = 0 ;
39903 PyObject * obj2 = 0 ;
39904 char * kwnames[] = {
39905 (char *) "self",(char *) "id",(char *) "label", NULL
39906 };
39907
39908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39910 if (!SWIG_IsOK(res1)) {
39911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39912 }
39913 arg1 = reinterpret_cast< wxMenu * >(argp1);
39914 ecode2 = SWIG_AsVal_int(obj1, &val2);
39915 if (!SWIG_IsOK(ecode2)) {
39916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39917 }
39918 arg2 = static_cast< int >(val2);
39919 {
39920 arg3 = wxString_in_helper(obj2);
39921 if (arg3 == NULL) SWIG_fail;
39922 temp3 = true;
39923 }
39924 {
39925 PyThreadState* __tstate = wxPyBeginAllowThreads();
39926 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39927 wxPyEndAllowThreads(__tstate);
39928 if (PyErr_Occurred()) SWIG_fail;
39929 }
39930 resultobj = SWIG_Py_Void();
39931 {
39932 if (temp3)
39933 delete arg3;
39934 }
39935 return resultobj;
39936 fail:
39937 {
39938 if (temp3)
39939 delete arg3;
39940 }
39941 return NULL;
39942 }
39943
39944
39945 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39946 PyObject *resultobj = 0;
39947 wxMenu *arg1 = (wxMenu *) 0 ;
39948 int arg2 ;
39949 wxString result;
39950 void *argp1 = 0 ;
39951 int res1 = 0 ;
39952 int val2 ;
39953 int ecode2 = 0 ;
39954 PyObject * obj0 = 0 ;
39955 PyObject * obj1 = 0 ;
39956 char * kwnames[] = {
39957 (char *) "self",(char *) "id", NULL
39958 };
39959
39960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39962 if (!SWIG_IsOK(res1)) {
39963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
39964 }
39965 arg1 = reinterpret_cast< wxMenu * >(argp1);
39966 ecode2 = SWIG_AsVal_int(obj1, &val2);
39967 if (!SWIG_IsOK(ecode2)) {
39968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
39969 }
39970 arg2 = static_cast< int >(val2);
39971 {
39972 PyThreadState* __tstate = wxPyBeginAllowThreads();
39973 result = ((wxMenu const *)arg1)->GetLabel(arg2);
39974 wxPyEndAllowThreads(__tstate);
39975 if (PyErr_Occurred()) SWIG_fail;
39976 }
39977 {
39978 #if wxUSE_UNICODE
39979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39980 #else
39981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39982 #endif
39983 }
39984 return resultobj;
39985 fail:
39986 return NULL;
39987 }
39988
39989
39990 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39991 PyObject *resultobj = 0;
39992 wxMenu *arg1 = (wxMenu *) 0 ;
39993 int arg2 ;
39994 wxString *arg3 = 0 ;
39995 void *argp1 = 0 ;
39996 int res1 = 0 ;
39997 int val2 ;
39998 int ecode2 = 0 ;
39999 bool temp3 = false ;
40000 PyObject * obj0 = 0 ;
40001 PyObject * obj1 = 0 ;
40002 PyObject * obj2 = 0 ;
40003 char * kwnames[] = {
40004 (char *) "self",(char *) "id",(char *) "helpString", NULL
40005 };
40006
40007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40009 if (!SWIG_IsOK(res1)) {
40010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40011 }
40012 arg1 = reinterpret_cast< wxMenu * >(argp1);
40013 ecode2 = SWIG_AsVal_int(obj1, &val2);
40014 if (!SWIG_IsOK(ecode2)) {
40015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40016 }
40017 arg2 = static_cast< int >(val2);
40018 {
40019 arg3 = wxString_in_helper(obj2);
40020 if (arg3 == NULL) SWIG_fail;
40021 temp3 = true;
40022 }
40023 {
40024 PyThreadState* __tstate = wxPyBeginAllowThreads();
40025 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40026 wxPyEndAllowThreads(__tstate);
40027 if (PyErr_Occurred()) SWIG_fail;
40028 }
40029 resultobj = SWIG_Py_Void();
40030 {
40031 if (temp3)
40032 delete arg3;
40033 }
40034 return resultobj;
40035 fail:
40036 {
40037 if (temp3)
40038 delete arg3;
40039 }
40040 return NULL;
40041 }
40042
40043
40044 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40045 PyObject *resultobj = 0;
40046 wxMenu *arg1 = (wxMenu *) 0 ;
40047 int arg2 ;
40048 wxString result;
40049 void *argp1 = 0 ;
40050 int res1 = 0 ;
40051 int val2 ;
40052 int ecode2 = 0 ;
40053 PyObject * obj0 = 0 ;
40054 PyObject * obj1 = 0 ;
40055 char * kwnames[] = {
40056 (char *) "self",(char *) "id", NULL
40057 };
40058
40059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40061 if (!SWIG_IsOK(res1)) {
40062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40063 }
40064 arg1 = reinterpret_cast< wxMenu * >(argp1);
40065 ecode2 = SWIG_AsVal_int(obj1, &val2);
40066 if (!SWIG_IsOK(ecode2)) {
40067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40068 }
40069 arg2 = static_cast< int >(val2);
40070 {
40071 PyThreadState* __tstate = wxPyBeginAllowThreads();
40072 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40073 wxPyEndAllowThreads(__tstate);
40074 if (PyErr_Occurred()) SWIG_fail;
40075 }
40076 {
40077 #if wxUSE_UNICODE
40078 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40079 #else
40080 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40081 #endif
40082 }
40083 return resultobj;
40084 fail:
40085 return NULL;
40086 }
40087
40088
40089 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40090 PyObject *resultobj = 0;
40091 wxMenu *arg1 = (wxMenu *) 0 ;
40092 wxString *arg2 = 0 ;
40093 void *argp1 = 0 ;
40094 int res1 = 0 ;
40095 bool temp2 = false ;
40096 PyObject * obj0 = 0 ;
40097 PyObject * obj1 = 0 ;
40098 char * kwnames[] = {
40099 (char *) "self",(char *) "title", NULL
40100 };
40101
40102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40104 if (!SWIG_IsOK(res1)) {
40105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40106 }
40107 arg1 = reinterpret_cast< wxMenu * >(argp1);
40108 {
40109 arg2 = wxString_in_helper(obj1);
40110 if (arg2 == NULL) SWIG_fail;
40111 temp2 = true;
40112 }
40113 {
40114 PyThreadState* __tstate = wxPyBeginAllowThreads();
40115 (arg1)->SetTitle((wxString const &)*arg2);
40116 wxPyEndAllowThreads(__tstate);
40117 if (PyErr_Occurred()) SWIG_fail;
40118 }
40119 resultobj = SWIG_Py_Void();
40120 {
40121 if (temp2)
40122 delete arg2;
40123 }
40124 return resultobj;
40125 fail:
40126 {
40127 if (temp2)
40128 delete arg2;
40129 }
40130 return NULL;
40131 }
40132
40133
40134 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40135 PyObject *resultobj = 0;
40136 wxMenu *arg1 = (wxMenu *) 0 ;
40137 wxString result;
40138 void *argp1 = 0 ;
40139 int res1 = 0 ;
40140 PyObject *swig_obj[1] ;
40141
40142 if (!args) SWIG_fail;
40143 swig_obj[0] = args;
40144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40145 if (!SWIG_IsOK(res1)) {
40146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40147 }
40148 arg1 = reinterpret_cast< wxMenu * >(argp1);
40149 {
40150 PyThreadState* __tstate = wxPyBeginAllowThreads();
40151 result = ((wxMenu const *)arg1)->GetTitle();
40152 wxPyEndAllowThreads(__tstate);
40153 if (PyErr_Occurred()) SWIG_fail;
40154 }
40155 {
40156 #if wxUSE_UNICODE
40157 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40158 #else
40159 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40160 #endif
40161 }
40162 return resultobj;
40163 fail:
40164 return NULL;
40165 }
40166
40167
40168 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40169 PyObject *resultobj = 0;
40170 wxMenu *arg1 = (wxMenu *) 0 ;
40171 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40172 void *argp1 = 0 ;
40173 int res1 = 0 ;
40174 void *argp2 = 0 ;
40175 int res2 = 0 ;
40176 PyObject * obj0 = 0 ;
40177 PyObject * obj1 = 0 ;
40178 char * kwnames[] = {
40179 (char *) "self",(char *) "handler", NULL
40180 };
40181
40182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40184 if (!SWIG_IsOK(res1)) {
40185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40186 }
40187 arg1 = reinterpret_cast< wxMenu * >(argp1);
40188 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40189 if (!SWIG_IsOK(res2)) {
40190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40191 }
40192 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40193 {
40194 PyThreadState* __tstate = wxPyBeginAllowThreads();
40195 (arg1)->SetEventHandler(arg2);
40196 wxPyEndAllowThreads(__tstate);
40197 if (PyErr_Occurred()) SWIG_fail;
40198 }
40199 resultobj = SWIG_Py_Void();
40200 return resultobj;
40201 fail:
40202 return NULL;
40203 }
40204
40205
40206 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40207 PyObject *resultobj = 0;
40208 wxMenu *arg1 = (wxMenu *) 0 ;
40209 wxEvtHandler *result = 0 ;
40210 void *argp1 = 0 ;
40211 int res1 = 0 ;
40212 PyObject *swig_obj[1] ;
40213
40214 if (!args) SWIG_fail;
40215 swig_obj[0] = args;
40216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40217 if (!SWIG_IsOK(res1)) {
40218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40219 }
40220 arg1 = reinterpret_cast< wxMenu * >(argp1);
40221 {
40222 PyThreadState* __tstate = wxPyBeginAllowThreads();
40223 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40224 wxPyEndAllowThreads(__tstate);
40225 if (PyErr_Occurred()) SWIG_fail;
40226 }
40227 {
40228 resultobj = wxPyMake_wxObject(result, 0);
40229 }
40230 return resultobj;
40231 fail:
40232 return NULL;
40233 }
40234
40235
40236 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40237 PyObject *resultobj = 0;
40238 wxMenu *arg1 = (wxMenu *) 0 ;
40239 wxWindow *arg2 = (wxWindow *) 0 ;
40240 void *argp1 = 0 ;
40241 int res1 = 0 ;
40242 void *argp2 = 0 ;
40243 int res2 = 0 ;
40244 PyObject * obj0 = 0 ;
40245 PyObject * obj1 = 0 ;
40246 char * kwnames[] = {
40247 (char *) "self",(char *) "win", NULL
40248 };
40249
40250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40252 if (!SWIG_IsOK(res1)) {
40253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40254 }
40255 arg1 = reinterpret_cast< wxMenu * >(argp1);
40256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40257 if (!SWIG_IsOK(res2)) {
40258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40259 }
40260 arg2 = reinterpret_cast< wxWindow * >(argp2);
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 (arg1)->SetInvokingWindow(arg2);
40264 wxPyEndAllowThreads(__tstate);
40265 if (PyErr_Occurred()) SWIG_fail;
40266 }
40267 resultobj = SWIG_Py_Void();
40268 return resultobj;
40269 fail:
40270 return NULL;
40271 }
40272
40273
40274 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40275 PyObject *resultobj = 0;
40276 wxMenu *arg1 = (wxMenu *) 0 ;
40277 wxWindow *result = 0 ;
40278 void *argp1 = 0 ;
40279 int res1 = 0 ;
40280 PyObject *swig_obj[1] ;
40281
40282 if (!args) SWIG_fail;
40283 swig_obj[0] = args;
40284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40285 if (!SWIG_IsOK(res1)) {
40286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40287 }
40288 arg1 = reinterpret_cast< wxMenu * >(argp1);
40289 {
40290 PyThreadState* __tstate = wxPyBeginAllowThreads();
40291 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40292 wxPyEndAllowThreads(__tstate);
40293 if (PyErr_Occurred()) SWIG_fail;
40294 }
40295 {
40296 resultobj = wxPyMake_wxObject(result, 0);
40297 }
40298 return resultobj;
40299 fail:
40300 return NULL;
40301 }
40302
40303
40304 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40305 PyObject *resultobj = 0;
40306 wxMenu *arg1 = (wxMenu *) 0 ;
40307 long result;
40308 void *argp1 = 0 ;
40309 int res1 = 0 ;
40310 PyObject *swig_obj[1] ;
40311
40312 if (!args) SWIG_fail;
40313 swig_obj[0] = args;
40314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40315 if (!SWIG_IsOK(res1)) {
40316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40317 }
40318 arg1 = reinterpret_cast< wxMenu * >(argp1);
40319 {
40320 PyThreadState* __tstate = wxPyBeginAllowThreads();
40321 result = (long)((wxMenu const *)arg1)->GetStyle();
40322 wxPyEndAllowThreads(__tstate);
40323 if (PyErr_Occurred()) SWIG_fail;
40324 }
40325 resultobj = SWIG_From_long(static_cast< long >(result));
40326 return resultobj;
40327 fail:
40328 return NULL;
40329 }
40330
40331
40332 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40333 PyObject *resultobj = 0;
40334 wxMenu *arg1 = (wxMenu *) 0 ;
40335 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40336 void *argp1 = 0 ;
40337 int res1 = 0 ;
40338 void *argp2 = 0 ;
40339 int res2 = 0 ;
40340 PyObject * obj0 = 0 ;
40341 PyObject * obj1 = 0 ;
40342 char * kwnames[] = {
40343 (char *) "self",(char *) "source", NULL
40344 };
40345
40346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40348 if (!SWIG_IsOK(res1)) {
40349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40350 }
40351 arg1 = reinterpret_cast< wxMenu * >(argp1);
40352 if (obj1) {
40353 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40354 if (!SWIG_IsOK(res2)) {
40355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40356 }
40357 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40358 }
40359 {
40360 PyThreadState* __tstate = wxPyBeginAllowThreads();
40361 (arg1)->UpdateUI(arg2);
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 resultobj = SWIG_Py_Void();
40366 return resultobj;
40367 fail:
40368 return NULL;
40369 }
40370
40371
40372 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40373 PyObject *resultobj = 0;
40374 wxMenu *arg1 = (wxMenu *) 0 ;
40375 wxMenuBar *result = 0 ;
40376 void *argp1 = 0 ;
40377 int res1 = 0 ;
40378 PyObject *swig_obj[1] ;
40379
40380 if (!args) SWIG_fail;
40381 swig_obj[0] = args;
40382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40383 if (!SWIG_IsOK(res1)) {
40384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40385 }
40386 arg1 = reinterpret_cast< wxMenu * >(argp1);
40387 {
40388 PyThreadState* __tstate = wxPyBeginAllowThreads();
40389 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40390 wxPyEndAllowThreads(__tstate);
40391 if (PyErr_Occurred()) SWIG_fail;
40392 }
40393 {
40394 resultobj = wxPyMake_wxObject(result, (bool)0);
40395 }
40396 return resultobj;
40397 fail:
40398 return NULL;
40399 }
40400
40401
40402 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40403 PyObject *resultobj = 0;
40404 wxMenu *arg1 = (wxMenu *) 0 ;
40405 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40406 void *argp1 = 0 ;
40407 int res1 = 0 ;
40408 void *argp2 = 0 ;
40409 int res2 = 0 ;
40410 PyObject * obj0 = 0 ;
40411 PyObject * obj1 = 0 ;
40412 char * kwnames[] = {
40413 (char *) "self",(char *) "menubar", NULL
40414 };
40415
40416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40418 if (!SWIG_IsOK(res1)) {
40419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40420 }
40421 arg1 = reinterpret_cast< wxMenu * >(argp1);
40422 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40423 if (!SWIG_IsOK(res2)) {
40424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40425 }
40426 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40427 {
40428 PyThreadState* __tstate = wxPyBeginAllowThreads();
40429 (arg1)->Attach(arg2);
40430 wxPyEndAllowThreads(__tstate);
40431 if (PyErr_Occurred()) SWIG_fail;
40432 }
40433 resultobj = SWIG_Py_Void();
40434 return resultobj;
40435 fail:
40436 return NULL;
40437 }
40438
40439
40440 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40441 PyObject *resultobj = 0;
40442 wxMenu *arg1 = (wxMenu *) 0 ;
40443 void *argp1 = 0 ;
40444 int res1 = 0 ;
40445 PyObject *swig_obj[1] ;
40446
40447 if (!args) SWIG_fail;
40448 swig_obj[0] = args;
40449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40450 if (!SWIG_IsOK(res1)) {
40451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40452 }
40453 arg1 = reinterpret_cast< wxMenu * >(argp1);
40454 {
40455 PyThreadState* __tstate = wxPyBeginAllowThreads();
40456 (arg1)->Detach();
40457 wxPyEndAllowThreads(__tstate);
40458 if (PyErr_Occurred()) SWIG_fail;
40459 }
40460 resultobj = SWIG_Py_Void();
40461 return resultobj;
40462 fail:
40463 return NULL;
40464 }
40465
40466
40467 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40468 PyObject *resultobj = 0;
40469 wxMenu *arg1 = (wxMenu *) 0 ;
40470 bool result;
40471 void *argp1 = 0 ;
40472 int res1 = 0 ;
40473 PyObject *swig_obj[1] ;
40474
40475 if (!args) SWIG_fail;
40476 swig_obj[0] = args;
40477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40478 if (!SWIG_IsOK(res1)) {
40479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40480 }
40481 arg1 = reinterpret_cast< wxMenu * >(argp1);
40482 {
40483 PyThreadState* __tstate = wxPyBeginAllowThreads();
40484 result = (bool)((wxMenu const *)arg1)->IsAttached();
40485 wxPyEndAllowThreads(__tstate);
40486 if (PyErr_Occurred()) SWIG_fail;
40487 }
40488 {
40489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40490 }
40491 return resultobj;
40492 fail:
40493 return NULL;
40494 }
40495
40496
40497 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40498 PyObject *resultobj = 0;
40499 wxMenu *arg1 = (wxMenu *) 0 ;
40500 wxMenu *arg2 = (wxMenu *) 0 ;
40501 void *argp1 = 0 ;
40502 int res1 = 0 ;
40503 void *argp2 = 0 ;
40504 int res2 = 0 ;
40505 PyObject * obj0 = 0 ;
40506 PyObject * obj1 = 0 ;
40507 char * kwnames[] = {
40508 (char *) "self",(char *) "parent", NULL
40509 };
40510
40511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40513 if (!SWIG_IsOK(res1)) {
40514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40515 }
40516 arg1 = reinterpret_cast< wxMenu * >(argp1);
40517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40518 if (!SWIG_IsOK(res2)) {
40519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40520 }
40521 arg2 = reinterpret_cast< wxMenu * >(argp2);
40522 {
40523 PyThreadState* __tstate = wxPyBeginAllowThreads();
40524 (arg1)->SetParent(arg2);
40525 wxPyEndAllowThreads(__tstate);
40526 if (PyErr_Occurred()) SWIG_fail;
40527 }
40528 resultobj = SWIG_Py_Void();
40529 return resultobj;
40530 fail:
40531 return NULL;
40532 }
40533
40534
40535 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40536 PyObject *resultobj = 0;
40537 wxMenu *arg1 = (wxMenu *) 0 ;
40538 wxMenu *result = 0 ;
40539 void *argp1 = 0 ;
40540 int res1 = 0 ;
40541 PyObject *swig_obj[1] ;
40542
40543 if (!args) SWIG_fail;
40544 swig_obj[0] = args;
40545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40546 if (!SWIG_IsOK(res1)) {
40547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40548 }
40549 arg1 = reinterpret_cast< wxMenu * >(argp1);
40550 {
40551 PyThreadState* __tstate = wxPyBeginAllowThreads();
40552 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40553 wxPyEndAllowThreads(__tstate);
40554 if (PyErr_Occurred()) SWIG_fail;
40555 }
40556 {
40557 resultobj = wxPyMake_wxObject(result, 0);
40558 }
40559 return resultobj;
40560 fail:
40561 return NULL;
40562 }
40563
40564
40565 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40566 PyObject *obj;
40567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40568 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40569 return SWIG_Py_Void();
40570 }
40571
40572 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40573 return SWIG_Python_InitShadowInstance(args);
40574 }
40575
40576 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40577 PyObject *resultobj = 0;
40578 long arg1 = (long) 0 ;
40579 wxMenuBar *result = 0 ;
40580 long val1 ;
40581 int ecode1 = 0 ;
40582 PyObject * obj0 = 0 ;
40583 char * kwnames[] = {
40584 (char *) "style", NULL
40585 };
40586
40587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40588 if (obj0) {
40589 ecode1 = SWIG_AsVal_long(obj0, &val1);
40590 if (!SWIG_IsOK(ecode1)) {
40591 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40592 }
40593 arg1 = static_cast< long >(val1);
40594 }
40595 {
40596 if (!wxPyCheckForApp()) SWIG_fail;
40597 PyThreadState* __tstate = wxPyBeginAllowThreads();
40598 result = (wxMenuBar *)new wxMenuBar(arg1);
40599 wxPyEndAllowThreads(__tstate);
40600 if (PyErr_Occurred()) SWIG_fail;
40601 }
40602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40603 return resultobj;
40604 fail:
40605 return NULL;
40606 }
40607
40608
40609 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40610 PyObject *resultobj = 0;
40611 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40612 wxMenu *arg2 = (wxMenu *) 0 ;
40613 wxString *arg3 = 0 ;
40614 bool result;
40615 void *argp1 = 0 ;
40616 int res1 = 0 ;
40617 void *argp2 = 0 ;
40618 int res2 = 0 ;
40619 bool temp3 = false ;
40620 PyObject * obj0 = 0 ;
40621 PyObject * obj1 = 0 ;
40622 PyObject * obj2 = 0 ;
40623 char * kwnames[] = {
40624 (char *) "self",(char *) "menu",(char *) "title", NULL
40625 };
40626
40627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40629 if (!SWIG_IsOK(res1)) {
40630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40631 }
40632 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40633 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40634 if (!SWIG_IsOK(res2)) {
40635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40636 }
40637 arg2 = reinterpret_cast< wxMenu * >(argp2);
40638 {
40639 arg3 = wxString_in_helper(obj2);
40640 if (arg3 == NULL) SWIG_fail;
40641 temp3 = true;
40642 }
40643 {
40644 PyThreadState* __tstate = wxPyBeginAllowThreads();
40645 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40646 wxPyEndAllowThreads(__tstate);
40647 if (PyErr_Occurred()) SWIG_fail;
40648 }
40649 {
40650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40651 }
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_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40667 PyObject *resultobj = 0;
40668 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40669 size_t arg2 ;
40670 wxMenu *arg3 = (wxMenu *) 0 ;
40671 wxString *arg4 = 0 ;
40672 bool result;
40673 void *argp1 = 0 ;
40674 int res1 = 0 ;
40675 size_t val2 ;
40676 int ecode2 = 0 ;
40677 void *argp3 = 0 ;
40678 int res3 = 0 ;
40679 bool temp4 = false ;
40680 PyObject * obj0 = 0 ;
40681 PyObject * obj1 = 0 ;
40682 PyObject * obj2 = 0 ;
40683 PyObject * obj3 = 0 ;
40684 char * kwnames[] = {
40685 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40686 };
40687
40688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40690 if (!SWIG_IsOK(res1)) {
40691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40692 }
40693 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40694 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40695 if (!SWIG_IsOK(ecode2)) {
40696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40697 }
40698 arg2 = static_cast< size_t >(val2);
40699 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40700 if (!SWIG_IsOK(res3)) {
40701 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40702 }
40703 arg3 = reinterpret_cast< wxMenu * >(argp3);
40704 {
40705 arg4 = wxString_in_helper(obj3);
40706 if (arg4 == NULL) SWIG_fail;
40707 temp4 = true;
40708 }
40709 {
40710 PyThreadState* __tstate = wxPyBeginAllowThreads();
40711 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40712 wxPyEndAllowThreads(__tstate);
40713 if (PyErr_Occurred()) SWIG_fail;
40714 }
40715 {
40716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40717 }
40718 {
40719 if (temp4)
40720 delete arg4;
40721 }
40722 return resultobj;
40723 fail:
40724 {
40725 if (temp4)
40726 delete arg4;
40727 }
40728 return NULL;
40729 }
40730
40731
40732 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40733 PyObject *resultobj = 0;
40734 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40735 size_t result;
40736 void *argp1 = 0 ;
40737 int res1 = 0 ;
40738 PyObject *swig_obj[1] ;
40739
40740 if (!args) SWIG_fail;
40741 swig_obj[0] = args;
40742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40743 if (!SWIG_IsOK(res1)) {
40744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40745 }
40746 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40747 {
40748 PyThreadState* __tstate = wxPyBeginAllowThreads();
40749 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40750 wxPyEndAllowThreads(__tstate);
40751 if (PyErr_Occurred()) SWIG_fail;
40752 }
40753 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40754 return resultobj;
40755 fail:
40756 return NULL;
40757 }
40758
40759
40760 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40761 PyObject *resultobj = 0;
40762 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40763 size_t arg2 ;
40764 wxMenu *result = 0 ;
40765 void *argp1 = 0 ;
40766 int res1 = 0 ;
40767 size_t val2 ;
40768 int ecode2 = 0 ;
40769 PyObject * obj0 = 0 ;
40770 PyObject * obj1 = 0 ;
40771 char * kwnames[] = {
40772 (char *) "self",(char *) "pos", NULL
40773 };
40774
40775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40777 if (!SWIG_IsOK(res1)) {
40778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40779 }
40780 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40781 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40782 if (!SWIG_IsOK(ecode2)) {
40783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40784 }
40785 arg2 = static_cast< size_t >(val2);
40786 {
40787 PyThreadState* __tstate = wxPyBeginAllowThreads();
40788 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40789 wxPyEndAllowThreads(__tstate);
40790 if (PyErr_Occurred()) SWIG_fail;
40791 }
40792 {
40793 resultobj = wxPyMake_wxObject(result, 0);
40794 }
40795 return resultobj;
40796 fail:
40797 return NULL;
40798 }
40799
40800
40801 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40802 PyObject *resultobj = 0;
40803 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40804 size_t arg2 ;
40805 wxMenu *arg3 = (wxMenu *) 0 ;
40806 wxString *arg4 = 0 ;
40807 wxMenu *result = 0 ;
40808 void *argp1 = 0 ;
40809 int res1 = 0 ;
40810 size_t val2 ;
40811 int ecode2 = 0 ;
40812 void *argp3 = 0 ;
40813 int res3 = 0 ;
40814 bool temp4 = false ;
40815 PyObject * obj0 = 0 ;
40816 PyObject * obj1 = 0 ;
40817 PyObject * obj2 = 0 ;
40818 PyObject * obj3 = 0 ;
40819 char * kwnames[] = {
40820 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40821 };
40822
40823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40825 if (!SWIG_IsOK(res1)) {
40826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40827 }
40828 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40829 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40830 if (!SWIG_IsOK(ecode2)) {
40831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40832 }
40833 arg2 = static_cast< size_t >(val2);
40834 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40835 if (!SWIG_IsOK(res3)) {
40836 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40837 }
40838 arg3 = reinterpret_cast< wxMenu * >(argp3);
40839 {
40840 arg4 = wxString_in_helper(obj3);
40841 if (arg4 == NULL) SWIG_fail;
40842 temp4 = true;
40843 }
40844 {
40845 PyThreadState* __tstate = wxPyBeginAllowThreads();
40846 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40847 wxPyEndAllowThreads(__tstate);
40848 if (PyErr_Occurred()) SWIG_fail;
40849 }
40850 {
40851 resultobj = wxPyMake_wxObject(result, 0);
40852 }
40853 {
40854 if (temp4)
40855 delete arg4;
40856 }
40857 return resultobj;
40858 fail:
40859 {
40860 if (temp4)
40861 delete arg4;
40862 }
40863 return NULL;
40864 }
40865
40866
40867 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40868 PyObject *resultobj = 0;
40869 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40870 size_t arg2 ;
40871 wxMenu *result = 0 ;
40872 void *argp1 = 0 ;
40873 int res1 = 0 ;
40874 size_t val2 ;
40875 int ecode2 = 0 ;
40876 PyObject * obj0 = 0 ;
40877 PyObject * obj1 = 0 ;
40878 char * kwnames[] = {
40879 (char *) "self",(char *) "pos", NULL
40880 };
40881
40882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40884 if (!SWIG_IsOK(res1)) {
40885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40886 }
40887 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40888 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40889 if (!SWIG_IsOK(ecode2)) {
40890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40891 }
40892 arg2 = static_cast< size_t >(val2);
40893 {
40894 PyThreadState* __tstate = wxPyBeginAllowThreads();
40895 result = (wxMenu *)(arg1)->Remove(arg2);
40896 wxPyEndAllowThreads(__tstate);
40897 if (PyErr_Occurred()) SWIG_fail;
40898 }
40899 {
40900 resultobj = wxPyMake_wxObject(result, 0);
40901 }
40902 return resultobj;
40903 fail:
40904 return NULL;
40905 }
40906
40907
40908 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40909 PyObject *resultobj = 0;
40910 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40911 size_t arg2 ;
40912 bool arg3 ;
40913 void *argp1 = 0 ;
40914 int res1 = 0 ;
40915 size_t val2 ;
40916 int ecode2 = 0 ;
40917 bool val3 ;
40918 int ecode3 = 0 ;
40919 PyObject * obj0 = 0 ;
40920 PyObject * obj1 = 0 ;
40921 PyObject * obj2 = 0 ;
40922 char * kwnames[] = {
40923 (char *) "self",(char *) "pos",(char *) "enable", NULL
40924 };
40925
40926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40928 if (!SWIG_IsOK(res1)) {
40929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40930 }
40931 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40932 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40933 if (!SWIG_IsOK(ecode2)) {
40934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40935 }
40936 arg2 = static_cast< size_t >(val2);
40937 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40938 if (!SWIG_IsOK(ecode3)) {
40939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
40940 }
40941 arg3 = static_cast< bool >(val3);
40942 {
40943 PyThreadState* __tstate = wxPyBeginAllowThreads();
40944 (arg1)->EnableTop(arg2,arg3);
40945 wxPyEndAllowThreads(__tstate);
40946 if (PyErr_Occurred()) SWIG_fail;
40947 }
40948 resultobj = SWIG_Py_Void();
40949 return resultobj;
40950 fail:
40951 return NULL;
40952 }
40953
40954
40955 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40956 PyObject *resultobj = 0;
40957 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40958 size_t arg2 ;
40959 bool result;
40960 void *argp1 = 0 ;
40961 int res1 = 0 ;
40962 size_t val2 ;
40963 int ecode2 = 0 ;
40964 PyObject * obj0 = 0 ;
40965 PyObject * obj1 = 0 ;
40966 char * kwnames[] = {
40967 (char *) "self",(char *) "pos", NULL
40968 };
40969
40970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
40971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40972 if (!SWIG_IsOK(res1)) {
40973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40974 }
40975 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40976 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40977 if (!SWIG_IsOK(ecode2)) {
40978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
40979 }
40980 arg2 = static_cast< size_t >(val2);
40981 {
40982 PyThreadState* __tstate = wxPyBeginAllowThreads();
40983 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
40984 wxPyEndAllowThreads(__tstate);
40985 if (PyErr_Occurred()) SWIG_fail;
40986 }
40987 {
40988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40989 }
40990 return resultobj;
40991 fail:
40992 return NULL;
40993 }
40994
40995
40996 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40997 PyObject *resultobj = 0;
40998 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40999 size_t arg2 ;
41000 wxString *arg3 = 0 ;
41001 void *argp1 = 0 ;
41002 int res1 = 0 ;
41003 size_t val2 ;
41004 int ecode2 = 0 ;
41005 bool temp3 = false ;
41006 PyObject * obj0 = 0 ;
41007 PyObject * obj1 = 0 ;
41008 PyObject * obj2 = 0 ;
41009 char * kwnames[] = {
41010 (char *) "self",(char *) "pos",(char *) "label", NULL
41011 };
41012
41013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41015 if (!SWIG_IsOK(res1)) {
41016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41017 }
41018 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41019 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41020 if (!SWIG_IsOK(ecode2)) {
41021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41022 }
41023 arg2 = static_cast< size_t >(val2);
41024 {
41025 arg3 = wxString_in_helper(obj2);
41026 if (arg3 == NULL) SWIG_fail;
41027 temp3 = true;
41028 }
41029 {
41030 PyThreadState* __tstate = wxPyBeginAllowThreads();
41031 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41032 wxPyEndAllowThreads(__tstate);
41033 if (PyErr_Occurred()) SWIG_fail;
41034 }
41035 resultobj = SWIG_Py_Void();
41036 {
41037 if (temp3)
41038 delete arg3;
41039 }
41040 return resultobj;
41041 fail:
41042 {
41043 if (temp3)
41044 delete arg3;
41045 }
41046 return NULL;
41047 }
41048
41049
41050 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41051 PyObject *resultobj = 0;
41052 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41053 size_t arg2 ;
41054 wxString result;
41055 void *argp1 = 0 ;
41056 int res1 = 0 ;
41057 size_t val2 ;
41058 int ecode2 = 0 ;
41059 PyObject * obj0 = 0 ;
41060 PyObject * obj1 = 0 ;
41061 char * kwnames[] = {
41062 (char *) "self",(char *) "pos", NULL
41063 };
41064
41065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41067 if (!SWIG_IsOK(res1)) {
41068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41069 }
41070 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41071 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41072 if (!SWIG_IsOK(ecode2)) {
41073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41074 }
41075 arg2 = static_cast< size_t >(val2);
41076 {
41077 PyThreadState* __tstate = wxPyBeginAllowThreads();
41078 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41079 wxPyEndAllowThreads(__tstate);
41080 if (PyErr_Occurred()) SWIG_fail;
41081 }
41082 {
41083 #if wxUSE_UNICODE
41084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41085 #else
41086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41087 #endif
41088 }
41089 return resultobj;
41090 fail:
41091 return NULL;
41092 }
41093
41094
41095 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41096 PyObject *resultobj = 0;
41097 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41098 wxString *arg2 = 0 ;
41099 wxString *arg3 = 0 ;
41100 int result;
41101 void *argp1 = 0 ;
41102 int res1 = 0 ;
41103 bool temp2 = false ;
41104 bool temp3 = false ;
41105 PyObject * obj0 = 0 ;
41106 PyObject * obj1 = 0 ;
41107 PyObject * obj2 = 0 ;
41108 char * kwnames[] = {
41109 (char *) "self",(char *) "menu",(char *) "item", NULL
41110 };
41111
41112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41114 if (!SWIG_IsOK(res1)) {
41115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41116 }
41117 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41118 {
41119 arg2 = wxString_in_helper(obj1);
41120 if (arg2 == NULL) SWIG_fail;
41121 temp2 = true;
41122 }
41123 {
41124 arg3 = wxString_in_helper(obj2);
41125 if (arg3 == NULL) SWIG_fail;
41126 temp3 = true;
41127 }
41128 {
41129 PyThreadState* __tstate = wxPyBeginAllowThreads();
41130 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41131 wxPyEndAllowThreads(__tstate);
41132 if (PyErr_Occurred()) SWIG_fail;
41133 }
41134 resultobj = SWIG_From_int(static_cast< int >(result));
41135 {
41136 if (temp2)
41137 delete arg2;
41138 }
41139 {
41140 if (temp3)
41141 delete arg3;
41142 }
41143 return resultobj;
41144 fail:
41145 {
41146 if (temp2)
41147 delete arg2;
41148 }
41149 {
41150 if (temp3)
41151 delete arg3;
41152 }
41153 return NULL;
41154 }
41155
41156
41157 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41158 PyObject *resultobj = 0;
41159 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41160 int arg2 ;
41161 wxMenuItem *result = 0 ;
41162 void *argp1 = 0 ;
41163 int res1 = 0 ;
41164 int val2 ;
41165 int ecode2 = 0 ;
41166 PyObject * obj0 = 0 ;
41167 PyObject * obj1 = 0 ;
41168 char * kwnames[] = {
41169 (char *) "self",(char *) "id", NULL
41170 };
41171
41172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41174 if (!SWIG_IsOK(res1)) {
41175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41176 }
41177 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41178 ecode2 = SWIG_AsVal_int(obj1, &val2);
41179 if (!SWIG_IsOK(ecode2)) {
41180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41181 }
41182 arg2 = static_cast< int >(val2);
41183 {
41184 PyThreadState* __tstate = wxPyBeginAllowThreads();
41185 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41186 wxPyEndAllowThreads(__tstate);
41187 if (PyErr_Occurred()) SWIG_fail;
41188 }
41189 {
41190 resultobj = wxPyMake_wxObject(result, (bool)0);
41191 }
41192 return resultobj;
41193 fail:
41194 return NULL;
41195 }
41196
41197
41198 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41199 PyObject *resultobj = 0;
41200 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41201 wxString *arg2 = 0 ;
41202 int result;
41203 void *argp1 = 0 ;
41204 int res1 = 0 ;
41205 bool temp2 = false ;
41206 PyObject * obj0 = 0 ;
41207 PyObject * obj1 = 0 ;
41208 char * kwnames[] = {
41209 (char *) "self",(char *) "title", NULL
41210 };
41211
41212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41214 if (!SWIG_IsOK(res1)) {
41215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41216 }
41217 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41218 {
41219 arg2 = wxString_in_helper(obj1);
41220 if (arg2 == NULL) SWIG_fail;
41221 temp2 = true;
41222 }
41223 {
41224 PyThreadState* __tstate = wxPyBeginAllowThreads();
41225 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41226 wxPyEndAllowThreads(__tstate);
41227 if (PyErr_Occurred()) SWIG_fail;
41228 }
41229 resultobj = SWIG_From_int(static_cast< int >(result));
41230 {
41231 if (temp2)
41232 delete arg2;
41233 }
41234 return resultobj;
41235 fail:
41236 {
41237 if (temp2)
41238 delete arg2;
41239 }
41240 return NULL;
41241 }
41242
41243
41244 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41245 PyObject *resultobj = 0;
41246 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41247 int arg2 ;
41248 bool arg3 ;
41249 void *argp1 = 0 ;
41250 int res1 = 0 ;
41251 int val2 ;
41252 int ecode2 = 0 ;
41253 bool val3 ;
41254 int ecode3 = 0 ;
41255 PyObject * obj0 = 0 ;
41256 PyObject * obj1 = 0 ;
41257 PyObject * obj2 = 0 ;
41258 char * kwnames[] = {
41259 (char *) "self",(char *) "id",(char *) "enable", NULL
41260 };
41261
41262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41264 if (!SWIG_IsOK(res1)) {
41265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41266 }
41267 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41268 ecode2 = SWIG_AsVal_int(obj1, &val2);
41269 if (!SWIG_IsOK(ecode2)) {
41270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41271 }
41272 arg2 = static_cast< int >(val2);
41273 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41274 if (!SWIG_IsOK(ecode3)) {
41275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41276 }
41277 arg3 = static_cast< bool >(val3);
41278 {
41279 PyThreadState* __tstate = wxPyBeginAllowThreads();
41280 (arg1)->Enable(arg2,arg3);
41281 wxPyEndAllowThreads(__tstate);
41282 if (PyErr_Occurred()) SWIG_fail;
41283 }
41284 resultobj = SWIG_Py_Void();
41285 return resultobj;
41286 fail:
41287 return NULL;
41288 }
41289
41290
41291 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41292 PyObject *resultobj = 0;
41293 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41294 int arg2 ;
41295 bool arg3 ;
41296 void *argp1 = 0 ;
41297 int res1 = 0 ;
41298 int val2 ;
41299 int ecode2 = 0 ;
41300 bool val3 ;
41301 int ecode3 = 0 ;
41302 PyObject * obj0 = 0 ;
41303 PyObject * obj1 = 0 ;
41304 PyObject * obj2 = 0 ;
41305 char * kwnames[] = {
41306 (char *) "self",(char *) "id",(char *) "check", NULL
41307 };
41308
41309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41311 if (!SWIG_IsOK(res1)) {
41312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41313 }
41314 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41315 ecode2 = SWIG_AsVal_int(obj1, &val2);
41316 if (!SWIG_IsOK(ecode2)) {
41317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41318 }
41319 arg2 = static_cast< int >(val2);
41320 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41321 if (!SWIG_IsOK(ecode3)) {
41322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41323 }
41324 arg3 = static_cast< bool >(val3);
41325 {
41326 PyThreadState* __tstate = wxPyBeginAllowThreads();
41327 (arg1)->Check(arg2,arg3);
41328 wxPyEndAllowThreads(__tstate);
41329 if (PyErr_Occurred()) SWIG_fail;
41330 }
41331 resultobj = SWIG_Py_Void();
41332 return resultobj;
41333 fail:
41334 return NULL;
41335 }
41336
41337
41338 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41339 PyObject *resultobj = 0;
41340 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41341 int arg2 ;
41342 bool result;
41343 void *argp1 = 0 ;
41344 int res1 = 0 ;
41345 int val2 ;
41346 int ecode2 = 0 ;
41347 PyObject * obj0 = 0 ;
41348 PyObject * obj1 = 0 ;
41349 char * kwnames[] = {
41350 (char *) "self",(char *) "id", NULL
41351 };
41352
41353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41355 if (!SWIG_IsOK(res1)) {
41356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41357 }
41358 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41359 ecode2 = SWIG_AsVal_int(obj1, &val2);
41360 if (!SWIG_IsOK(ecode2)) {
41361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41362 }
41363 arg2 = static_cast< int >(val2);
41364 {
41365 PyThreadState* __tstate = wxPyBeginAllowThreads();
41366 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41367 wxPyEndAllowThreads(__tstate);
41368 if (PyErr_Occurred()) SWIG_fail;
41369 }
41370 {
41371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41372 }
41373 return resultobj;
41374 fail:
41375 return NULL;
41376 }
41377
41378
41379 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41380 PyObject *resultobj = 0;
41381 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41382 int arg2 ;
41383 bool result;
41384 void *argp1 = 0 ;
41385 int res1 = 0 ;
41386 int val2 ;
41387 int ecode2 = 0 ;
41388 PyObject * obj0 = 0 ;
41389 PyObject * obj1 = 0 ;
41390 char * kwnames[] = {
41391 (char *) "self",(char *) "id", NULL
41392 };
41393
41394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41396 if (!SWIG_IsOK(res1)) {
41397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41398 }
41399 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41400 ecode2 = SWIG_AsVal_int(obj1, &val2);
41401 if (!SWIG_IsOK(ecode2)) {
41402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41403 }
41404 arg2 = static_cast< int >(val2);
41405 {
41406 PyThreadState* __tstate = wxPyBeginAllowThreads();
41407 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41408 wxPyEndAllowThreads(__tstate);
41409 if (PyErr_Occurred()) SWIG_fail;
41410 }
41411 {
41412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41413 }
41414 return resultobj;
41415 fail:
41416 return NULL;
41417 }
41418
41419
41420 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41421 PyObject *resultobj = 0;
41422 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41423 int arg2 ;
41424 wxString *arg3 = 0 ;
41425 void *argp1 = 0 ;
41426 int res1 = 0 ;
41427 int val2 ;
41428 int ecode2 = 0 ;
41429 bool temp3 = false ;
41430 PyObject * obj0 = 0 ;
41431 PyObject * obj1 = 0 ;
41432 PyObject * obj2 = 0 ;
41433 char * kwnames[] = {
41434 (char *) "self",(char *) "id",(char *) "label", NULL
41435 };
41436
41437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41439 if (!SWIG_IsOK(res1)) {
41440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41441 }
41442 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41443 ecode2 = SWIG_AsVal_int(obj1, &val2);
41444 if (!SWIG_IsOK(ecode2)) {
41445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41446 }
41447 arg2 = static_cast< int >(val2);
41448 {
41449 arg3 = wxString_in_helper(obj2);
41450 if (arg3 == NULL) SWIG_fail;
41451 temp3 = true;
41452 }
41453 {
41454 PyThreadState* __tstate = wxPyBeginAllowThreads();
41455 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41456 wxPyEndAllowThreads(__tstate);
41457 if (PyErr_Occurred()) SWIG_fail;
41458 }
41459 resultobj = SWIG_Py_Void();
41460 {
41461 if (temp3)
41462 delete arg3;
41463 }
41464 return resultobj;
41465 fail:
41466 {
41467 if (temp3)
41468 delete arg3;
41469 }
41470 return NULL;
41471 }
41472
41473
41474 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41475 PyObject *resultobj = 0;
41476 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41477 int arg2 ;
41478 wxString result;
41479 void *argp1 = 0 ;
41480 int res1 = 0 ;
41481 int val2 ;
41482 int ecode2 = 0 ;
41483 PyObject * obj0 = 0 ;
41484 PyObject * obj1 = 0 ;
41485 char * kwnames[] = {
41486 (char *) "self",(char *) "id", NULL
41487 };
41488
41489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41491 if (!SWIG_IsOK(res1)) {
41492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41493 }
41494 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41495 ecode2 = SWIG_AsVal_int(obj1, &val2);
41496 if (!SWIG_IsOK(ecode2)) {
41497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41498 }
41499 arg2 = static_cast< int >(val2);
41500 {
41501 PyThreadState* __tstate = wxPyBeginAllowThreads();
41502 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41503 wxPyEndAllowThreads(__tstate);
41504 if (PyErr_Occurred()) SWIG_fail;
41505 }
41506 {
41507 #if wxUSE_UNICODE
41508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41509 #else
41510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41511 #endif
41512 }
41513 return resultobj;
41514 fail:
41515 return NULL;
41516 }
41517
41518
41519 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41520 PyObject *resultobj = 0;
41521 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41522 int arg2 ;
41523 wxString *arg3 = 0 ;
41524 void *argp1 = 0 ;
41525 int res1 = 0 ;
41526 int val2 ;
41527 int ecode2 = 0 ;
41528 bool temp3 = false ;
41529 PyObject * obj0 = 0 ;
41530 PyObject * obj1 = 0 ;
41531 PyObject * obj2 = 0 ;
41532 char * kwnames[] = {
41533 (char *) "self",(char *) "id",(char *) "helpString", NULL
41534 };
41535
41536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41538 if (!SWIG_IsOK(res1)) {
41539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41540 }
41541 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41542 ecode2 = SWIG_AsVal_int(obj1, &val2);
41543 if (!SWIG_IsOK(ecode2)) {
41544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41545 }
41546 arg2 = static_cast< int >(val2);
41547 {
41548 arg3 = wxString_in_helper(obj2);
41549 if (arg3 == NULL) SWIG_fail;
41550 temp3 = true;
41551 }
41552 {
41553 PyThreadState* __tstate = wxPyBeginAllowThreads();
41554 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41555 wxPyEndAllowThreads(__tstate);
41556 if (PyErr_Occurred()) SWIG_fail;
41557 }
41558 resultobj = SWIG_Py_Void();
41559 {
41560 if (temp3)
41561 delete arg3;
41562 }
41563 return resultobj;
41564 fail:
41565 {
41566 if (temp3)
41567 delete arg3;
41568 }
41569 return NULL;
41570 }
41571
41572
41573 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41574 PyObject *resultobj = 0;
41575 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41576 int arg2 ;
41577 wxString result;
41578 void *argp1 = 0 ;
41579 int res1 = 0 ;
41580 int val2 ;
41581 int ecode2 = 0 ;
41582 PyObject * obj0 = 0 ;
41583 PyObject * obj1 = 0 ;
41584 char * kwnames[] = {
41585 (char *) "self",(char *) "id", NULL
41586 };
41587
41588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41590 if (!SWIG_IsOK(res1)) {
41591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41592 }
41593 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41594 ecode2 = SWIG_AsVal_int(obj1, &val2);
41595 if (!SWIG_IsOK(ecode2)) {
41596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41597 }
41598 arg2 = static_cast< int >(val2);
41599 {
41600 PyThreadState* __tstate = wxPyBeginAllowThreads();
41601 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41602 wxPyEndAllowThreads(__tstate);
41603 if (PyErr_Occurred()) SWIG_fail;
41604 }
41605 {
41606 #if wxUSE_UNICODE
41607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41608 #else
41609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41610 #endif
41611 }
41612 return resultobj;
41613 fail:
41614 return NULL;
41615 }
41616
41617
41618 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41619 PyObject *resultobj = 0;
41620 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41621 wxFrame *result = 0 ;
41622 void *argp1 = 0 ;
41623 int res1 = 0 ;
41624 PyObject *swig_obj[1] ;
41625
41626 if (!args) SWIG_fail;
41627 swig_obj[0] = args;
41628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41629 if (!SWIG_IsOK(res1)) {
41630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41631 }
41632 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41633 {
41634 PyThreadState* __tstate = wxPyBeginAllowThreads();
41635 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41636 wxPyEndAllowThreads(__tstate);
41637 if (PyErr_Occurred()) SWIG_fail;
41638 }
41639 {
41640 resultobj = wxPyMake_wxObject(result, (bool)0);
41641 }
41642 return resultobj;
41643 fail:
41644 return NULL;
41645 }
41646
41647
41648 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41649 PyObject *resultobj = 0;
41650 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41651 bool result;
41652 void *argp1 = 0 ;
41653 int res1 = 0 ;
41654 PyObject *swig_obj[1] ;
41655
41656 if (!args) SWIG_fail;
41657 swig_obj[0] = args;
41658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41659 if (!SWIG_IsOK(res1)) {
41660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41661 }
41662 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41663 {
41664 PyThreadState* __tstate = wxPyBeginAllowThreads();
41665 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41666 wxPyEndAllowThreads(__tstate);
41667 if (PyErr_Occurred()) SWIG_fail;
41668 }
41669 {
41670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41671 }
41672 return resultobj;
41673 fail:
41674 return NULL;
41675 }
41676
41677
41678 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41679 PyObject *resultobj = 0;
41680 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41681 wxFrame *arg2 = (wxFrame *) 0 ;
41682 void *argp1 = 0 ;
41683 int res1 = 0 ;
41684 void *argp2 = 0 ;
41685 int res2 = 0 ;
41686 PyObject * obj0 = 0 ;
41687 PyObject * obj1 = 0 ;
41688 char * kwnames[] = {
41689 (char *) "self",(char *) "frame", NULL
41690 };
41691
41692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41694 if (!SWIG_IsOK(res1)) {
41695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41696 }
41697 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41698 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41699 if (!SWIG_IsOK(res2)) {
41700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41701 }
41702 arg2 = reinterpret_cast< wxFrame * >(argp2);
41703 {
41704 PyThreadState* __tstate = wxPyBeginAllowThreads();
41705 (arg1)->Attach(arg2);
41706 wxPyEndAllowThreads(__tstate);
41707 if (PyErr_Occurred()) SWIG_fail;
41708 }
41709 resultobj = SWIG_Py_Void();
41710 return resultobj;
41711 fail:
41712 return NULL;
41713 }
41714
41715
41716 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41717 PyObject *resultobj = 0;
41718 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41719 void *argp1 = 0 ;
41720 int res1 = 0 ;
41721 PyObject *swig_obj[1] ;
41722
41723 if (!args) SWIG_fail;
41724 swig_obj[0] = args;
41725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41726 if (!SWIG_IsOK(res1)) {
41727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41728 }
41729 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41730 {
41731 PyThreadState* __tstate = wxPyBeginAllowThreads();
41732 (arg1)->Detach();
41733 wxPyEndAllowThreads(__tstate);
41734 if (PyErr_Occurred()) SWIG_fail;
41735 }
41736 resultobj = SWIG_Py_Void();
41737 return resultobj;
41738 fail:
41739 return NULL;
41740 }
41741
41742
41743 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41744 PyObject *resultobj = 0;
41745 bool arg1 ;
41746 bool val1 ;
41747 int ecode1 = 0 ;
41748 PyObject * obj0 = 0 ;
41749 char * kwnames[] = {
41750 (char *) "enable", NULL
41751 };
41752
41753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41754 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41755 if (!SWIG_IsOK(ecode1)) {
41756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41757 }
41758 arg1 = static_cast< bool >(val1);
41759 {
41760 PyThreadState* __tstate = wxPyBeginAllowThreads();
41761 wxMenuBar_SetAutoWindowMenu(arg1);
41762 wxPyEndAllowThreads(__tstate);
41763 if (PyErr_Occurred()) SWIG_fail;
41764 }
41765 resultobj = SWIG_Py_Void();
41766 return resultobj;
41767 fail:
41768 return NULL;
41769 }
41770
41771
41772 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41773 PyObject *resultobj = 0;
41774 bool result;
41775
41776 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41777 {
41778 PyThreadState* __tstate = wxPyBeginAllowThreads();
41779 result = (bool)wxMenuBar_GetAutoWindowMenu();
41780 wxPyEndAllowThreads(__tstate);
41781 if (PyErr_Occurred()) SWIG_fail;
41782 }
41783 {
41784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41785 }
41786 return resultobj;
41787 fail:
41788 return NULL;
41789 }
41790
41791
41792 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41793 PyObject *obj;
41794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41795 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41796 return SWIG_Py_Void();
41797 }
41798
41799 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41800 return SWIG_Python_InitShadowInstance(args);
41801 }
41802
41803 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41804 PyObject *resultobj = 0;
41805 wxMenu *arg1 = (wxMenu *) NULL ;
41806 int arg2 = (int) wxID_ANY ;
41807 wxString const &arg3_defvalue = wxPyEmptyString ;
41808 wxString *arg3 = (wxString *) &arg3_defvalue ;
41809 wxString const &arg4_defvalue = wxPyEmptyString ;
41810 wxString *arg4 = (wxString *) &arg4_defvalue ;
41811 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41812 wxMenu *arg6 = (wxMenu *) NULL ;
41813 wxMenuItem *result = 0 ;
41814 void *argp1 = 0 ;
41815 int res1 = 0 ;
41816 int val2 ;
41817 int ecode2 = 0 ;
41818 bool temp3 = false ;
41819 bool temp4 = false ;
41820 int val5 ;
41821 int ecode5 = 0 ;
41822 void *argp6 = 0 ;
41823 int res6 = 0 ;
41824 PyObject * obj0 = 0 ;
41825 PyObject * obj1 = 0 ;
41826 PyObject * obj2 = 0 ;
41827 PyObject * obj3 = 0 ;
41828 PyObject * obj4 = 0 ;
41829 PyObject * obj5 = 0 ;
41830 char * kwnames[] = {
41831 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41832 };
41833
41834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41835 if (obj0) {
41836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41837 if (!SWIG_IsOK(res1)) {
41838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41839 }
41840 arg1 = reinterpret_cast< wxMenu * >(argp1);
41841 }
41842 if (obj1) {
41843 ecode2 = SWIG_AsVal_int(obj1, &val2);
41844 if (!SWIG_IsOK(ecode2)) {
41845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41846 }
41847 arg2 = static_cast< int >(val2);
41848 }
41849 if (obj2) {
41850 {
41851 arg3 = wxString_in_helper(obj2);
41852 if (arg3 == NULL) SWIG_fail;
41853 temp3 = true;
41854 }
41855 }
41856 if (obj3) {
41857 {
41858 arg4 = wxString_in_helper(obj3);
41859 if (arg4 == NULL) SWIG_fail;
41860 temp4 = true;
41861 }
41862 }
41863 if (obj4) {
41864 ecode5 = SWIG_AsVal_int(obj4, &val5);
41865 if (!SWIG_IsOK(ecode5)) {
41866 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41867 }
41868 arg5 = static_cast< wxItemKind >(val5);
41869 }
41870 if (obj5) {
41871 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41872 if (!SWIG_IsOK(res6)) {
41873 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41874 }
41875 arg6 = reinterpret_cast< wxMenu * >(argp6);
41876 }
41877 {
41878 PyThreadState* __tstate = wxPyBeginAllowThreads();
41879 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41880 wxPyEndAllowThreads(__tstate);
41881 if (PyErr_Occurred()) SWIG_fail;
41882 }
41883 {
41884 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41885 }
41886 {
41887 if (temp3)
41888 delete arg3;
41889 }
41890 {
41891 if (temp4)
41892 delete arg4;
41893 }
41894 return resultobj;
41895 fail:
41896 {
41897 if (temp3)
41898 delete arg3;
41899 }
41900 {
41901 if (temp4)
41902 delete arg4;
41903 }
41904 return NULL;
41905 }
41906
41907
41908 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41909 PyObject *resultobj = 0;
41910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41911 void *argp1 = 0 ;
41912 int res1 = 0 ;
41913 PyObject *swig_obj[1] ;
41914
41915 if (!args) SWIG_fail;
41916 swig_obj[0] = args;
41917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41918 if (!SWIG_IsOK(res1)) {
41919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41920 }
41921 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41922 {
41923 PyThreadState* __tstate = wxPyBeginAllowThreads();
41924 delete arg1;
41925
41926 wxPyEndAllowThreads(__tstate);
41927 if (PyErr_Occurred()) SWIG_fail;
41928 }
41929 resultobj = SWIG_Py_Void();
41930 return resultobj;
41931 fail:
41932 return NULL;
41933 }
41934
41935
41936 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41937 PyObject *resultobj = 0;
41938 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41939 wxMenu *result = 0 ;
41940 void *argp1 = 0 ;
41941 int res1 = 0 ;
41942 PyObject *swig_obj[1] ;
41943
41944 if (!args) SWIG_fail;
41945 swig_obj[0] = args;
41946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41947 if (!SWIG_IsOK(res1)) {
41948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41949 }
41950 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41951 {
41952 PyThreadState* __tstate = wxPyBeginAllowThreads();
41953 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
41954 wxPyEndAllowThreads(__tstate);
41955 if (PyErr_Occurred()) SWIG_fail;
41956 }
41957 {
41958 resultobj = wxPyMake_wxObject(result, 0);
41959 }
41960 return resultobj;
41961 fail:
41962 return NULL;
41963 }
41964
41965
41966 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41967 PyObject *resultobj = 0;
41968 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41969 wxMenu *arg2 = (wxMenu *) 0 ;
41970 void *argp1 = 0 ;
41971 int res1 = 0 ;
41972 void *argp2 = 0 ;
41973 int res2 = 0 ;
41974 PyObject * obj0 = 0 ;
41975 PyObject * obj1 = 0 ;
41976 char * kwnames[] = {
41977 (char *) "self",(char *) "menu", NULL
41978 };
41979
41980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41982 if (!SWIG_IsOK(res1)) {
41983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41984 }
41985 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41987 if (!SWIG_IsOK(res2)) {
41988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
41989 }
41990 arg2 = reinterpret_cast< wxMenu * >(argp2);
41991 {
41992 PyThreadState* __tstate = wxPyBeginAllowThreads();
41993 (arg1)->SetMenu(arg2);
41994 wxPyEndAllowThreads(__tstate);
41995 if (PyErr_Occurred()) SWIG_fail;
41996 }
41997 resultobj = SWIG_Py_Void();
41998 return resultobj;
41999 fail:
42000 return NULL;
42001 }
42002
42003
42004 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42005 PyObject *resultobj = 0;
42006 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42007 int arg2 ;
42008 void *argp1 = 0 ;
42009 int res1 = 0 ;
42010 int val2 ;
42011 int ecode2 = 0 ;
42012 PyObject * obj0 = 0 ;
42013 PyObject * obj1 = 0 ;
42014 char * kwnames[] = {
42015 (char *) "self",(char *) "id", NULL
42016 };
42017
42018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42020 if (!SWIG_IsOK(res1)) {
42021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42022 }
42023 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42024 ecode2 = SWIG_AsVal_int(obj1, &val2);
42025 if (!SWIG_IsOK(ecode2)) {
42026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42027 }
42028 arg2 = static_cast< int >(val2);
42029 {
42030 PyThreadState* __tstate = wxPyBeginAllowThreads();
42031 (arg1)->SetId(arg2);
42032 wxPyEndAllowThreads(__tstate);
42033 if (PyErr_Occurred()) SWIG_fail;
42034 }
42035 resultobj = SWIG_Py_Void();
42036 return resultobj;
42037 fail:
42038 return NULL;
42039 }
42040
42041
42042 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42043 PyObject *resultobj = 0;
42044 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42045 int result;
42046 void *argp1 = 0 ;
42047 int res1 = 0 ;
42048 PyObject *swig_obj[1] ;
42049
42050 if (!args) SWIG_fail;
42051 swig_obj[0] = args;
42052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42053 if (!SWIG_IsOK(res1)) {
42054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42055 }
42056 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42057 {
42058 PyThreadState* __tstate = wxPyBeginAllowThreads();
42059 result = (int)((wxMenuItem const *)arg1)->GetId();
42060 wxPyEndAllowThreads(__tstate);
42061 if (PyErr_Occurred()) SWIG_fail;
42062 }
42063 resultobj = SWIG_From_int(static_cast< int >(result));
42064 return resultobj;
42065 fail:
42066 return NULL;
42067 }
42068
42069
42070 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42071 PyObject *resultobj = 0;
42072 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42073 bool result;
42074 void *argp1 = 0 ;
42075 int res1 = 0 ;
42076 PyObject *swig_obj[1] ;
42077
42078 if (!args) SWIG_fail;
42079 swig_obj[0] = args;
42080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42081 if (!SWIG_IsOK(res1)) {
42082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42083 }
42084 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42085 {
42086 PyThreadState* __tstate = wxPyBeginAllowThreads();
42087 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42088 wxPyEndAllowThreads(__tstate);
42089 if (PyErr_Occurred()) SWIG_fail;
42090 }
42091 {
42092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42093 }
42094 return resultobj;
42095 fail:
42096 return NULL;
42097 }
42098
42099
42100 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42101 PyObject *resultobj = 0;
42102 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42103 wxString *arg2 = 0 ;
42104 void *argp1 = 0 ;
42105 int res1 = 0 ;
42106 bool temp2 = false ;
42107 PyObject * obj0 = 0 ;
42108 PyObject * obj1 = 0 ;
42109 char * kwnames[] = {
42110 (char *) "self",(char *) "str", NULL
42111 };
42112
42113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42115 if (!SWIG_IsOK(res1)) {
42116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42117 }
42118 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42119 {
42120 arg2 = wxString_in_helper(obj1);
42121 if (arg2 == NULL) SWIG_fail;
42122 temp2 = true;
42123 }
42124 {
42125 PyThreadState* __tstate = wxPyBeginAllowThreads();
42126 (arg1)->SetText((wxString const &)*arg2);
42127 wxPyEndAllowThreads(__tstate);
42128 if (PyErr_Occurred()) SWIG_fail;
42129 }
42130 resultobj = SWIG_Py_Void();
42131 {
42132 if (temp2)
42133 delete arg2;
42134 }
42135 return resultobj;
42136 fail:
42137 {
42138 if (temp2)
42139 delete arg2;
42140 }
42141 return NULL;
42142 }
42143
42144
42145 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42146 PyObject *resultobj = 0;
42147 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42148 wxString result;
42149 void *argp1 = 0 ;
42150 int res1 = 0 ;
42151 PyObject *swig_obj[1] ;
42152
42153 if (!args) SWIG_fail;
42154 swig_obj[0] = args;
42155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42156 if (!SWIG_IsOK(res1)) {
42157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42158 }
42159 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42160 {
42161 PyThreadState* __tstate = wxPyBeginAllowThreads();
42162 result = ((wxMenuItem const *)arg1)->GetLabel();
42163 wxPyEndAllowThreads(__tstate);
42164 if (PyErr_Occurred()) SWIG_fail;
42165 }
42166 {
42167 #if wxUSE_UNICODE
42168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42169 #else
42170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42171 #endif
42172 }
42173 return resultobj;
42174 fail:
42175 return NULL;
42176 }
42177
42178
42179 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42180 PyObject *resultobj = 0;
42181 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42182 wxString *result = 0 ;
42183 void *argp1 = 0 ;
42184 int res1 = 0 ;
42185 PyObject *swig_obj[1] ;
42186
42187 if (!args) SWIG_fail;
42188 swig_obj[0] = args;
42189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42190 if (!SWIG_IsOK(res1)) {
42191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42192 }
42193 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42194 {
42195 PyThreadState* __tstate = wxPyBeginAllowThreads();
42196 {
42197 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42198 result = (wxString *) &_result_ref;
42199 }
42200 wxPyEndAllowThreads(__tstate);
42201 if (PyErr_Occurred()) SWIG_fail;
42202 }
42203 {
42204 #if wxUSE_UNICODE
42205 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42206 #else
42207 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42208 #endif
42209 }
42210 return resultobj;
42211 fail:
42212 return NULL;
42213 }
42214
42215
42216 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42217 PyObject *resultobj = 0;
42218 wxString *arg1 = 0 ;
42219 wxString result;
42220 bool temp1 = false ;
42221 PyObject * obj0 = 0 ;
42222 char * kwnames[] = {
42223 (char *) "text", NULL
42224 };
42225
42226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42227 {
42228 arg1 = wxString_in_helper(obj0);
42229 if (arg1 == NULL) SWIG_fail;
42230 temp1 = true;
42231 }
42232 {
42233 PyThreadState* __tstate = wxPyBeginAllowThreads();
42234 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42235 wxPyEndAllowThreads(__tstate);
42236 if (PyErr_Occurred()) SWIG_fail;
42237 }
42238 {
42239 #if wxUSE_UNICODE
42240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42241 #else
42242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42243 #endif
42244 }
42245 {
42246 if (temp1)
42247 delete arg1;
42248 }
42249 return resultobj;
42250 fail:
42251 {
42252 if (temp1)
42253 delete arg1;
42254 }
42255 return NULL;
42256 }
42257
42258
42259 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42260 PyObject *resultobj = 0;
42261 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42262 wxItemKind result;
42263 void *argp1 = 0 ;
42264 int res1 = 0 ;
42265 PyObject *swig_obj[1] ;
42266
42267 if (!args) SWIG_fail;
42268 swig_obj[0] = args;
42269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42270 if (!SWIG_IsOK(res1)) {
42271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42272 }
42273 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42274 {
42275 PyThreadState* __tstate = wxPyBeginAllowThreads();
42276 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42277 wxPyEndAllowThreads(__tstate);
42278 if (PyErr_Occurred()) SWIG_fail;
42279 }
42280 resultobj = SWIG_From_int(static_cast< int >(result));
42281 return resultobj;
42282 fail:
42283 return NULL;
42284 }
42285
42286
42287 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42288 PyObject *resultobj = 0;
42289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42290 wxItemKind arg2 ;
42291 void *argp1 = 0 ;
42292 int res1 = 0 ;
42293 int val2 ;
42294 int ecode2 = 0 ;
42295 PyObject * obj0 = 0 ;
42296 PyObject * obj1 = 0 ;
42297 char * kwnames[] = {
42298 (char *) "self",(char *) "kind", NULL
42299 };
42300
42301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42303 if (!SWIG_IsOK(res1)) {
42304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42305 }
42306 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42307 ecode2 = SWIG_AsVal_int(obj1, &val2);
42308 if (!SWIG_IsOK(ecode2)) {
42309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42310 }
42311 arg2 = static_cast< wxItemKind >(val2);
42312 {
42313 PyThreadState* __tstate = wxPyBeginAllowThreads();
42314 (arg1)->SetKind(arg2);
42315 wxPyEndAllowThreads(__tstate);
42316 if (PyErr_Occurred()) SWIG_fail;
42317 }
42318 resultobj = SWIG_Py_Void();
42319 return resultobj;
42320 fail:
42321 return NULL;
42322 }
42323
42324
42325 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42326 PyObject *resultobj = 0;
42327 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42328 bool arg2 ;
42329 void *argp1 = 0 ;
42330 int res1 = 0 ;
42331 bool val2 ;
42332 int ecode2 = 0 ;
42333 PyObject * obj0 = 0 ;
42334 PyObject * obj1 = 0 ;
42335 char * kwnames[] = {
42336 (char *) "self",(char *) "checkable", NULL
42337 };
42338
42339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42341 if (!SWIG_IsOK(res1)) {
42342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42343 }
42344 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42345 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42346 if (!SWIG_IsOK(ecode2)) {
42347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42348 }
42349 arg2 = static_cast< bool >(val2);
42350 {
42351 PyThreadState* __tstate = wxPyBeginAllowThreads();
42352 (arg1)->SetCheckable(arg2);
42353 wxPyEndAllowThreads(__tstate);
42354 if (PyErr_Occurred()) SWIG_fail;
42355 }
42356 resultobj = SWIG_Py_Void();
42357 return resultobj;
42358 fail:
42359 return NULL;
42360 }
42361
42362
42363 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42364 PyObject *resultobj = 0;
42365 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42366 bool result;
42367 void *argp1 = 0 ;
42368 int res1 = 0 ;
42369 PyObject *swig_obj[1] ;
42370
42371 if (!args) SWIG_fail;
42372 swig_obj[0] = args;
42373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42374 if (!SWIG_IsOK(res1)) {
42375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42376 }
42377 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42378 {
42379 PyThreadState* __tstate = wxPyBeginAllowThreads();
42380 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42381 wxPyEndAllowThreads(__tstate);
42382 if (PyErr_Occurred()) SWIG_fail;
42383 }
42384 {
42385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42386 }
42387 return resultobj;
42388 fail:
42389 return NULL;
42390 }
42391
42392
42393 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42394 PyObject *resultobj = 0;
42395 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42396 bool result;
42397 void *argp1 = 0 ;
42398 int res1 = 0 ;
42399 PyObject *swig_obj[1] ;
42400
42401 if (!args) SWIG_fail;
42402 swig_obj[0] = args;
42403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42404 if (!SWIG_IsOK(res1)) {
42405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42406 }
42407 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42408 {
42409 PyThreadState* __tstate = wxPyBeginAllowThreads();
42410 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42411 wxPyEndAllowThreads(__tstate);
42412 if (PyErr_Occurred()) SWIG_fail;
42413 }
42414 {
42415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42416 }
42417 return resultobj;
42418 fail:
42419 return NULL;
42420 }
42421
42422
42423 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42424 PyObject *resultobj = 0;
42425 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42426 wxMenu *arg2 = (wxMenu *) 0 ;
42427 void *argp1 = 0 ;
42428 int res1 = 0 ;
42429 void *argp2 = 0 ;
42430 int res2 = 0 ;
42431 PyObject * obj0 = 0 ;
42432 PyObject * obj1 = 0 ;
42433 char * kwnames[] = {
42434 (char *) "self",(char *) "menu", NULL
42435 };
42436
42437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42439 if (!SWIG_IsOK(res1)) {
42440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42441 }
42442 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42443 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42444 if (!SWIG_IsOK(res2)) {
42445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42446 }
42447 arg2 = reinterpret_cast< wxMenu * >(argp2);
42448 {
42449 PyThreadState* __tstate = wxPyBeginAllowThreads();
42450 (arg1)->SetSubMenu(arg2);
42451 wxPyEndAllowThreads(__tstate);
42452 if (PyErr_Occurred()) SWIG_fail;
42453 }
42454 resultobj = SWIG_Py_Void();
42455 return resultobj;
42456 fail:
42457 return NULL;
42458 }
42459
42460
42461 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42462 PyObject *resultobj = 0;
42463 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42464 wxMenu *result = 0 ;
42465 void *argp1 = 0 ;
42466 int res1 = 0 ;
42467 PyObject *swig_obj[1] ;
42468
42469 if (!args) SWIG_fail;
42470 swig_obj[0] = args;
42471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42472 if (!SWIG_IsOK(res1)) {
42473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42474 }
42475 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42476 {
42477 PyThreadState* __tstate = wxPyBeginAllowThreads();
42478 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42479 wxPyEndAllowThreads(__tstate);
42480 if (PyErr_Occurred()) SWIG_fail;
42481 }
42482 {
42483 resultobj = wxPyMake_wxObject(result, 0);
42484 }
42485 return resultobj;
42486 fail:
42487 return NULL;
42488 }
42489
42490
42491 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42492 PyObject *resultobj = 0;
42493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42494 bool arg2 = (bool) true ;
42495 void *argp1 = 0 ;
42496 int res1 = 0 ;
42497 bool val2 ;
42498 int ecode2 = 0 ;
42499 PyObject * obj0 = 0 ;
42500 PyObject * obj1 = 0 ;
42501 char * kwnames[] = {
42502 (char *) "self",(char *) "enable", NULL
42503 };
42504
42505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42507 if (!SWIG_IsOK(res1)) {
42508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42509 }
42510 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42511 if (obj1) {
42512 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42513 if (!SWIG_IsOK(ecode2)) {
42514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42515 }
42516 arg2 = static_cast< bool >(val2);
42517 }
42518 {
42519 PyThreadState* __tstate = wxPyBeginAllowThreads();
42520 (arg1)->Enable(arg2);
42521 wxPyEndAllowThreads(__tstate);
42522 if (PyErr_Occurred()) SWIG_fail;
42523 }
42524 resultobj = SWIG_Py_Void();
42525 return resultobj;
42526 fail:
42527 return NULL;
42528 }
42529
42530
42531 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42532 PyObject *resultobj = 0;
42533 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42534 bool result;
42535 void *argp1 = 0 ;
42536 int res1 = 0 ;
42537 PyObject *swig_obj[1] ;
42538
42539 if (!args) SWIG_fail;
42540 swig_obj[0] = args;
42541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42542 if (!SWIG_IsOK(res1)) {
42543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42544 }
42545 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42546 {
42547 PyThreadState* __tstate = wxPyBeginAllowThreads();
42548 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42549 wxPyEndAllowThreads(__tstate);
42550 if (PyErr_Occurred()) SWIG_fail;
42551 }
42552 {
42553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42554 }
42555 return resultobj;
42556 fail:
42557 return NULL;
42558 }
42559
42560
42561 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42562 PyObject *resultobj = 0;
42563 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42564 bool arg2 = (bool) true ;
42565 void *argp1 = 0 ;
42566 int res1 = 0 ;
42567 bool val2 ;
42568 int ecode2 = 0 ;
42569 PyObject * obj0 = 0 ;
42570 PyObject * obj1 = 0 ;
42571 char * kwnames[] = {
42572 (char *) "self",(char *) "check", NULL
42573 };
42574
42575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42577 if (!SWIG_IsOK(res1)) {
42578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42579 }
42580 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42581 if (obj1) {
42582 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42583 if (!SWIG_IsOK(ecode2)) {
42584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42585 }
42586 arg2 = static_cast< bool >(val2);
42587 }
42588 {
42589 PyThreadState* __tstate = wxPyBeginAllowThreads();
42590 (arg1)->Check(arg2);
42591 wxPyEndAllowThreads(__tstate);
42592 if (PyErr_Occurred()) SWIG_fail;
42593 }
42594 resultobj = SWIG_Py_Void();
42595 return resultobj;
42596 fail:
42597 return NULL;
42598 }
42599
42600
42601 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42602 PyObject *resultobj = 0;
42603 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42604 bool result;
42605 void *argp1 = 0 ;
42606 int res1 = 0 ;
42607 PyObject *swig_obj[1] ;
42608
42609 if (!args) SWIG_fail;
42610 swig_obj[0] = args;
42611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42612 if (!SWIG_IsOK(res1)) {
42613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42614 }
42615 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42616 {
42617 PyThreadState* __tstate = wxPyBeginAllowThreads();
42618 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42619 wxPyEndAllowThreads(__tstate);
42620 if (PyErr_Occurred()) SWIG_fail;
42621 }
42622 {
42623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42624 }
42625 return resultobj;
42626 fail:
42627 return NULL;
42628 }
42629
42630
42631 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42632 PyObject *resultobj = 0;
42633 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42634 void *argp1 = 0 ;
42635 int res1 = 0 ;
42636 PyObject *swig_obj[1] ;
42637
42638 if (!args) SWIG_fail;
42639 swig_obj[0] = args;
42640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42641 if (!SWIG_IsOK(res1)) {
42642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42643 }
42644 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42645 {
42646 PyThreadState* __tstate = wxPyBeginAllowThreads();
42647 (arg1)->Toggle();
42648 wxPyEndAllowThreads(__tstate);
42649 if (PyErr_Occurred()) SWIG_fail;
42650 }
42651 resultobj = SWIG_Py_Void();
42652 return resultobj;
42653 fail:
42654 return NULL;
42655 }
42656
42657
42658 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42659 PyObject *resultobj = 0;
42660 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42661 wxString *arg2 = 0 ;
42662 void *argp1 = 0 ;
42663 int res1 = 0 ;
42664 bool temp2 = false ;
42665 PyObject * obj0 = 0 ;
42666 PyObject * obj1 = 0 ;
42667 char * kwnames[] = {
42668 (char *) "self",(char *) "str", NULL
42669 };
42670
42671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42673 if (!SWIG_IsOK(res1)) {
42674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42675 }
42676 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42677 {
42678 arg2 = wxString_in_helper(obj1);
42679 if (arg2 == NULL) SWIG_fail;
42680 temp2 = true;
42681 }
42682 {
42683 PyThreadState* __tstate = wxPyBeginAllowThreads();
42684 (arg1)->SetHelp((wxString const &)*arg2);
42685 wxPyEndAllowThreads(__tstate);
42686 if (PyErr_Occurred()) SWIG_fail;
42687 }
42688 resultobj = SWIG_Py_Void();
42689 {
42690 if (temp2)
42691 delete arg2;
42692 }
42693 return resultobj;
42694 fail:
42695 {
42696 if (temp2)
42697 delete arg2;
42698 }
42699 return NULL;
42700 }
42701
42702
42703 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42704 PyObject *resultobj = 0;
42705 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42706 wxString *result = 0 ;
42707 void *argp1 = 0 ;
42708 int res1 = 0 ;
42709 PyObject *swig_obj[1] ;
42710
42711 if (!args) SWIG_fail;
42712 swig_obj[0] = args;
42713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42714 if (!SWIG_IsOK(res1)) {
42715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42716 }
42717 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42718 {
42719 PyThreadState* __tstate = wxPyBeginAllowThreads();
42720 {
42721 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42722 result = (wxString *) &_result_ref;
42723 }
42724 wxPyEndAllowThreads(__tstate);
42725 if (PyErr_Occurred()) SWIG_fail;
42726 }
42727 {
42728 #if wxUSE_UNICODE
42729 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42730 #else
42731 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42732 #endif
42733 }
42734 return resultobj;
42735 fail:
42736 return NULL;
42737 }
42738
42739
42740 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42741 PyObject *resultobj = 0;
42742 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42743 wxAcceleratorEntry *result = 0 ;
42744 void *argp1 = 0 ;
42745 int res1 = 0 ;
42746 PyObject *swig_obj[1] ;
42747
42748 if (!args) SWIG_fail;
42749 swig_obj[0] = args;
42750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42751 if (!SWIG_IsOK(res1)) {
42752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42753 }
42754 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42755 {
42756 PyThreadState* __tstate = wxPyBeginAllowThreads();
42757 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42758 wxPyEndAllowThreads(__tstate);
42759 if (PyErr_Occurred()) SWIG_fail;
42760 }
42761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42762 return resultobj;
42763 fail:
42764 return NULL;
42765 }
42766
42767
42768 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42769 PyObject *resultobj = 0;
42770 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42771 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42772 void *argp1 = 0 ;
42773 int res1 = 0 ;
42774 void *argp2 = 0 ;
42775 int res2 = 0 ;
42776 PyObject * obj0 = 0 ;
42777 PyObject * obj1 = 0 ;
42778 char * kwnames[] = {
42779 (char *) "self",(char *) "accel", NULL
42780 };
42781
42782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42784 if (!SWIG_IsOK(res1)) {
42785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42786 }
42787 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42788 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42789 if (!SWIG_IsOK(res2)) {
42790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42791 }
42792 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42793 {
42794 PyThreadState* __tstate = wxPyBeginAllowThreads();
42795 (arg1)->SetAccel(arg2);
42796 wxPyEndAllowThreads(__tstate);
42797 if (PyErr_Occurred()) SWIG_fail;
42798 }
42799 resultobj = SWIG_Py_Void();
42800 return resultobj;
42801 fail:
42802 return NULL;
42803 }
42804
42805
42806 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42807 PyObject *resultobj = 0;
42808 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42809 wxBitmap *arg2 = 0 ;
42810 void *argp1 = 0 ;
42811 int res1 = 0 ;
42812 void *argp2 = 0 ;
42813 int res2 = 0 ;
42814 PyObject * obj0 = 0 ;
42815 PyObject * obj1 = 0 ;
42816 char * kwnames[] = {
42817 (char *) "self",(char *) "bitmap", NULL
42818 };
42819
42820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42822 if (!SWIG_IsOK(res1)) {
42823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42824 }
42825 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42826 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42827 if (!SWIG_IsOK(res2)) {
42828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42829 }
42830 if (!argp2) {
42831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42832 }
42833 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42834 {
42835 PyThreadState* __tstate = wxPyBeginAllowThreads();
42836 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42837 wxPyEndAllowThreads(__tstate);
42838 if (PyErr_Occurred()) SWIG_fail;
42839 }
42840 resultobj = SWIG_Py_Void();
42841 return resultobj;
42842 fail:
42843 return NULL;
42844 }
42845
42846
42847 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42848 PyObject *resultobj = 0;
42849 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42850 wxBitmap *result = 0 ;
42851 void *argp1 = 0 ;
42852 int res1 = 0 ;
42853 PyObject *swig_obj[1] ;
42854
42855 if (!args) SWIG_fail;
42856 swig_obj[0] = args;
42857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42858 if (!SWIG_IsOK(res1)) {
42859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42860 }
42861 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42862 {
42863 PyThreadState* __tstate = wxPyBeginAllowThreads();
42864 {
42865 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42866 result = (wxBitmap *) &_result_ref;
42867 }
42868 wxPyEndAllowThreads(__tstate);
42869 if (PyErr_Occurred()) SWIG_fail;
42870 }
42871 {
42872 wxBitmap* resultptr = new wxBitmap(*result);
42873 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42874 }
42875 return resultobj;
42876 fail:
42877 return NULL;
42878 }
42879
42880
42881 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42882 PyObject *resultobj = 0;
42883 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42884 wxFont *arg2 = 0 ;
42885 void *argp1 = 0 ;
42886 int res1 = 0 ;
42887 void *argp2 = 0 ;
42888 int res2 = 0 ;
42889 PyObject * obj0 = 0 ;
42890 PyObject * obj1 = 0 ;
42891 char * kwnames[] = {
42892 (char *) "self",(char *) "font", NULL
42893 };
42894
42895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42897 if (!SWIG_IsOK(res1)) {
42898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42899 }
42900 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42901 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42902 if (!SWIG_IsOK(res2)) {
42903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42904 }
42905 if (!argp2) {
42906 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42907 }
42908 arg2 = reinterpret_cast< wxFont * >(argp2);
42909 {
42910 PyThreadState* __tstate = wxPyBeginAllowThreads();
42911 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
42912 wxPyEndAllowThreads(__tstate);
42913 if (PyErr_Occurred()) SWIG_fail;
42914 }
42915 resultobj = SWIG_Py_Void();
42916 return resultobj;
42917 fail:
42918 return NULL;
42919 }
42920
42921
42922 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42923 PyObject *resultobj = 0;
42924 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42925 wxFont result;
42926 void *argp1 = 0 ;
42927 int res1 = 0 ;
42928 PyObject *swig_obj[1] ;
42929
42930 if (!args) SWIG_fail;
42931 swig_obj[0] = args;
42932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42933 if (!SWIG_IsOK(res1)) {
42934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42935 }
42936 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42937 {
42938 PyThreadState* __tstate = wxPyBeginAllowThreads();
42939 result = wxMenuItem_GetFont(arg1);
42940 wxPyEndAllowThreads(__tstate);
42941 if (PyErr_Occurred()) SWIG_fail;
42942 }
42943 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
42944 return resultobj;
42945 fail:
42946 return NULL;
42947 }
42948
42949
42950 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42951 PyObject *resultobj = 0;
42952 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42953 wxColour *arg2 = 0 ;
42954 void *argp1 = 0 ;
42955 int res1 = 0 ;
42956 wxColour temp2 ;
42957 PyObject * obj0 = 0 ;
42958 PyObject * obj1 = 0 ;
42959 char * kwnames[] = {
42960 (char *) "self",(char *) "colText", NULL
42961 };
42962
42963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
42964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42965 if (!SWIG_IsOK(res1)) {
42966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42967 }
42968 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42969 {
42970 arg2 = &temp2;
42971 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42972 }
42973 {
42974 PyThreadState* __tstate = wxPyBeginAllowThreads();
42975 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
42976 wxPyEndAllowThreads(__tstate);
42977 if (PyErr_Occurred()) SWIG_fail;
42978 }
42979 resultobj = SWIG_Py_Void();
42980 return resultobj;
42981 fail:
42982 return NULL;
42983 }
42984
42985
42986 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42987 PyObject *resultobj = 0;
42988 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42989 wxColour result;
42990 void *argp1 = 0 ;
42991 int res1 = 0 ;
42992 PyObject *swig_obj[1] ;
42993
42994 if (!args) SWIG_fail;
42995 swig_obj[0] = args;
42996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42997 if (!SWIG_IsOK(res1)) {
42998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42999 }
43000 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43001 {
43002 PyThreadState* __tstate = wxPyBeginAllowThreads();
43003 result = wxMenuItem_GetTextColour(arg1);
43004 wxPyEndAllowThreads(__tstate);
43005 if (PyErr_Occurred()) SWIG_fail;
43006 }
43007 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43008 return resultobj;
43009 fail:
43010 return NULL;
43011 }
43012
43013
43014 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43015 PyObject *resultobj = 0;
43016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43017 wxColour *arg2 = 0 ;
43018 void *argp1 = 0 ;
43019 int res1 = 0 ;
43020 wxColour temp2 ;
43021 PyObject * obj0 = 0 ;
43022 PyObject * obj1 = 0 ;
43023 char * kwnames[] = {
43024 (char *) "self",(char *) "colBack", NULL
43025 };
43026
43027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43029 if (!SWIG_IsOK(res1)) {
43030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43031 }
43032 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43033 {
43034 arg2 = &temp2;
43035 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43036 }
43037 {
43038 PyThreadState* __tstate = wxPyBeginAllowThreads();
43039 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43040 wxPyEndAllowThreads(__tstate);
43041 if (PyErr_Occurred()) SWIG_fail;
43042 }
43043 resultobj = SWIG_Py_Void();
43044 return resultobj;
43045 fail:
43046 return NULL;
43047 }
43048
43049
43050 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43051 PyObject *resultobj = 0;
43052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43053 wxColour result;
43054 void *argp1 = 0 ;
43055 int res1 = 0 ;
43056 PyObject *swig_obj[1] ;
43057
43058 if (!args) SWIG_fail;
43059 swig_obj[0] = args;
43060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43061 if (!SWIG_IsOK(res1)) {
43062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43063 }
43064 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43065 {
43066 PyThreadState* __tstate = wxPyBeginAllowThreads();
43067 result = wxMenuItem_GetBackgroundColour(arg1);
43068 wxPyEndAllowThreads(__tstate);
43069 if (PyErr_Occurred()) SWIG_fail;
43070 }
43071 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43072 return resultobj;
43073 fail:
43074 return NULL;
43075 }
43076
43077
43078 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43079 PyObject *resultobj = 0;
43080 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43081 wxBitmap *arg2 = 0 ;
43082 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43083 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43084 void *argp1 = 0 ;
43085 int res1 = 0 ;
43086 void *argp2 = 0 ;
43087 int res2 = 0 ;
43088 void *argp3 = 0 ;
43089 int res3 = 0 ;
43090 PyObject * obj0 = 0 ;
43091 PyObject * obj1 = 0 ;
43092 PyObject * obj2 = 0 ;
43093 char * kwnames[] = {
43094 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43095 };
43096
43097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43099 if (!SWIG_IsOK(res1)) {
43100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43101 }
43102 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43103 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43104 if (!SWIG_IsOK(res2)) {
43105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43106 }
43107 if (!argp2) {
43108 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43109 }
43110 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43111 if (obj2) {
43112 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43113 if (!SWIG_IsOK(res3)) {
43114 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43115 }
43116 if (!argp3) {
43117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43118 }
43119 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43120 }
43121 {
43122 PyThreadState* __tstate = wxPyBeginAllowThreads();
43123 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43124 wxPyEndAllowThreads(__tstate);
43125 if (PyErr_Occurred()) SWIG_fail;
43126 }
43127 resultobj = SWIG_Py_Void();
43128 return resultobj;
43129 fail:
43130 return NULL;
43131 }
43132
43133
43134 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43135 PyObject *resultobj = 0;
43136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43137 wxBitmap *arg2 = 0 ;
43138 void *argp1 = 0 ;
43139 int res1 = 0 ;
43140 void *argp2 = 0 ;
43141 int res2 = 0 ;
43142 PyObject * obj0 = 0 ;
43143 PyObject * obj1 = 0 ;
43144 char * kwnames[] = {
43145 (char *) "self",(char *) "bmpDisabled", NULL
43146 };
43147
43148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43150 if (!SWIG_IsOK(res1)) {
43151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43152 }
43153 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43154 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43155 if (!SWIG_IsOK(res2)) {
43156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43157 }
43158 if (!argp2) {
43159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43160 }
43161 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43162 {
43163 PyThreadState* __tstate = wxPyBeginAllowThreads();
43164 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43165 wxPyEndAllowThreads(__tstate);
43166 if (PyErr_Occurred()) SWIG_fail;
43167 }
43168 resultobj = SWIG_Py_Void();
43169 return resultobj;
43170 fail:
43171 return NULL;
43172 }
43173
43174
43175 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43176 PyObject *resultobj = 0;
43177 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43178 wxBitmap *result = 0 ;
43179 void *argp1 = 0 ;
43180 int res1 = 0 ;
43181 PyObject *swig_obj[1] ;
43182
43183 if (!args) SWIG_fail;
43184 swig_obj[0] = args;
43185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43186 if (!SWIG_IsOK(res1)) {
43187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43188 }
43189 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43190 {
43191 PyThreadState* __tstate = wxPyBeginAllowThreads();
43192 {
43193 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43194 result = (wxBitmap *) &_result_ref;
43195 }
43196 wxPyEndAllowThreads(__tstate);
43197 if (PyErr_Occurred()) SWIG_fail;
43198 }
43199 {
43200 wxBitmap* resultptr = new wxBitmap(*result);
43201 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43202 }
43203 return resultobj;
43204 fail:
43205 return NULL;
43206 }
43207
43208
43209 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43210 PyObject *resultobj = 0;
43211 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43212 int arg2 ;
43213 void *argp1 = 0 ;
43214 int res1 = 0 ;
43215 int val2 ;
43216 int ecode2 = 0 ;
43217 PyObject * obj0 = 0 ;
43218 PyObject * obj1 = 0 ;
43219 char * kwnames[] = {
43220 (char *) "self",(char *) "nWidth", NULL
43221 };
43222
43223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43225 if (!SWIG_IsOK(res1)) {
43226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43227 }
43228 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43229 ecode2 = SWIG_AsVal_int(obj1, &val2);
43230 if (!SWIG_IsOK(ecode2)) {
43231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43232 }
43233 arg2 = static_cast< int >(val2);
43234 {
43235 PyThreadState* __tstate = wxPyBeginAllowThreads();
43236 wxMenuItem_SetMarginWidth(arg1,arg2);
43237 wxPyEndAllowThreads(__tstate);
43238 if (PyErr_Occurred()) SWIG_fail;
43239 }
43240 resultobj = SWIG_Py_Void();
43241 return resultobj;
43242 fail:
43243 return NULL;
43244 }
43245
43246
43247 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43248 PyObject *resultobj = 0;
43249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43250 int result;
43251 void *argp1 = 0 ;
43252 int res1 = 0 ;
43253 PyObject *swig_obj[1] ;
43254
43255 if (!args) SWIG_fail;
43256 swig_obj[0] = args;
43257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43258 if (!SWIG_IsOK(res1)) {
43259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43260 }
43261 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43262 {
43263 PyThreadState* __tstate = wxPyBeginAllowThreads();
43264 result = (int)wxMenuItem_GetMarginWidth(arg1);
43265 wxPyEndAllowThreads(__tstate);
43266 if (PyErr_Occurred()) SWIG_fail;
43267 }
43268 resultobj = SWIG_From_int(static_cast< int >(result));
43269 return resultobj;
43270 fail:
43271 return NULL;
43272 }
43273
43274
43275 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43276 PyObject *resultobj = 0;
43277 int result;
43278
43279 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43280 {
43281 PyThreadState* __tstate = wxPyBeginAllowThreads();
43282 result = (int)wxMenuItem_GetDefaultMarginWidth();
43283 wxPyEndAllowThreads(__tstate);
43284 if (PyErr_Occurred()) SWIG_fail;
43285 }
43286 resultobj = SWIG_From_int(static_cast< int >(result));
43287 return resultobj;
43288 fail:
43289 return NULL;
43290 }
43291
43292
43293 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43294 PyObject *resultobj = 0;
43295 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43296 bool result;
43297 void *argp1 = 0 ;
43298 int res1 = 0 ;
43299 PyObject *swig_obj[1] ;
43300
43301 if (!args) SWIG_fail;
43302 swig_obj[0] = args;
43303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43304 if (!SWIG_IsOK(res1)) {
43305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43306 }
43307 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43308 {
43309 PyThreadState* __tstate = wxPyBeginAllowThreads();
43310 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43311 wxPyEndAllowThreads(__tstate);
43312 if (PyErr_Occurred()) SWIG_fail;
43313 }
43314 {
43315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43316 }
43317 return resultobj;
43318 fail:
43319 return NULL;
43320 }
43321
43322
43323 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43324 PyObject *resultobj = 0;
43325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43326 bool arg2 = (bool) true ;
43327 void *argp1 = 0 ;
43328 int res1 = 0 ;
43329 bool val2 ;
43330 int ecode2 = 0 ;
43331 PyObject * obj0 = 0 ;
43332 PyObject * obj1 = 0 ;
43333 char * kwnames[] = {
43334 (char *) "self",(char *) "ownerDrawn", NULL
43335 };
43336
43337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43339 if (!SWIG_IsOK(res1)) {
43340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43341 }
43342 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43343 if (obj1) {
43344 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43345 if (!SWIG_IsOK(ecode2)) {
43346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43347 }
43348 arg2 = static_cast< bool >(val2);
43349 }
43350 {
43351 PyThreadState* __tstate = wxPyBeginAllowThreads();
43352 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43353 wxPyEndAllowThreads(__tstate);
43354 if (PyErr_Occurred()) SWIG_fail;
43355 }
43356 resultobj = SWIG_Py_Void();
43357 return resultobj;
43358 fail:
43359 return NULL;
43360 }
43361
43362
43363 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43364 PyObject *resultobj = 0;
43365 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43366 void *argp1 = 0 ;
43367 int res1 = 0 ;
43368 PyObject *swig_obj[1] ;
43369
43370 if (!args) SWIG_fail;
43371 swig_obj[0] = args;
43372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43373 if (!SWIG_IsOK(res1)) {
43374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43375 }
43376 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43377 {
43378 PyThreadState* __tstate = wxPyBeginAllowThreads();
43379 wxMenuItem_ResetOwnerDrawn(arg1);
43380 wxPyEndAllowThreads(__tstate);
43381 if (PyErr_Occurred()) SWIG_fail;
43382 }
43383 resultobj = SWIG_Py_Void();
43384 return resultobj;
43385 fail:
43386 return NULL;
43387 }
43388
43389
43390 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43391 PyObject *obj;
43392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43393 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43394 return SWIG_Py_Void();
43395 }
43396
43397 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43398 return SWIG_Python_InitShadowInstance(args);
43399 }
43400
43401 SWIGINTERN int ControlNameStr_set(PyObject *) {
43402 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43403 return 1;
43404 }
43405
43406
43407 SWIGINTERN PyObject *ControlNameStr_get(void) {
43408 PyObject *pyobj = 0;
43409
43410 {
43411 #if wxUSE_UNICODE
43412 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43413 #else
43414 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43415 #endif
43416 }
43417 return pyobj;
43418 }
43419
43420
43421 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43422 PyObject *resultobj = 0;
43423 wxWindow *arg1 = (wxWindow *) 0 ;
43424 int arg2 = (int) -1 ;
43425 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43426 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43427 wxSize const &arg4_defvalue = wxDefaultSize ;
43428 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43429 long arg5 = (long) 0 ;
43430 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43431 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43432 wxString const &arg7_defvalue = wxPyControlNameStr ;
43433 wxString *arg7 = (wxString *) &arg7_defvalue ;
43434 wxControl *result = 0 ;
43435 void *argp1 = 0 ;
43436 int res1 = 0 ;
43437 int val2 ;
43438 int ecode2 = 0 ;
43439 wxPoint temp3 ;
43440 wxSize temp4 ;
43441 long val5 ;
43442 int ecode5 = 0 ;
43443 void *argp6 = 0 ;
43444 int res6 = 0 ;
43445 bool temp7 = false ;
43446 PyObject * obj0 = 0 ;
43447 PyObject * obj1 = 0 ;
43448 PyObject * obj2 = 0 ;
43449 PyObject * obj3 = 0 ;
43450 PyObject * obj4 = 0 ;
43451 PyObject * obj5 = 0 ;
43452 PyObject * obj6 = 0 ;
43453 char * kwnames[] = {
43454 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43455 };
43456
43457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43459 if (!SWIG_IsOK(res1)) {
43460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43461 }
43462 arg1 = reinterpret_cast< wxWindow * >(argp1);
43463 if (obj1) {
43464 ecode2 = SWIG_AsVal_int(obj1, &val2);
43465 if (!SWIG_IsOK(ecode2)) {
43466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43467 }
43468 arg2 = static_cast< int >(val2);
43469 }
43470 if (obj2) {
43471 {
43472 arg3 = &temp3;
43473 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43474 }
43475 }
43476 if (obj3) {
43477 {
43478 arg4 = &temp4;
43479 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43480 }
43481 }
43482 if (obj4) {
43483 ecode5 = SWIG_AsVal_long(obj4, &val5);
43484 if (!SWIG_IsOK(ecode5)) {
43485 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43486 }
43487 arg5 = static_cast< long >(val5);
43488 }
43489 if (obj5) {
43490 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43491 if (!SWIG_IsOK(res6)) {
43492 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43493 }
43494 if (!argp6) {
43495 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43496 }
43497 arg6 = reinterpret_cast< wxValidator * >(argp6);
43498 }
43499 if (obj6) {
43500 {
43501 arg7 = wxString_in_helper(obj6);
43502 if (arg7 == NULL) SWIG_fail;
43503 temp7 = true;
43504 }
43505 }
43506 {
43507 if (!wxPyCheckForApp()) SWIG_fail;
43508 PyThreadState* __tstate = wxPyBeginAllowThreads();
43509 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43510 wxPyEndAllowThreads(__tstate);
43511 if (PyErr_Occurred()) SWIG_fail;
43512 }
43513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43514 {
43515 if (temp7)
43516 delete arg7;
43517 }
43518 return resultobj;
43519 fail:
43520 {
43521 if (temp7)
43522 delete arg7;
43523 }
43524 return NULL;
43525 }
43526
43527
43528 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43529 PyObject *resultobj = 0;
43530 wxControl *result = 0 ;
43531
43532 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43533 {
43534 if (!wxPyCheckForApp()) SWIG_fail;
43535 PyThreadState* __tstate = wxPyBeginAllowThreads();
43536 result = (wxControl *)new wxControl();
43537 wxPyEndAllowThreads(__tstate);
43538 if (PyErr_Occurred()) SWIG_fail;
43539 }
43540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43541 return resultobj;
43542 fail:
43543 return NULL;
43544 }
43545
43546
43547 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43548 PyObject *resultobj = 0;
43549 wxControl *arg1 = (wxControl *) 0 ;
43550 wxWindow *arg2 = (wxWindow *) 0 ;
43551 int arg3 = (int) -1 ;
43552 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43553 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43554 wxSize const &arg5_defvalue = wxDefaultSize ;
43555 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43556 long arg6 = (long) 0 ;
43557 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43558 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43559 wxString const &arg8_defvalue = wxPyControlNameStr ;
43560 wxString *arg8 = (wxString *) &arg8_defvalue ;
43561 bool result;
43562 void *argp1 = 0 ;
43563 int res1 = 0 ;
43564 void *argp2 = 0 ;
43565 int res2 = 0 ;
43566 int val3 ;
43567 int ecode3 = 0 ;
43568 wxPoint temp4 ;
43569 wxSize temp5 ;
43570 long val6 ;
43571 int ecode6 = 0 ;
43572 void *argp7 = 0 ;
43573 int res7 = 0 ;
43574 bool temp8 = false ;
43575 PyObject * obj0 = 0 ;
43576 PyObject * obj1 = 0 ;
43577 PyObject * obj2 = 0 ;
43578 PyObject * obj3 = 0 ;
43579 PyObject * obj4 = 0 ;
43580 PyObject * obj5 = 0 ;
43581 PyObject * obj6 = 0 ;
43582 PyObject * obj7 = 0 ;
43583 char * kwnames[] = {
43584 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43585 };
43586
43587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43589 if (!SWIG_IsOK(res1)) {
43590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43591 }
43592 arg1 = reinterpret_cast< wxControl * >(argp1);
43593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43594 if (!SWIG_IsOK(res2)) {
43595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43596 }
43597 arg2 = reinterpret_cast< wxWindow * >(argp2);
43598 if (obj2) {
43599 ecode3 = SWIG_AsVal_int(obj2, &val3);
43600 if (!SWIG_IsOK(ecode3)) {
43601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43602 }
43603 arg3 = static_cast< int >(val3);
43604 }
43605 if (obj3) {
43606 {
43607 arg4 = &temp4;
43608 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43609 }
43610 }
43611 if (obj4) {
43612 {
43613 arg5 = &temp5;
43614 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43615 }
43616 }
43617 if (obj5) {
43618 ecode6 = SWIG_AsVal_long(obj5, &val6);
43619 if (!SWIG_IsOK(ecode6)) {
43620 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43621 }
43622 arg6 = static_cast< long >(val6);
43623 }
43624 if (obj6) {
43625 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43626 if (!SWIG_IsOK(res7)) {
43627 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43628 }
43629 if (!argp7) {
43630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43631 }
43632 arg7 = reinterpret_cast< wxValidator * >(argp7);
43633 }
43634 if (obj7) {
43635 {
43636 arg8 = wxString_in_helper(obj7);
43637 if (arg8 == NULL) SWIG_fail;
43638 temp8 = true;
43639 }
43640 }
43641 {
43642 PyThreadState* __tstate = wxPyBeginAllowThreads();
43643 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43644 wxPyEndAllowThreads(__tstate);
43645 if (PyErr_Occurred()) SWIG_fail;
43646 }
43647 {
43648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43649 }
43650 {
43651 if (temp8)
43652 delete arg8;
43653 }
43654 return resultobj;
43655 fail:
43656 {
43657 if (temp8)
43658 delete arg8;
43659 }
43660 return NULL;
43661 }
43662
43663
43664 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43665 PyObject *resultobj = 0;
43666 wxControl *arg1 = (wxControl *) 0 ;
43667 wxCommandEvent *arg2 = 0 ;
43668 void *argp1 = 0 ;
43669 int res1 = 0 ;
43670 void *argp2 = 0 ;
43671 int res2 = 0 ;
43672 PyObject * obj0 = 0 ;
43673 PyObject * obj1 = 0 ;
43674 char * kwnames[] = {
43675 (char *) "self",(char *) "event", NULL
43676 };
43677
43678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43680 if (!SWIG_IsOK(res1)) {
43681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43682 }
43683 arg1 = reinterpret_cast< wxControl * >(argp1);
43684 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43685 if (!SWIG_IsOK(res2)) {
43686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43687 }
43688 if (!argp2) {
43689 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43690 }
43691 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43692 {
43693 PyThreadState* __tstate = wxPyBeginAllowThreads();
43694 (arg1)->Command(*arg2);
43695 wxPyEndAllowThreads(__tstate);
43696 if (PyErr_Occurred()) SWIG_fail;
43697 }
43698 resultobj = SWIG_Py_Void();
43699 return resultobj;
43700 fail:
43701 return NULL;
43702 }
43703
43704
43705 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43706 PyObject *resultobj = 0;
43707 wxControl *arg1 = (wxControl *) 0 ;
43708 wxString result;
43709 void *argp1 = 0 ;
43710 int res1 = 0 ;
43711 PyObject *swig_obj[1] ;
43712
43713 if (!args) SWIG_fail;
43714 swig_obj[0] = args;
43715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43716 if (!SWIG_IsOK(res1)) {
43717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43718 }
43719 arg1 = reinterpret_cast< wxControl * >(argp1);
43720 {
43721 PyThreadState* __tstate = wxPyBeginAllowThreads();
43722 result = (arg1)->GetLabel();
43723 wxPyEndAllowThreads(__tstate);
43724 if (PyErr_Occurred()) SWIG_fail;
43725 }
43726 {
43727 #if wxUSE_UNICODE
43728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43729 #else
43730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43731 #endif
43732 }
43733 return resultobj;
43734 fail:
43735 return NULL;
43736 }
43737
43738
43739 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43740 PyObject *resultobj = 0;
43741 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43742 SwigValueWrapper<wxVisualAttributes > result;
43743 int val1 ;
43744 int ecode1 = 0 ;
43745 PyObject * obj0 = 0 ;
43746 char * kwnames[] = {
43747 (char *) "variant", NULL
43748 };
43749
43750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43751 if (obj0) {
43752 ecode1 = SWIG_AsVal_int(obj0, &val1);
43753 if (!SWIG_IsOK(ecode1)) {
43754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43755 }
43756 arg1 = static_cast< wxWindowVariant >(val1);
43757 }
43758 {
43759 if (!wxPyCheckForApp()) SWIG_fail;
43760 PyThreadState* __tstate = wxPyBeginAllowThreads();
43761 result = wxControl::GetClassDefaultAttributes(arg1);
43762 wxPyEndAllowThreads(__tstate);
43763 if (PyErr_Occurred()) SWIG_fail;
43764 }
43765 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43766 return resultobj;
43767 fail:
43768 return NULL;
43769 }
43770
43771
43772 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43773 PyObject *obj;
43774 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43775 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43776 return SWIG_Py_Void();
43777 }
43778
43779 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43780 return SWIG_Python_InitShadowInstance(args);
43781 }
43782
43783 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43784 PyObject *resultobj = 0;
43785 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43786 wxString *arg2 = 0 ;
43787 PyObject *arg3 = (PyObject *) NULL ;
43788 int result;
43789 void *argp1 = 0 ;
43790 int res1 = 0 ;
43791 bool temp2 = false ;
43792 PyObject * obj0 = 0 ;
43793 PyObject * obj1 = 0 ;
43794 PyObject * obj2 = 0 ;
43795 char * kwnames[] = {
43796 (char *) "self",(char *) "item",(char *) "clientData", NULL
43797 };
43798
43799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43801 if (!SWIG_IsOK(res1)) {
43802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43803 }
43804 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43805 {
43806 arg2 = wxString_in_helper(obj1);
43807 if (arg2 == NULL) SWIG_fail;
43808 temp2 = true;
43809 }
43810 if (obj2) {
43811 arg3 = obj2;
43812 }
43813 {
43814 PyThreadState* __tstate = wxPyBeginAllowThreads();
43815 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43816 wxPyEndAllowThreads(__tstate);
43817 if (PyErr_Occurred()) SWIG_fail;
43818 }
43819 resultobj = SWIG_From_int(static_cast< int >(result));
43820 {
43821 if (temp2)
43822 delete arg2;
43823 }
43824 return resultobj;
43825 fail:
43826 {
43827 if (temp2)
43828 delete arg2;
43829 }
43830 return NULL;
43831 }
43832
43833
43834 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43835 PyObject *resultobj = 0;
43836 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43837 wxArrayString *arg2 = 0 ;
43838 void *argp1 = 0 ;
43839 int res1 = 0 ;
43840 bool temp2 = false ;
43841 PyObject * obj0 = 0 ;
43842 PyObject * obj1 = 0 ;
43843 char * kwnames[] = {
43844 (char *) "self",(char *) "strings", NULL
43845 };
43846
43847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43849 if (!SWIG_IsOK(res1)) {
43850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43851 }
43852 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43853 {
43854 if (! PySequence_Check(obj1)) {
43855 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43856 SWIG_fail;
43857 }
43858 arg2 = new wxArrayString;
43859 temp2 = true;
43860 int i, len=PySequence_Length(obj1);
43861 for (i=0; i<len; i++) {
43862 PyObject* item = PySequence_GetItem(obj1, i);
43863 wxString* s = wxString_in_helper(item);
43864 if (PyErr_Occurred()) SWIG_fail;
43865 arg2->Add(*s);
43866 delete s;
43867 Py_DECREF(item);
43868 }
43869 }
43870 {
43871 PyThreadState* __tstate = wxPyBeginAllowThreads();
43872 (arg1)->Append((wxArrayString const &)*arg2);
43873 wxPyEndAllowThreads(__tstate);
43874 if (PyErr_Occurred()) SWIG_fail;
43875 }
43876 resultobj = SWIG_Py_Void();
43877 {
43878 if (temp2) delete arg2;
43879 }
43880 return resultobj;
43881 fail:
43882 {
43883 if (temp2) delete arg2;
43884 }
43885 return NULL;
43886 }
43887
43888
43889 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43890 PyObject *resultobj = 0;
43891 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43892 wxString *arg2 = 0 ;
43893 unsigned int arg3 ;
43894 PyObject *arg4 = (PyObject *) NULL ;
43895 int result;
43896 void *argp1 = 0 ;
43897 int res1 = 0 ;
43898 bool temp2 = false ;
43899 unsigned int val3 ;
43900 int ecode3 = 0 ;
43901 PyObject * obj0 = 0 ;
43902 PyObject * obj1 = 0 ;
43903 PyObject * obj2 = 0 ;
43904 PyObject * obj3 = 0 ;
43905 char * kwnames[] = {
43906 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43907 };
43908
43909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43911 if (!SWIG_IsOK(res1)) {
43912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43913 }
43914 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43915 {
43916 arg2 = wxString_in_helper(obj1);
43917 if (arg2 == NULL) SWIG_fail;
43918 temp2 = true;
43919 }
43920 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
43921 if (!SWIG_IsOK(ecode3)) {
43922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
43923 }
43924 arg3 = static_cast< unsigned int >(val3);
43925 if (obj3) {
43926 arg4 = obj3;
43927 }
43928 {
43929 PyThreadState* __tstate = wxPyBeginAllowThreads();
43930 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 resultobj = SWIG_From_int(static_cast< int >(result));
43935 {
43936 if (temp2)
43937 delete arg2;
43938 }
43939 return resultobj;
43940 fail:
43941 {
43942 if (temp2)
43943 delete arg2;
43944 }
43945 return NULL;
43946 }
43947
43948
43949 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43950 PyObject *resultobj = 0;
43951 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43952 void *argp1 = 0 ;
43953 int res1 = 0 ;
43954 PyObject *swig_obj[1] ;
43955
43956 if (!args) SWIG_fail;
43957 swig_obj[0] = args;
43958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43959 if (!SWIG_IsOK(res1)) {
43960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43961 }
43962 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43963 {
43964 PyThreadState* __tstate = wxPyBeginAllowThreads();
43965 (arg1)->Clear();
43966 wxPyEndAllowThreads(__tstate);
43967 if (PyErr_Occurred()) SWIG_fail;
43968 }
43969 resultobj = SWIG_Py_Void();
43970 return resultobj;
43971 fail:
43972 return NULL;
43973 }
43974
43975
43976 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43977 PyObject *resultobj = 0;
43978 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43979 unsigned int arg2 ;
43980 void *argp1 = 0 ;
43981 int res1 = 0 ;
43982 unsigned int val2 ;
43983 int ecode2 = 0 ;
43984 PyObject * obj0 = 0 ;
43985 PyObject * obj1 = 0 ;
43986 char * kwnames[] = {
43987 (char *) "self",(char *) "n", NULL
43988 };
43989
43990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43992 if (!SWIG_IsOK(res1)) {
43993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43994 }
43995 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43996 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
43997 if (!SWIG_IsOK(ecode2)) {
43998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
43999 }
44000 arg2 = static_cast< unsigned int >(val2);
44001 {
44002 PyThreadState* __tstate = wxPyBeginAllowThreads();
44003 (arg1)->Delete(arg2);
44004 wxPyEndAllowThreads(__tstate);
44005 if (PyErr_Occurred()) SWIG_fail;
44006 }
44007 resultobj = SWIG_Py_Void();
44008 return resultobj;
44009 fail:
44010 return NULL;
44011 }
44012
44013
44014 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44015 PyObject *resultobj = 0;
44016 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44017 unsigned int arg2 ;
44018 PyObject *result = 0 ;
44019 void *argp1 = 0 ;
44020 int res1 = 0 ;
44021 unsigned int val2 ;
44022 int ecode2 = 0 ;
44023 PyObject * obj0 = 0 ;
44024 PyObject * obj1 = 0 ;
44025 char * kwnames[] = {
44026 (char *) "self",(char *) "n", NULL
44027 };
44028
44029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44031 if (!SWIG_IsOK(res1)) {
44032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44033 }
44034 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44035 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44036 if (!SWIG_IsOK(ecode2)) {
44037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44038 }
44039 arg2 = static_cast< unsigned int >(val2);
44040 {
44041 PyThreadState* __tstate = wxPyBeginAllowThreads();
44042 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44043 wxPyEndAllowThreads(__tstate);
44044 if (PyErr_Occurred()) SWIG_fail;
44045 }
44046 resultobj = result;
44047 return resultobj;
44048 fail:
44049 return NULL;
44050 }
44051
44052
44053 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44054 PyObject *resultobj = 0;
44055 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44056 unsigned int arg2 ;
44057 PyObject *arg3 = (PyObject *) 0 ;
44058 void *argp1 = 0 ;
44059 int res1 = 0 ;
44060 unsigned int val2 ;
44061 int ecode2 = 0 ;
44062 PyObject * obj0 = 0 ;
44063 PyObject * obj1 = 0 ;
44064 PyObject * obj2 = 0 ;
44065 char * kwnames[] = {
44066 (char *) "self",(char *) "n",(char *) "clientData", NULL
44067 };
44068
44069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44071 if (!SWIG_IsOK(res1)) {
44072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44073 }
44074 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44075 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44076 if (!SWIG_IsOK(ecode2)) {
44077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44078 }
44079 arg2 = static_cast< unsigned int >(val2);
44080 arg3 = obj2;
44081 {
44082 PyThreadState* __tstate = wxPyBeginAllowThreads();
44083 wxItemContainer_SetClientData(arg1,arg2,arg3);
44084 wxPyEndAllowThreads(__tstate);
44085 if (PyErr_Occurred()) SWIG_fail;
44086 }
44087 resultobj = SWIG_Py_Void();
44088 return resultobj;
44089 fail:
44090 return NULL;
44091 }
44092
44093
44094 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44095 PyObject *resultobj = 0;
44096 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44097 unsigned int result;
44098 void *argp1 = 0 ;
44099 int res1 = 0 ;
44100 PyObject *swig_obj[1] ;
44101
44102 if (!args) SWIG_fail;
44103 swig_obj[0] = args;
44104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44105 if (!SWIG_IsOK(res1)) {
44106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44107 }
44108 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44109 {
44110 PyThreadState* __tstate = wxPyBeginAllowThreads();
44111 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44112 wxPyEndAllowThreads(__tstate);
44113 if (PyErr_Occurred()) SWIG_fail;
44114 }
44115 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44116 return resultobj;
44117 fail:
44118 return NULL;
44119 }
44120
44121
44122 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44123 PyObject *resultobj = 0;
44124 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44125 bool result;
44126 void *argp1 = 0 ;
44127 int res1 = 0 ;
44128 PyObject *swig_obj[1] ;
44129
44130 if (!args) SWIG_fail;
44131 swig_obj[0] = args;
44132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44133 if (!SWIG_IsOK(res1)) {
44134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44135 }
44136 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44137 {
44138 PyThreadState* __tstate = wxPyBeginAllowThreads();
44139 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44140 wxPyEndAllowThreads(__tstate);
44141 if (PyErr_Occurred()) SWIG_fail;
44142 }
44143 {
44144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44145 }
44146 return resultobj;
44147 fail:
44148 return NULL;
44149 }
44150
44151
44152 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44153 PyObject *resultobj = 0;
44154 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44155 unsigned int arg2 ;
44156 wxString result;
44157 void *argp1 = 0 ;
44158 int res1 = 0 ;
44159 unsigned int val2 ;
44160 int ecode2 = 0 ;
44161 PyObject * obj0 = 0 ;
44162 PyObject * obj1 = 0 ;
44163 char * kwnames[] = {
44164 (char *) "self",(char *) "n", NULL
44165 };
44166
44167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44169 if (!SWIG_IsOK(res1)) {
44170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44171 }
44172 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44173 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44174 if (!SWIG_IsOK(ecode2)) {
44175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44176 }
44177 arg2 = static_cast< unsigned int >(val2);
44178 {
44179 PyThreadState* __tstate = wxPyBeginAllowThreads();
44180 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44181 wxPyEndAllowThreads(__tstate);
44182 if (PyErr_Occurred()) SWIG_fail;
44183 }
44184 {
44185 #if wxUSE_UNICODE
44186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44187 #else
44188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44189 #endif
44190 }
44191 return resultobj;
44192 fail:
44193 return NULL;
44194 }
44195
44196
44197 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44198 PyObject *resultobj = 0;
44199 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44200 wxArrayString result;
44201 void *argp1 = 0 ;
44202 int res1 = 0 ;
44203 PyObject *swig_obj[1] ;
44204
44205 if (!args) SWIG_fail;
44206 swig_obj[0] = args;
44207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44208 if (!SWIG_IsOK(res1)) {
44209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44210 }
44211 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44212 {
44213 PyThreadState* __tstate = wxPyBeginAllowThreads();
44214 result = ((wxItemContainer const *)arg1)->GetStrings();
44215 wxPyEndAllowThreads(__tstate);
44216 if (PyErr_Occurred()) SWIG_fail;
44217 }
44218 {
44219 resultobj = wxArrayString2PyList_helper(result);
44220 }
44221 return resultobj;
44222 fail:
44223 return NULL;
44224 }
44225
44226
44227 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44228 PyObject *resultobj = 0;
44229 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44230 unsigned int arg2 ;
44231 wxString *arg3 = 0 ;
44232 void *argp1 = 0 ;
44233 int res1 = 0 ;
44234 unsigned int val2 ;
44235 int ecode2 = 0 ;
44236 bool temp3 = false ;
44237 PyObject * obj0 = 0 ;
44238 PyObject * obj1 = 0 ;
44239 PyObject * obj2 = 0 ;
44240 char * kwnames[] = {
44241 (char *) "self",(char *) "n",(char *) "s", NULL
44242 };
44243
44244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44246 if (!SWIG_IsOK(res1)) {
44247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44248 }
44249 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44250 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44251 if (!SWIG_IsOK(ecode2)) {
44252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44253 }
44254 arg2 = static_cast< unsigned int >(val2);
44255 {
44256 arg3 = wxString_in_helper(obj2);
44257 if (arg3 == NULL) SWIG_fail;
44258 temp3 = true;
44259 }
44260 {
44261 PyThreadState* __tstate = wxPyBeginAllowThreads();
44262 (arg1)->SetString(arg2,(wxString const &)*arg3);
44263 wxPyEndAllowThreads(__tstate);
44264 if (PyErr_Occurred()) SWIG_fail;
44265 }
44266 resultobj = SWIG_Py_Void();
44267 {
44268 if (temp3)
44269 delete arg3;
44270 }
44271 return resultobj;
44272 fail:
44273 {
44274 if (temp3)
44275 delete arg3;
44276 }
44277 return NULL;
44278 }
44279
44280
44281 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44282 PyObject *resultobj = 0;
44283 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44284 wxString *arg2 = 0 ;
44285 int result;
44286 void *argp1 = 0 ;
44287 int res1 = 0 ;
44288 bool temp2 = false ;
44289 PyObject * obj0 = 0 ;
44290 PyObject * obj1 = 0 ;
44291 char * kwnames[] = {
44292 (char *) "self",(char *) "s", NULL
44293 };
44294
44295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44297 if (!SWIG_IsOK(res1)) {
44298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44299 }
44300 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44301 {
44302 arg2 = wxString_in_helper(obj1);
44303 if (arg2 == NULL) SWIG_fail;
44304 temp2 = true;
44305 }
44306 {
44307 PyThreadState* __tstate = wxPyBeginAllowThreads();
44308 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44309 wxPyEndAllowThreads(__tstate);
44310 if (PyErr_Occurred()) SWIG_fail;
44311 }
44312 resultobj = SWIG_From_int(static_cast< int >(result));
44313 {
44314 if (temp2)
44315 delete arg2;
44316 }
44317 return resultobj;
44318 fail:
44319 {
44320 if (temp2)
44321 delete arg2;
44322 }
44323 return NULL;
44324 }
44325
44326
44327 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44328 PyObject *resultobj = 0;
44329 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44330 int arg2 ;
44331 void *argp1 = 0 ;
44332 int res1 = 0 ;
44333 int val2 ;
44334 int ecode2 = 0 ;
44335 PyObject * obj0 = 0 ;
44336 PyObject * obj1 = 0 ;
44337 char * kwnames[] = {
44338 (char *) "self",(char *) "n", NULL
44339 };
44340
44341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44343 if (!SWIG_IsOK(res1)) {
44344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44345 }
44346 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44347 ecode2 = SWIG_AsVal_int(obj1, &val2);
44348 if (!SWIG_IsOK(ecode2)) {
44349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44350 }
44351 arg2 = static_cast< int >(val2);
44352 {
44353 PyThreadState* __tstate = wxPyBeginAllowThreads();
44354 (arg1)->SetSelection(arg2);
44355 wxPyEndAllowThreads(__tstate);
44356 if (PyErr_Occurred()) SWIG_fail;
44357 }
44358 resultobj = SWIG_Py_Void();
44359 return resultobj;
44360 fail:
44361 return NULL;
44362 }
44363
44364
44365 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44366 PyObject *resultobj = 0;
44367 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44368 int result;
44369 void *argp1 = 0 ;
44370 int res1 = 0 ;
44371 PyObject *swig_obj[1] ;
44372
44373 if (!args) SWIG_fail;
44374 swig_obj[0] = args;
44375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44378 }
44379 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44380 {
44381 PyThreadState* __tstate = wxPyBeginAllowThreads();
44382 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44383 wxPyEndAllowThreads(__tstate);
44384 if (PyErr_Occurred()) SWIG_fail;
44385 }
44386 resultobj = SWIG_From_int(static_cast< int >(result));
44387 return resultobj;
44388 fail:
44389 return NULL;
44390 }
44391
44392
44393 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44394 PyObject *resultobj = 0;
44395 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44396 wxString *arg2 = 0 ;
44397 bool result;
44398 void *argp1 = 0 ;
44399 int res1 = 0 ;
44400 bool temp2 = false ;
44401 PyObject * obj0 = 0 ;
44402 PyObject * obj1 = 0 ;
44403 char * kwnames[] = {
44404 (char *) "self",(char *) "s", NULL
44405 };
44406
44407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44409 if (!SWIG_IsOK(res1)) {
44410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44411 }
44412 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44413 {
44414 arg2 = wxString_in_helper(obj1);
44415 if (arg2 == NULL) SWIG_fail;
44416 temp2 = true;
44417 }
44418 {
44419 PyThreadState* __tstate = wxPyBeginAllowThreads();
44420 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44421 wxPyEndAllowThreads(__tstate);
44422 if (PyErr_Occurred()) SWIG_fail;
44423 }
44424 {
44425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44426 }
44427 {
44428 if (temp2)
44429 delete arg2;
44430 }
44431 return resultobj;
44432 fail:
44433 {
44434 if (temp2)
44435 delete arg2;
44436 }
44437 return NULL;
44438 }
44439
44440
44441 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44442 PyObject *resultobj = 0;
44443 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44444 wxString result;
44445 void *argp1 = 0 ;
44446 int res1 = 0 ;
44447 PyObject *swig_obj[1] ;
44448
44449 if (!args) SWIG_fail;
44450 swig_obj[0] = args;
44451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44452 if (!SWIG_IsOK(res1)) {
44453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44454 }
44455 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44456 {
44457 PyThreadState* __tstate = wxPyBeginAllowThreads();
44458 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 {
44463 #if wxUSE_UNICODE
44464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44465 #else
44466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44467 #endif
44468 }
44469 return resultobj;
44470 fail:
44471 return NULL;
44472 }
44473
44474
44475 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44476 PyObject *resultobj = 0;
44477 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44478 int arg2 ;
44479 void *argp1 = 0 ;
44480 int res1 = 0 ;
44481 int val2 ;
44482 int ecode2 = 0 ;
44483 PyObject * obj0 = 0 ;
44484 PyObject * obj1 = 0 ;
44485 char * kwnames[] = {
44486 (char *) "self",(char *) "n", NULL
44487 };
44488
44489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44491 if (!SWIG_IsOK(res1)) {
44492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44493 }
44494 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44495 ecode2 = SWIG_AsVal_int(obj1, &val2);
44496 if (!SWIG_IsOK(ecode2)) {
44497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44498 }
44499 arg2 = static_cast< int >(val2);
44500 {
44501 PyThreadState* __tstate = wxPyBeginAllowThreads();
44502 (arg1)->Select(arg2);
44503 wxPyEndAllowThreads(__tstate);
44504 if (PyErr_Occurred()) SWIG_fail;
44505 }
44506 resultobj = SWIG_Py_Void();
44507 return resultobj;
44508 fail:
44509 return NULL;
44510 }
44511
44512
44513 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44514 PyObject *obj;
44515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44516 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44517 return SWIG_Py_Void();
44518 }
44519
44520 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44521 PyObject *obj;
44522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44523 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44524 return SWIG_Py_Void();
44525 }
44526
44527 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44528 PyObject *resultobj = 0;
44529 wxSizerItem *result = 0 ;
44530
44531 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44532 {
44533 PyThreadState* __tstate = wxPyBeginAllowThreads();
44534 result = (wxSizerItem *)new wxSizerItem();
44535 wxPyEndAllowThreads(__tstate);
44536 if (PyErr_Occurred()) SWIG_fail;
44537 }
44538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44539 return resultobj;
44540 fail:
44541 return NULL;
44542 }
44543
44544
44545 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44546 PyObject *resultobj = 0;
44547 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44548 void *argp1 = 0 ;
44549 int res1 = 0 ;
44550 PyObject *swig_obj[1] ;
44551
44552 if (!args) SWIG_fail;
44553 swig_obj[0] = args;
44554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44555 if (!SWIG_IsOK(res1)) {
44556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44557 }
44558 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44559 {
44560 PyThreadState* __tstate = wxPyBeginAllowThreads();
44561 delete arg1;
44562
44563 wxPyEndAllowThreads(__tstate);
44564 if (PyErr_Occurred()) SWIG_fail;
44565 }
44566 resultobj = SWIG_Py_Void();
44567 return resultobj;
44568 fail:
44569 return NULL;
44570 }
44571
44572
44573 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44574 PyObject *resultobj = 0;
44575 wxWindow *arg1 = (wxWindow *) 0 ;
44576 int arg2 ;
44577 int arg3 ;
44578 int arg4 ;
44579 PyObject *arg5 = (PyObject *) NULL ;
44580 wxSizerItem *result = 0 ;
44581 void *argp1 = 0 ;
44582 int res1 = 0 ;
44583 int val2 ;
44584 int ecode2 = 0 ;
44585 int val3 ;
44586 int ecode3 = 0 ;
44587 int val4 ;
44588 int ecode4 = 0 ;
44589 PyObject * obj0 = 0 ;
44590 PyObject * obj1 = 0 ;
44591 PyObject * obj2 = 0 ;
44592 PyObject * obj3 = 0 ;
44593 PyObject * obj4 = 0 ;
44594 char * kwnames[] = {
44595 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44596 };
44597
44598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44600 if (!SWIG_IsOK(res1)) {
44601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44602 }
44603 arg1 = reinterpret_cast< wxWindow * >(argp1);
44604 ecode2 = SWIG_AsVal_int(obj1, &val2);
44605 if (!SWIG_IsOK(ecode2)) {
44606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44607 }
44608 arg2 = static_cast< int >(val2);
44609 ecode3 = SWIG_AsVal_int(obj2, &val3);
44610 if (!SWIG_IsOK(ecode3)) {
44611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44612 }
44613 arg3 = static_cast< int >(val3);
44614 ecode4 = SWIG_AsVal_int(obj3, &val4);
44615 if (!SWIG_IsOK(ecode4)) {
44616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44617 }
44618 arg4 = static_cast< int >(val4);
44619 if (obj4) {
44620 arg5 = obj4;
44621 }
44622 {
44623 PyThreadState* __tstate = wxPyBeginAllowThreads();
44624 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44625 wxPyEndAllowThreads(__tstate);
44626 if (PyErr_Occurred()) SWIG_fail;
44627 }
44628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44629 return resultobj;
44630 fail:
44631 return NULL;
44632 }
44633
44634
44635 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44636 PyObject *resultobj = 0;
44637 int arg1 ;
44638 int arg2 ;
44639 int arg3 ;
44640 int arg4 ;
44641 int arg5 ;
44642 PyObject *arg6 = (PyObject *) NULL ;
44643 wxSizerItem *result = 0 ;
44644 int val1 ;
44645 int ecode1 = 0 ;
44646 int val2 ;
44647 int ecode2 = 0 ;
44648 int val3 ;
44649 int ecode3 = 0 ;
44650 int val4 ;
44651 int ecode4 = 0 ;
44652 int val5 ;
44653 int ecode5 = 0 ;
44654 PyObject * obj0 = 0 ;
44655 PyObject * obj1 = 0 ;
44656 PyObject * obj2 = 0 ;
44657 PyObject * obj3 = 0 ;
44658 PyObject * obj4 = 0 ;
44659 PyObject * obj5 = 0 ;
44660 char * kwnames[] = {
44661 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44662 };
44663
44664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44665 ecode1 = SWIG_AsVal_int(obj0, &val1);
44666 if (!SWIG_IsOK(ecode1)) {
44667 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44668 }
44669 arg1 = static_cast< int >(val1);
44670 ecode2 = SWIG_AsVal_int(obj1, &val2);
44671 if (!SWIG_IsOK(ecode2)) {
44672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44673 }
44674 arg2 = static_cast< int >(val2);
44675 ecode3 = SWIG_AsVal_int(obj2, &val3);
44676 if (!SWIG_IsOK(ecode3)) {
44677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44678 }
44679 arg3 = static_cast< int >(val3);
44680 ecode4 = SWIG_AsVal_int(obj3, &val4);
44681 if (!SWIG_IsOK(ecode4)) {
44682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44683 }
44684 arg4 = static_cast< int >(val4);
44685 ecode5 = SWIG_AsVal_int(obj4, &val5);
44686 if (!SWIG_IsOK(ecode5)) {
44687 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44688 }
44689 arg5 = static_cast< int >(val5);
44690 if (obj5) {
44691 arg6 = obj5;
44692 }
44693 {
44694 PyThreadState* __tstate = wxPyBeginAllowThreads();
44695 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44696 wxPyEndAllowThreads(__tstate);
44697 if (PyErr_Occurred()) SWIG_fail;
44698 }
44699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44700 return resultobj;
44701 fail:
44702 return NULL;
44703 }
44704
44705
44706 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44707 PyObject *resultobj = 0;
44708 wxSizer *arg1 = (wxSizer *) 0 ;
44709 int arg2 ;
44710 int arg3 ;
44711 int arg4 ;
44712 PyObject *arg5 = (PyObject *) NULL ;
44713 wxSizerItem *result = 0 ;
44714 int res1 = 0 ;
44715 int val2 ;
44716 int ecode2 = 0 ;
44717 int val3 ;
44718 int ecode3 = 0 ;
44719 int val4 ;
44720 int ecode4 = 0 ;
44721 PyObject * obj0 = 0 ;
44722 PyObject * obj1 = 0 ;
44723 PyObject * obj2 = 0 ;
44724 PyObject * obj3 = 0 ;
44725 PyObject * obj4 = 0 ;
44726 char * kwnames[] = {
44727 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44728 };
44729
44730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44731 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44732 if (!SWIG_IsOK(res1)) {
44733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44734 }
44735 ecode2 = SWIG_AsVal_int(obj1, &val2);
44736 if (!SWIG_IsOK(ecode2)) {
44737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44738 }
44739 arg2 = static_cast< int >(val2);
44740 ecode3 = SWIG_AsVal_int(obj2, &val3);
44741 if (!SWIG_IsOK(ecode3)) {
44742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44743 }
44744 arg3 = static_cast< int >(val3);
44745 ecode4 = SWIG_AsVal_int(obj3, &val4);
44746 if (!SWIG_IsOK(ecode4)) {
44747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44748 }
44749 arg4 = static_cast< int >(val4);
44750 if (obj4) {
44751 arg5 = obj4;
44752 }
44753 {
44754 PyThreadState* __tstate = wxPyBeginAllowThreads();
44755 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44756 wxPyEndAllowThreads(__tstate);
44757 if (PyErr_Occurred()) SWIG_fail;
44758 }
44759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44760 return resultobj;
44761 fail:
44762 return NULL;
44763 }
44764
44765
44766 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44767 PyObject *resultobj = 0;
44768 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44769 void *argp1 = 0 ;
44770 int res1 = 0 ;
44771 PyObject *swig_obj[1] ;
44772
44773 if (!args) SWIG_fail;
44774 swig_obj[0] = args;
44775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44776 if (!SWIG_IsOK(res1)) {
44777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44778 }
44779 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44780 {
44781 PyThreadState* __tstate = wxPyBeginAllowThreads();
44782 (arg1)->DeleteWindows();
44783 wxPyEndAllowThreads(__tstate);
44784 if (PyErr_Occurred()) SWIG_fail;
44785 }
44786 resultobj = SWIG_Py_Void();
44787 return resultobj;
44788 fail:
44789 return NULL;
44790 }
44791
44792
44793 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44794 PyObject *resultobj = 0;
44795 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44796 void *argp1 = 0 ;
44797 int res1 = 0 ;
44798 PyObject *swig_obj[1] ;
44799
44800 if (!args) SWIG_fail;
44801 swig_obj[0] = args;
44802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44803 if (!SWIG_IsOK(res1)) {
44804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44805 }
44806 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44807 {
44808 PyThreadState* __tstate = wxPyBeginAllowThreads();
44809 (arg1)->DetachSizer();
44810 wxPyEndAllowThreads(__tstate);
44811 if (PyErr_Occurred()) SWIG_fail;
44812 }
44813 resultobj = SWIG_Py_Void();
44814 return resultobj;
44815 fail:
44816 return NULL;
44817 }
44818
44819
44820 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44821 PyObject *resultobj = 0;
44822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44823 wxSize result;
44824 void *argp1 = 0 ;
44825 int res1 = 0 ;
44826 PyObject *swig_obj[1] ;
44827
44828 if (!args) SWIG_fail;
44829 swig_obj[0] = args;
44830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44831 if (!SWIG_IsOK(res1)) {
44832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44833 }
44834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44835 {
44836 PyThreadState* __tstate = wxPyBeginAllowThreads();
44837 result = (arg1)->GetSize();
44838 wxPyEndAllowThreads(__tstate);
44839 if (PyErr_Occurred()) SWIG_fail;
44840 }
44841 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44842 return resultobj;
44843 fail:
44844 return NULL;
44845 }
44846
44847
44848 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44849 PyObject *resultobj = 0;
44850 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44851 wxSize result;
44852 void *argp1 = 0 ;
44853 int res1 = 0 ;
44854 PyObject *swig_obj[1] ;
44855
44856 if (!args) SWIG_fail;
44857 swig_obj[0] = args;
44858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44859 if (!SWIG_IsOK(res1)) {
44860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44861 }
44862 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44863 {
44864 PyThreadState* __tstate = wxPyBeginAllowThreads();
44865 result = (arg1)->CalcMin();
44866 wxPyEndAllowThreads(__tstate);
44867 if (PyErr_Occurred()) SWIG_fail;
44868 }
44869 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44870 return resultobj;
44871 fail:
44872 return NULL;
44873 }
44874
44875
44876 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44877 PyObject *resultobj = 0;
44878 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44879 wxPoint *arg2 = 0 ;
44880 wxSize *arg3 = 0 ;
44881 void *argp1 = 0 ;
44882 int res1 = 0 ;
44883 wxPoint temp2 ;
44884 wxSize temp3 ;
44885 PyObject * obj0 = 0 ;
44886 PyObject * obj1 = 0 ;
44887 PyObject * obj2 = 0 ;
44888 char * kwnames[] = {
44889 (char *) "self",(char *) "pos",(char *) "size", NULL
44890 };
44891
44892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44894 if (!SWIG_IsOK(res1)) {
44895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44896 }
44897 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44898 {
44899 arg2 = &temp2;
44900 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44901 }
44902 {
44903 arg3 = &temp3;
44904 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44905 }
44906 {
44907 PyThreadState* __tstate = wxPyBeginAllowThreads();
44908 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44909 wxPyEndAllowThreads(__tstate);
44910 if (PyErr_Occurred()) SWIG_fail;
44911 }
44912 resultobj = SWIG_Py_Void();
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44920 PyObject *resultobj = 0;
44921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44922 wxSize result;
44923 void *argp1 = 0 ;
44924 int res1 = 0 ;
44925 PyObject *swig_obj[1] ;
44926
44927 if (!args) SWIG_fail;
44928 swig_obj[0] = args;
44929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44930 if (!SWIG_IsOK(res1)) {
44931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44932 }
44933 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44934 {
44935 PyThreadState* __tstate = wxPyBeginAllowThreads();
44936 result = (arg1)->GetMinSize();
44937 wxPyEndAllowThreads(__tstate);
44938 if (PyErr_Occurred()) SWIG_fail;
44939 }
44940 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44941 return resultobj;
44942 fail:
44943 return NULL;
44944 }
44945
44946
44947 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44948 PyObject *resultobj = 0;
44949 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44950 wxSize result;
44951 void *argp1 = 0 ;
44952 int res1 = 0 ;
44953 PyObject *swig_obj[1] ;
44954
44955 if (!args) SWIG_fail;
44956 swig_obj[0] = args;
44957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44958 if (!SWIG_IsOK(res1)) {
44959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
44960 }
44961 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44962 {
44963 PyThreadState* __tstate = wxPyBeginAllowThreads();
44964 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
44965 wxPyEndAllowThreads(__tstate);
44966 if (PyErr_Occurred()) SWIG_fail;
44967 }
44968 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44969 return resultobj;
44970 fail:
44971 return NULL;
44972 }
44973
44974
44975 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44976 PyObject *resultobj = 0;
44977 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44978 int arg2 ;
44979 int arg3 ;
44980 void *argp1 = 0 ;
44981 int res1 = 0 ;
44982 int val2 ;
44983 int ecode2 = 0 ;
44984 int val3 ;
44985 int ecode3 = 0 ;
44986 PyObject * obj0 = 0 ;
44987 PyObject * obj1 = 0 ;
44988 PyObject * obj2 = 0 ;
44989 char * kwnames[] = {
44990 (char *) "self",(char *) "x",(char *) "y", NULL
44991 };
44992
44993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44995 if (!SWIG_IsOK(res1)) {
44996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44997 }
44998 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44999 ecode2 = SWIG_AsVal_int(obj1, &val2);
45000 if (!SWIG_IsOK(ecode2)) {
45001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45002 }
45003 arg2 = static_cast< int >(val2);
45004 ecode3 = SWIG_AsVal_int(obj2, &val3);
45005 if (!SWIG_IsOK(ecode3)) {
45006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45007 }
45008 arg3 = static_cast< int >(val3);
45009 {
45010 PyThreadState* __tstate = wxPyBeginAllowThreads();
45011 (arg1)->SetInitSize(arg2,arg3);
45012 wxPyEndAllowThreads(__tstate);
45013 if (PyErr_Occurred()) SWIG_fail;
45014 }
45015 resultobj = SWIG_Py_Void();
45016 return resultobj;
45017 fail:
45018 return NULL;
45019 }
45020
45021
45022 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45023 PyObject *resultobj = 0;
45024 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45025 int arg2 ;
45026 int arg3 ;
45027 void *argp1 = 0 ;
45028 int res1 = 0 ;
45029 int val2 ;
45030 int ecode2 = 0 ;
45031 int val3 ;
45032 int ecode3 = 0 ;
45033 PyObject * obj0 = 0 ;
45034 PyObject * obj1 = 0 ;
45035 PyObject * obj2 = 0 ;
45036 char * kwnames[] = {
45037 (char *) "self",(char *) "width",(char *) "height", NULL
45038 };
45039
45040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45042 if (!SWIG_IsOK(res1)) {
45043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45044 }
45045 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45046 ecode2 = SWIG_AsVal_int(obj1, &val2);
45047 if (!SWIG_IsOK(ecode2)) {
45048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45049 }
45050 arg2 = static_cast< int >(val2);
45051 ecode3 = SWIG_AsVal_int(obj2, &val3);
45052 if (!SWIG_IsOK(ecode3)) {
45053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45054 }
45055 arg3 = static_cast< int >(val3);
45056 {
45057 PyThreadState* __tstate = wxPyBeginAllowThreads();
45058 (arg1)->SetRatio(arg2,arg3);
45059 wxPyEndAllowThreads(__tstate);
45060 if (PyErr_Occurred()) SWIG_fail;
45061 }
45062 resultobj = SWIG_Py_Void();
45063 return resultobj;
45064 fail:
45065 return NULL;
45066 }
45067
45068
45069 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45070 PyObject *resultobj = 0;
45071 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45072 wxSize *arg2 = 0 ;
45073 void *argp1 = 0 ;
45074 int res1 = 0 ;
45075 wxSize temp2 ;
45076 PyObject * obj0 = 0 ;
45077 PyObject * obj1 = 0 ;
45078 char * kwnames[] = {
45079 (char *) "self",(char *) "size", NULL
45080 };
45081
45082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45084 if (!SWIG_IsOK(res1)) {
45085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45086 }
45087 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45088 {
45089 arg2 = &temp2;
45090 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45091 }
45092 {
45093 PyThreadState* __tstate = wxPyBeginAllowThreads();
45094 (arg1)->SetRatio((wxSize const &)*arg2);
45095 wxPyEndAllowThreads(__tstate);
45096 if (PyErr_Occurred()) SWIG_fail;
45097 }
45098 resultobj = SWIG_Py_Void();
45099 return resultobj;
45100 fail:
45101 return NULL;
45102 }
45103
45104
45105 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45106 PyObject *resultobj = 0;
45107 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45108 float arg2 ;
45109 void *argp1 = 0 ;
45110 int res1 = 0 ;
45111 float val2 ;
45112 int ecode2 = 0 ;
45113 PyObject * obj0 = 0 ;
45114 PyObject * obj1 = 0 ;
45115 char * kwnames[] = {
45116 (char *) "self",(char *) "ratio", NULL
45117 };
45118
45119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45121 if (!SWIG_IsOK(res1)) {
45122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45123 }
45124 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45125 ecode2 = SWIG_AsVal_float(obj1, &val2);
45126 if (!SWIG_IsOK(ecode2)) {
45127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45128 }
45129 arg2 = static_cast< float >(val2);
45130 {
45131 PyThreadState* __tstate = wxPyBeginAllowThreads();
45132 (arg1)->SetRatio(arg2);
45133 wxPyEndAllowThreads(__tstate);
45134 if (PyErr_Occurred()) SWIG_fail;
45135 }
45136 resultobj = SWIG_Py_Void();
45137 return resultobj;
45138 fail:
45139 return NULL;
45140 }
45141
45142
45143 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45144 PyObject *resultobj = 0;
45145 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45146 float result;
45147 void *argp1 = 0 ;
45148 int res1 = 0 ;
45149 PyObject *swig_obj[1] ;
45150
45151 if (!args) SWIG_fail;
45152 swig_obj[0] = args;
45153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45154 if (!SWIG_IsOK(res1)) {
45155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45156 }
45157 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45158 {
45159 PyThreadState* __tstate = wxPyBeginAllowThreads();
45160 result = (float)(arg1)->GetRatio();
45161 wxPyEndAllowThreads(__tstate);
45162 if (PyErr_Occurred()) SWIG_fail;
45163 }
45164 resultobj = SWIG_From_float(static_cast< float >(result));
45165 return resultobj;
45166 fail:
45167 return NULL;
45168 }
45169
45170
45171 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45172 PyObject *resultobj = 0;
45173 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45174 wxRect result;
45175 void *argp1 = 0 ;
45176 int res1 = 0 ;
45177 PyObject *swig_obj[1] ;
45178
45179 if (!args) SWIG_fail;
45180 swig_obj[0] = args;
45181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45182 if (!SWIG_IsOK(res1)) {
45183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45184 }
45185 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45186 {
45187 PyThreadState* __tstate = wxPyBeginAllowThreads();
45188 result = (arg1)->GetRect();
45189 wxPyEndAllowThreads(__tstate);
45190 if (PyErr_Occurred()) SWIG_fail;
45191 }
45192 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45193 return resultobj;
45194 fail:
45195 return NULL;
45196 }
45197
45198
45199 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45200 PyObject *resultobj = 0;
45201 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45202 bool result;
45203 void *argp1 = 0 ;
45204 int res1 = 0 ;
45205 PyObject *swig_obj[1] ;
45206
45207 if (!args) SWIG_fail;
45208 swig_obj[0] = args;
45209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45210 if (!SWIG_IsOK(res1)) {
45211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45212 }
45213 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45214 {
45215 PyThreadState* __tstate = wxPyBeginAllowThreads();
45216 result = (bool)(arg1)->IsWindow();
45217 wxPyEndAllowThreads(__tstate);
45218 if (PyErr_Occurred()) SWIG_fail;
45219 }
45220 {
45221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45222 }
45223 return resultobj;
45224 fail:
45225 return NULL;
45226 }
45227
45228
45229 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45230 PyObject *resultobj = 0;
45231 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45232 bool result;
45233 void *argp1 = 0 ;
45234 int res1 = 0 ;
45235 PyObject *swig_obj[1] ;
45236
45237 if (!args) SWIG_fail;
45238 swig_obj[0] = args;
45239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45240 if (!SWIG_IsOK(res1)) {
45241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45242 }
45243 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45244 {
45245 PyThreadState* __tstate = wxPyBeginAllowThreads();
45246 result = (bool)(arg1)->IsSizer();
45247 wxPyEndAllowThreads(__tstate);
45248 if (PyErr_Occurred()) SWIG_fail;
45249 }
45250 {
45251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45252 }
45253 return resultobj;
45254 fail:
45255 return NULL;
45256 }
45257
45258
45259 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45260 PyObject *resultobj = 0;
45261 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45262 bool result;
45263 void *argp1 = 0 ;
45264 int res1 = 0 ;
45265 PyObject *swig_obj[1] ;
45266
45267 if (!args) SWIG_fail;
45268 swig_obj[0] = args;
45269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45270 if (!SWIG_IsOK(res1)) {
45271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45272 }
45273 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45274 {
45275 PyThreadState* __tstate = wxPyBeginAllowThreads();
45276 result = (bool)(arg1)->IsSpacer();
45277 wxPyEndAllowThreads(__tstate);
45278 if (PyErr_Occurred()) SWIG_fail;
45279 }
45280 {
45281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45282 }
45283 return resultobj;
45284 fail:
45285 return NULL;
45286 }
45287
45288
45289 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45290 PyObject *resultobj = 0;
45291 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45292 int arg2 ;
45293 void *argp1 = 0 ;
45294 int res1 = 0 ;
45295 int val2 ;
45296 int ecode2 = 0 ;
45297 PyObject * obj0 = 0 ;
45298 PyObject * obj1 = 0 ;
45299 char * kwnames[] = {
45300 (char *) "self",(char *) "proportion", NULL
45301 };
45302
45303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45305 if (!SWIG_IsOK(res1)) {
45306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45307 }
45308 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45309 ecode2 = SWIG_AsVal_int(obj1, &val2);
45310 if (!SWIG_IsOK(ecode2)) {
45311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45312 }
45313 arg2 = static_cast< int >(val2);
45314 {
45315 PyThreadState* __tstate = wxPyBeginAllowThreads();
45316 (arg1)->SetProportion(arg2);
45317 wxPyEndAllowThreads(__tstate);
45318 if (PyErr_Occurred()) SWIG_fail;
45319 }
45320 resultobj = SWIG_Py_Void();
45321 return resultobj;
45322 fail:
45323 return NULL;
45324 }
45325
45326
45327 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45328 PyObject *resultobj = 0;
45329 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45330 int result;
45331 void *argp1 = 0 ;
45332 int res1 = 0 ;
45333 PyObject *swig_obj[1] ;
45334
45335 if (!args) SWIG_fail;
45336 swig_obj[0] = args;
45337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45338 if (!SWIG_IsOK(res1)) {
45339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45340 }
45341 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45342 {
45343 PyThreadState* __tstate = wxPyBeginAllowThreads();
45344 result = (int)(arg1)->GetProportion();
45345 wxPyEndAllowThreads(__tstate);
45346 if (PyErr_Occurred()) SWIG_fail;
45347 }
45348 resultobj = SWIG_From_int(static_cast< int >(result));
45349 return resultobj;
45350 fail:
45351 return NULL;
45352 }
45353
45354
45355 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45356 PyObject *resultobj = 0;
45357 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45358 int arg2 ;
45359 void *argp1 = 0 ;
45360 int res1 = 0 ;
45361 int val2 ;
45362 int ecode2 = 0 ;
45363 PyObject * obj0 = 0 ;
45364 PyObject * obj1 = 0 ;
45365 char * kwnames[] = {
45366 (char *) "self",(char *) "flag", NULL
45367 };
45368
45369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45371 if (!SWIG_IsOK(res1)) {
45372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45373 }
45374 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45375 ecode2 = SWIG_AsVal_int(obj1, &val2);
45376 if (!SWIG_IsOK(ecode2)) {
45377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45378 }
45379 arg2 = static_cast< int >(val2);
45380 {
45381 PyThreadState* __tstate = wxPyBeginAllowThreads();
45382 (arg1)->SetFlag(arg2);
45383 wxPyEndAllowThreads(__tstate);
45384 if (PyErr_Occurred()) SWIG_fail;
45385 }
45386 resultobj = SWIG_Py_Void();
45387 return resultobj;
45388 fail:
45389 return NULL;
45390 }
45391
45392
45393 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45394 PyObject *resultobj = 0;
45395 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45396 int result;
45397 void *argp1 = 0 ;
45398 int res1 = 0 ;
45399 PyObject *swig_obj[1] ;
45400
45401 if (!args) SWIG_fail;
45402 swig_obj[0] = args;
45403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45404 if (!SWIG_IsOK(res1)) {
45405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45406 }
45407 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45408 {
45409 PyThreadState* __tstate = wxPyBeginAllowThreads();
45410 result = (int)(arg1)->GetFlag();
45411 wxPyEndAllowThreads(__tstate);
45412 if (PyErr_Occurred()) SWIG_fail;
45413 }
45414 resultobj = SWIG_From_int(static_cast< int >(result));
45415 return resultobj;
45416 fail:
45417 return NULL;
45418 }
45419
45420
45421 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45422 PyObject *resultobj = 0;
45423 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45424 int arg2 ;
45425 void *argp1 = 0 ;
45426 int res1 = 0 ;
45427 int val2 ;
45428 int ecode2 = 0 ;
45429 PyObject * obj0 = 0 ;
45430 PyObject * obj1 = 0 ;
45431 char * kwnames[] = {
45432 (char *) "self",(char *) "border", NULL
45433 };
45434
45435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45437 if (!SWIG_IsOK(res1)) {
45438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45439 }
45440 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45441 ecode2 = SWIG_AsVal_int(obj1, &val2);
45442 if (!SWIG_IsOK(ecode2)) {
45443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45444 }
45445 arg2 = static_cast< int >(val2);
45446 {
45447 PyThreadState* __tstate = wxPyBeginAllowThreads();
45448 (arg1)->SetBorder(arg2);
45449 wxPyEndAllowThreads(__tstate);
45450 if (PyErr_Occurred()) SWIG_fail;
45451 }
45452 resultobj = SWIG_Py_Void();
45453 return resultobj;
45454 fail:
45455 return NULL;
45456 }
45457
45458
45459 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45460 PyObject *resultobj = 0;
45461 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45462 int result;
45463 void *argp1 = 0 ;
45464 int res1 = 0 ;
45465 PyObject *swig_obj[1] ;
45466
45467 if (!args) SWIG_fail;
45468 swig_obj[0] = args;
45469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45470 if (!SWIG_IsOK(res1)) {
45471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45472 }
45473 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45474 {
45475 PyThreadState* __tstate = wxPyBeginAllowThreads();
45476 result = (int)(arg1)->GetBorder();
45477 wxPyEndAllowThreads(__tstate);
45478 if (PyErr_Occurred()) SWIG_fail;
45479 }
45480 resultobj = SWIG_From_int(static_cast< int >(result));
45481 return resultobj;
45482 fail:
45483 return NULL;
45484 }
45485
45486
45487 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45488 PyObject *resultobj = 0;
45489 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45490 wxWindow *result = 0 ;
45491 void *argp1 = 0 ;
45492 int res1 = 0 ;
45493 PyObject *swig_obj[1] ;
45494
45495 if (!args) SWIG_fail;
45496 swig_obj[0] = args;
45497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45498 if (!SWIG_IsOK(res1)) {
45499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45500 }
45501 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45502 {
45503 PyThreadState* __tstate = wxPyBeginAllowThreads();
45504 result = (wxWindow *)(arg1)->GetWindow();
45505 wxPyEndAllowThreads(__tstate);
45506 if (PyErr_Occurred()) SWIG_fail;
45507 }
45508 {
45509 resultobj = wxPyMake_wxObject(result, 0);
45510 }
45511 return resultobj;
45512 fail:
45513 return NULL;
45514 }
45515
45516
45517 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45518 PyObject *resultobj = 0;
45519 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45520 wxWindow *arg2 = (wxWindow *) 0 ;
45521 void *argp1 = 0 ;
45522 int res1 = 0 ;
45523 void *argp2 = 0 ;
45524 int res2 = 0 ;
45525 PyObject * obj0 = 0 ;
45526 PyObject * obj1 = 0 ;
45527 char * kwnames[] = {
45528 (char *) "self",(char *) "window", NULL
45529 };
45530
45531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45533 if (!SWIG_IsOK(res1)) {
45534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45535 }
45536 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45537 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45538 if (!SWIG_IsOK(res2)) {
45539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45540 }
45541 arg2 = reinterpret_cast< wxWindow * >(argp2);
45542 {
45543 PyThreadState* __tstate = wxPyBeginAllowThreads();
45544 (arg1)->SetWindow(arg2);
45545 wxPyEndAllowThreads(__tstate);
45546 if (PyErr_Occurred()) SWIG_fail;
45547 }
45548 resultobj = SWIG_Py_Void();
45549 return resultobj;
45550 fail:
45551 return NULL;
45552 }
45553
45554
45555 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45556 PyObject *resultobj = 0;
45557 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45558 wxSizer *result = 0 ;
45559 void *argp1 = 0 ;
45560 int res1 = 0 ;
45561 PyObject *swig_obj[1] ;
45562
45563 if (!args) SWIG_fail;
45564 swig_obj[0] = args;
45565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45566 if (!SWIG_IsOK(res1)) {
45567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45568 }
45569 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45570 {
45571 PyThreadState* __tstate = wxPyBeginAllowThreads();
45572 result = (wxSizer *)(arg1)->GetSizer();
45573 wxPyEndAllowThreads(__tstate);
45574 if (PyErr_Occurred()) SWIG_fail;
45575 }
45576 {
45577 resultobj = wxPyMake_wxObject(result, (bool)0);
45578 }
45579 return resultobj;
45580 fail:
45581 return NULL;
45582 }
45583
45584
45585 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45586 PyObject *resultobj = 0;
45587 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45588 wxSizer *arg2 = (wxSizer *) 0 ;
45589 void *argp1 = 0 ;
45590 int res1 = 0 ;
45591 int res2 = 0 ;
45592 PyObject * obj0 = 0 ;
45593 PyObject * obj1 = 0 ;
45594 char * kwnames[] = {
45595 (char *) "self",(char *) "sizer", NULL
45596 };
45597
45598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45600 if (!SWIG_IsOK(res1)) {
45601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45602 }
45603 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45604 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45605 if (!SWIG_IsOK(res2)) {
45606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45607 }
45608 {
45609 PyThreadState* __tstate = wxPyBeginAllowThreads();
45610 (arg1)->SetSizer(arg2);
45611 wxPyEndAllowThreads(__tstate);
45612 if (PyErr_Occurred()) SWIG_fail;
45613 }
45614 resultobj = SWIG_Py_Void();
45615 return resultobj;
45616 fail:
45617 return NULL;
45618 }
45619
45620
45621 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45622 PyObject *resultobj = 0;
45623 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45624 wxSize *result = 0 ;
45625 void *argp1 = 0 ;
45626 int res1 = 0 ;
45627 PyObject *swig_obj[1] ;
45628
45629 if (!args) SWIG_fail;
45630 swig_obj[0] = args;
45631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45632 if (!SWIG_IsOK(res1)) {
45633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45634 }
45635 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45636 {
45637 PyThreadState* __tstate = wxPyBeginAllowThreads();
45638 {
45639 wxSize const &_result_ref = (arg1)->GetSpacer();
45640 result = (wxSize *) &_result_ref;
45641 }
45642 wxPyEndAllowThreads(__tstate);
45643 if (PyErr_Occurred()) SWIG_fail;
45644 }
45645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45646 return resultobj;
45647 fail:
45648 return NULL;
45649 }
45650
45651
45652 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45653 PyObject *resultobj = 0;
45654 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45655 wxSize *arg2 = 0 ;
45656 void *argp1 = 0 ;
45657 int res1 = 0 ;
45658 wxSize temp2 ;
45659 PyObject * obj0 = 0 ;
45660 PyObject * obj1 = 0 ;
45661 char * kwnames[] = {
45662 (char *) "self",(char *) "size", NULL
45663 };
45664
45665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45667 if (!SWIG_IsOK(res1)) {
45668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45669 }
45670 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45671 {
45672 arg2 = &temp2;
45673 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45674 }
45675 {
45676 PyThreadState* __tstate = wxPyBeginAllowThreads();
45677 (arg1)->SetSpacer((wxSize const &)*arg2);
45678 wxPyEndAllowThreads(__tstate);
45679 if (PyErr_Occurred()) SWIG_fail;
45680 }
45681 resultobj = SWIG_Py_Void();
45682 return resultobj;
45683 fail:
45684 return NULL;
45685 }
45686
45687
45688 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45689 PyObject *resultobj = 0;
45690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45691 bool arg2 ;
45692 void *argp1 = 0 ;
45693 int res1 = 0 ;
45694 bool val2 ;
45695 int ecode2 = 0 ;
45696 PyObject * obj0 = 0 ;
45697 PyObject * obj1 = 0 ;
45698 char * kwnames[] = {
45699 (char *) "self",(char *) "show", NULL
45700 };
45701
45702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45704 if (!SWIG_IsOK(res1)) {
45705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45706 }
45707 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45708 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45709 if (!SWIG_IsOK(ecode2)) {
45710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45711 }
45712 arg2 = static_cast< bool >(val2);
45713 {
45714 PyThreadState* __tstate = wxPyBeginAllowThreads();
45715 (arg1)->Show(arg2);
45716 wxPyEndAllowThreads(__tstate);
45717 if (PyErr_Occurred()) SWIG_fail;
45718 }
45719 resultobj = SWIG_Py_Void();
45720 return resultobj;
45721 fail:
45722 return NULL;
45723 }
45724
45725
45726 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45727 PyObject *resultobj = 0;
45728 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45729 bool result;
45730 void *argp1 = 0 ;
45731 int res1 = 0 ;
45732 PyObject *swig_obj[1] ;
45733
45734 if (!args) SWIG_fail;
45735 swig_obj[0] = args;
45736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45737 if (!SWIG_IsOK(res1)) {
45738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45739 }
45740 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45741 {
45742 PyThreadState* __tstate = wxPyBeginAllowThreads();
45743 result = (bool)(arg1)->IsShown();
45744 wxPyEndAllowThreads(__tstate);
45745 if (PyErr_Occurred()) SWIG_fail;
45746 }
45747 {
45748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45749 }
45750 return resultobj;
45751 fail:
45752 return NULL;
45753 }
45754
45755
45756 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45757 PyObject *resultobj = 0;
45758 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45759 wxPoint result;
45760 void *argp1 = 0 ;
45761 int res1 = 0 ;
45762 PyObject *swig_obj[1] ;
45763
45764 if (!args) SWIG_fail;
45765 swig_obj[0] = args;
45766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45767 if (!SWIG_IsOK(res1)) {
45768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45769 }
45770 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45771 {
45772 PyThreadState* __tstate = wxPyBeginAllowThreads();
45773 result = (arg1)->GetPosition();
45774 wxPyEndAllowThreads(__tstate);
45775 if (PyErr_Occurred()) SWIG_fail;
45776 }
45777 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45778 return resultobj;
45779 fail:
45780 return NULL;
45781 }
45782
45783
45784 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45785 PyObject *resultobj = 0;
45786 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45787 PyObject *result = 0 ;
45788 void *argp1 = 0 ;
45789 int res1 = 0 ;
45790 PyObject *swig_obj[1] ;
45791
45792 if (!args) SWIG_fail;
45793 swig_obj[0] = args;
45794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45795 if (!SWIG_IsOK(res1)) {
45796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45797 }
45798 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45799 {
45800 PyThreadState* __tstate = wxPyBeginAllowThreads();
45801 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45802 wxPyEndAllowThreads(__tstate);
45803 if (PyErr_Occurred()) SWIG_fail;
45804 }
45805 resultobj = result;
45806 return resultobj;
45807 fail:
45808 return NULL;
45809 }
45810
45811
45812 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45813 PyObject *resultobj = 0;
45814 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45815 PyObject *arg2 = (PyObject *) 0 ;
45816 void *argp1 = 0 ;
45817 int res1 = 0 ;
45818 PyObject * obj0 = 0 ;
45819 PyObject * obj1 = 0 ;
45820 char * kwnames[] = {
45821 (char *) "self",(char *) "userData", NULL
45822 };
45823
45824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45826 if (!SWIG_IsOK(res1)) {
45827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45828 }
45829 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45830 arg2 = obj1;
45831 {
45832 PyThreadState* __tstate = wxPyBeginAllowThreads();
45833 wxSizerItem_SetUserData(arg1,arg2);
45834 wxPyEndAllowThreads(__tstate);
45835 if (PyErr_Occurred()) SWIG_fail;
45836 }
45837 resultobj = SWIG_Py_Void();
45838 return resultobj;
45839 fail:
45840 return NULL;
45841 }
45842
45843
45844 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45845 PyObject *obj;
45846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45847 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45848 return SWIG_Py_Void();
45849 }
45850
45851 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45852 return SWIG_Python_InitShadowInstance(args);
45853 }
45854
45855 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45856 PyObject *resultobj = 0;
45857 wxSizer *arg1 = (wxSizer *) 0 ;
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_wxSizer, SWIG_POINTER_DISOWN | 0 );
45865 if (!SWIG_IsOK(res1)) {
45866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45867 }
45868 arg1 = reinterpret_cast< wxSizer * >(argp1);
45869 {
45870 PyThreadState* __tstate = wxPyBeginAllowThreads();
45871 delete arg1;
45872
45873 wxPyEndAllowThreads(__tstate);
45874 if (PyErr_Occurred()) SWIG_fail;
45875 }
45876 resultobj = SWIG_Py_Void();
45877 return resultobj;
45878 fail:
45879 return NULL;
45880 }
45881
45882
45883 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45884 PyObject *resultobj = 0;
45885 wxSizer *arg1 = (wxSizer *) 0 ;
45886 PyObject *arg2 = (PyObject *) 0 ;
45887 void *argp1 = 0 ;
45888 int res1 = 0 ;
45889 PyObject * obj0 = 0 ;
45890 PyObject * obj1 = 0 ;
45891 char * kwnames[] = {
45892 (char *) "self",(char *) "_self", NULL
45893 };
45894
45895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45897 if (!SWIG_IsOK(res1)) {
45898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45899 }
45900 arg1 = reinterpret_cast< wxSizer * >(argp1);
45901 arg2 = obj1;
45902 {
45903 PyThreadState* __tstate = wxPyBeginAllowThreads();
45904 wxSizer__setOORInfo(arg1,arg2);
45905 wxPyEndAllowThreads(__tstate);
45906 if (PyErr_Occurred()) SWIG_fail;
45907 }
45908 resultobj = SWIG_Py_Void();
45909 return resultobj;
45910 fail:
45911 return NULL;
45912 }
45913
45914
45915 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45916 PyObject *resultobj = 0;
45917 wxSizer *arg1 = (wxSizer *) 0 ;
45918 PyObject *arg2 = (PyObject *) 0 ;
45919 int arg3 = (int) 0 ;
45920 int arg4 = (int) 0 ;
45921 int arg5 = (int) 0 ;
45922 PyObject *arg6 = (PyObject *) NULL ;
45923 wxSizerItem *result = 0 ;
45924 void *argp1 = 0 ;
45925 int res1 = 0 ;
45926 int val3 ;
45927 int ecode3 = 0 ;
45928 int val4 ;
45929 int ecode4 = 0 ;
45930 int val5 ;
45931 int ecode5 = 0 ;
45932 PyObject * obj0 = 0 ;
45933 PyObject * obj1 = 0 ;
45934 PyObject * obj2 = 0 ;
45935 PyObject * obj3 = 0 ;
45936 PyObject * obj4 = 0 ;
45937 PyObject * obj5 = 0 ;
45938 char * kwnames[] = {
45939 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45940 };
45941
45942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45944 if (!SWIG_IsOK(res1)) {
45945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
45946 }
45947 arg1 = reinterpret_cast< wxSizer * >(argp1);
45948 arg2 = obj1;
45949 if (obj2) {
45950 ecode3 = SWIG_AsVal_int(obj2, &val3);
45951 if (!SWIG_IsOK(ecode3)) {
45952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
45953 }
45954 arg3 = static_cast< int >(val3);
45955 }
45956 if (obj3) {
45957 ecode4 = SWIG_AsVal_int(obj3, &val4);
45958 if (!SWIG_IsOK(ecode4)) {
45959 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
45960 }
45961 arg4 = static_cast< int >(val4);
45962 }
45963 if (obj4) {
45964 ecode5 = SWIG_AsVal_int(obj4, &val5);
45965 if (!SWIG_IsOK(ecode5)) {
45966 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
45967 }
45968 arg5 = static_cast< int >(val5);
45969 }
45970 if (obj5) {
45971 arg6 = obj5;
45972 }
45973 {
45974 PyThreadState* __tstate = wxPyBeginAllowThreads();
45975 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
45976 wxPyEndAllowThreads(__tstate);
45977 if (PyErr_Occurred()) SWIG_fail;
45978 }
45979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45980 return resultobj;
45981 fail:
45982 return NULL;
45983 }
45984
45985
45986 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45987 PyObject *resultobj = 0;
45988 wxSizer *arg1 = (wxSizer *) 0 ;
45989 int arg2 ;
45990 PyObject *arg3 = (PyObject *) 0 ;
45991 int arg4 = (int) 0 ;
45992 int arg5 = (int) 0 ;
45993 int arg6 = (int) 0 ;
45994 PyObject *arg7 = (PyObject *) NULL ;
45995 wxSizerItem *result = 0 ;
45996 void *argp1 = 0 ;
45997 int res1 = 0 ;
45998 int val2 ;
45999 int ecode2 = 0 ;
46000 int val4 ;
46001 int ecode4 = 0 ;
46002 int val5 ;
46003 int ecode5 = 0 ;
46004 int val6 ;
46005 int ecode6 = 0 ;
46006 PyObject * obj0 = 0 ;
46007 PyObject * obj1 = 0 ;
46008 PyObject * obj2 = 0 ;
46009 PyObject * obj3 = 0 ;
46010 PyObject * obj4 = 0 ;
46011 PyObject * obj5 = 0 ;
46012 PyObject * obj6 = 0 ;
46013 char * kwnames[] = {
46014 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46015 };
46016
46017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46019 if (!SWIG_IsOK(res1)) {
46020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46021 }
46022 arg1 = reinterpret_cast< wxSizer * >(argp1);
46023 ecode2 = SWIG_AsVal_int(obj1, &val2);
46024 if (!SWIG_IsOK(ecode2)) {
46025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46026 }
46027 arg2 = static_cast< int >(val2);
46028 arg3 = obj2;
46029 if (obj3) {
46030 ecode4 = SWIG_AsVal_int(obj3, &val4);
46031 if (!SWIG_IsOK(ecode4)) {
46032 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46033 }
46034 arg4 = static_cast< int >(val4);
46035 }
46036 if (obj4) {
46037 ecode5 = SWIG_AsVal_int(obj4, &val5);
46038 if (!SWIG_IsOK(ecode5)) {
46039 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46040 }
46041 arg5 = static_cast< int >(val5);
46042 }
46043 if (obj5) {
46044 ecode6 = SWIG_AsVal_int(obj5, &val6);
46045 if (!SWIG_IsOK(ecode6)) {
46046 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46047 }
46048 arg6 = static_cast< int >(val6);
46049 }
46050 if (obj6) {
46051 arg7 = obj6;
46052 }
46053 {
46054 PyThreadState* __tstate = wxPyBeginAllowThreads();
46055 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46056 wxPyEndAllowThreads(__tstate);
46057 if (PyErr_Occurred()) SWIG_fail;
46058 }
46059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46060 return resultobj;
46061 fail:
46062 return NULL;
46063 }
46064
46065
46066 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46067 PyObject *resultobj = 0;
46068 wxSizer *arg1 = (wxSizer *) 0 ;
46069 PyObject *arg2 = (PyObject *) 0 ;
46070 int arg3 = (int) 0 ;
46071 int arg4 = (int) 0 ;
46072 int arg5 = (int) 0 ;
46073 PyObject *arg6 = (PyObject *) NULL ;
46074 wxSizerItem *result = 0 ;
46075 void *argp1 = 0 ;
46076 int res1 = 0 ;
46077 int val3 ;
46078 int ecode3 = 0 ;
46079 int val4 ;
46080 int ecode4 = 0 ;
46081 int val5 ;
46082 int ecode5 = 0 ;
46083 PyObject * obj0 = 0 ;
46084 PyObject * obj1 = 0 ;
46085 PyObject * obj2 = 0 ;
46086 PyObject * obj3 = 0 ;
46087 PyObject * obj4 = 0 ;
46088 PyObject * obj5 = 0 ;
46089 char * kwnames[] = {
46090 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46091 };
46092
46093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46095 if (!SWIG_IsOK(res1)) {
46096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46097 }
46098 arg1 = reinterpret_cast< wxSizer * >(argp1);
46099 arg2 = obj1;
46100 if (obj2) {
46101 ecode3 = SWIG_AsVal_int(obj2, &val3);
46102 if (!SWIG_IsOK(ecode3)) {
46103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46104 }
46105 arg3 = static_cast< int >(val3);
46106 }
46107 if (obj3) {
46108 ecode4 = SWIG_AsVal_int(obj3, &val4);
46109 if (!SWIG_IsOK(ecode4)) {
46110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46111 }
46112 arg4 = static_cast< int >(val4);
46113 }
46114 if (obj4) {
46115 ecode5 = SWIG_AsVal_int(obj4, &val5);
46116 if (!SWIG_IsOK(ecode5)) {
46117 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46118 }
46119 arg5 = static_cast< int >(val5);
46120 }
46121 if (obj5) {
46122 arg6 = obj5;
46123 }
46124 {
46125 PyThreadState* __tstate = wxPyBeginAllowThreads();
46126 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46127 wxPyEndAllowThreads(__tstate);
46128 if (PyErr_Occurred()) SWIG_fail;
46129 }
46130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46131 return resultobj;
46132 fail:
46133 return NULL;
46134 }
46135
46136
46137 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46138 PyObject *resultobj = 0;
46139 wxSizer *arg1 = (wxSizer *) 0 ;
46140 PyObject *arg2 = (PyObject *) 0 ;
46141 bool result;
46142 void *argp1 = 0 ;
46143 int res1 = 0 ;
46144 PyObject * obj0 = 0 ;
46145 PyObject * obj1 = 0 ;
46146 char * kwnames[] = {
46147 (char *) "self",(char *) "item", NULL
46148 };
46149
46150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46152 if (!SWIG_IsOK(res1)) {
46153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46154 }
46155 arg1 = reinterpret_cast< wxSizer * >(argp1);
46156 arg2 = obj1;
46157 {
46158 PyThreadState* __tstate = wxPyBeginAllowThreads();
46159 result = (bool)wxSizer_Remove(arg1,arg2);
46160 wxPyEndAllowThreads(__tstate);
46161 if (PyErr_Occurred()) SWIG_fail;
46162 }
46163 {
46164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46165 }
46166 return resultobj;
46167 fail:
46168 return NULL;
46169 }
46170
46171
46172 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46173 PyObject *resultobj = 0;
46174 wxSizer *arg1 = (wxSizer *) 0 ;
46175 PyObject *arg2 = (PyObject *) 0 ;
46176 bool result;
46177 void *argp1 = 0 ;
46178 int res1 = 0 ;
46179 PyObject * obj0 = 0 ;
46180 PyObject * obj1 = 0 ;
46181 char * kwnames[] = {
46182 (char *) "self",(char *) "item", NULL
46183 };
46184
46185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46187 if (!SWIG_IsOK(res1)) {
46188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46189 }
46190 arg1 = reinterpret_cast< wxSizer * >(argp1);
46191 arg2 = obj1;
46192 {
46193 PyThreadState* __tstate = wxPyBeginAllowThreads();
46194 result = (bool)wxSizer_Detach(arg1,arg2);
46195 wxPyEndAllowThreads(__tstate);
46196 if (PyErr_Occurred()) SWIG_fail;
46197 }
46198 {
46199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46200 }
46201 return resultobj;
46202 fail:
46203 return NULL;
46204 }
46205
46206
46207 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46208 PyObject *resultobj = 0;
46209 wxSizer *arg1 = (wxSizer *) 0 ;
46210 PyObject *arg2 = (PyObject *) 0 ;
46211 wxSizerItem *result = 0 ;
46212 void *argp1 = 0 ;
46213 int res1 = 0 ;
46214 PyObject * obj0 = 0 ;
46215 PyObject * obj1 = 0 ;
46216 char * kwnames[] = {
46217 (char *) "self",(char *) "item", NULL
46218 };
46219
46220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46222 if (!SWIG_IsOK(res1)) {
46223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46224 }
46225 arg1 = reinterpret_cast< wxSizer * >(argp1);
46226 arg2 = obj1;
46227 {
46228 PyThreadState* __tstate = wxPyBeginAllowThreads();
46229 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46230 wxPyEndAllowThreads(__tstate);
46231 if (PyErr_Occurred()) SWIG_fail;
46232 }
46233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46234 return resultobj;
46235 fail:
46236 return NULL;
46237 }
46238
46239
46240 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46241 PyObject *resultobj = 0;
46242 wxSizer *arg1 = (wxSizer *) 0 ;
46243 PyObject *arg2 = (PyObject *) 0 ;
46244 wxSize *arg3 = 0 ;
46245 void *argp1 = 0 ;
46246 int res1 = 0 ;
46247 wxSize temp3 ;
46248 PyObject * obj0 = 0 ;
46249 PyObject * obj1 = 0 ;
46250 PyObject * obj2 = 0 ;
46251 char * kwnames[] = {
46252 (char *) "self",(char *) "item",(char *) "size", NULL
46253 };
46254
46255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46257 if (!SWIG_IsOK(res1)) {
46258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46259 }
46260 arg1 = reinterpret_cast< wxSizer * >(argp1);
46261 arg2 = obj1;
46262 {
46263 arg3 = &temp3;
46264 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46265 }
46266 {
46267 PyThreadState* __tstate = wxPyBeginAllowThreads();
46268 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46269 wxPyEndAllowThreads(__tstate);
46270 if (PyErr_Occurred()) SWIG_fail;
46271 }
46272 resultobj = SWIG_Py_Void();
46273 return resultobj;
46274 fail:
46275 return NULL;
46276 }
46277
46278
46279 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46280 PyObject *resultobj = 0;
46281 wxSizer *arg1 = (wxSizer *) 0 ;
46282 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46283 wxSizerItem *result = 0 ;
46284 void *argp1 = 0 ;
46285 int res1 = 0 ;
46286 int res2 = 0 ;
46287 PyObject * obj0 = 0 ;
46288 PyObject * obj1 = 0 ;
46289 char * kwnames[] = {
46290 (char *) "self",(char *) "item", NULL
46291 };
46292
46293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46295 if (!SWIG_IsOK(res1)) {
46296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46297 }
46298 arg1 = reinterpret_cast< wxSizer * >(argp1);
46299 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46300 if (!SWIG_IsOK(res2)) {
46301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46302 }
46303 {
46304 PyThreadState* __tstate = wxPyBeginAllowThreads();
46305 result = (wxSizerItem *)(arg1)->Add(arg2);
46306 wxPyEndAllowThreads(__tstate);
46307 if (PyErr_Occurred()) SWIG_fail;
46308 }
46309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46310 return resultobj;
46311 fail:
46312 return NULL;
46313 }
46314
46315
46316 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46317 PyObject *resultobj = 0;
46318 wxSizer *arg1 = (wxSizer *) 0 ;
46319 size_t arg2 ;
46320 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46321 wxSizerItem *result = 0 ;
46322 void *argp1 = 0 ;
46323 int res1 = 0 ;
46324 size_t val2 ;
46325 int ecode2 = 0 ;
46326 int res3 = 0 ;
46327 PyObject * obj0 = 0 ;
46328 PyObject * obj1 = 0 ;
46329 PyObject * obj2 = 0 ;
46330 char * kwnames[] = {
46331 (char *) "self",(char *) "index",(char *) "item", NULL
46332 };
46333
46334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46336 if (!SWIG_IsOK(res1)) {
46337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46338 }
46339 arg1 = reinterpret_cast< wxSizer * >(argp1);
46340 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46341 if (!SWIG_IsOK(ecode2)) {
46342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46343 }
46344 arg2 = static_cast< size_t >(val2);
46345 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46346 if (!SWIG_IsOK(res3)) {
46347 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46348 }
46349 {
46350 PyThreadState* __tstate = wxPyBeginAllowThreads();
46351 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46352 wxPyEndAllowThreads(__tstate);
46353 if (PyErr_Occurred()) SWIG_fail;
46354 }
46355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46356 return resultobj;
46357 fail:
46358 return NULL;
46359 }
46360
46361
46362 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46363 PyObject *resultobj = 0;
46364 wxSizer *arg1 = (wxSizer *) 0 ;
46365 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46366 wxSizerItem *result = 0 ;
46367 void *argp1 = 0 ;
46368 int res1 = 0 ;
46369 int res2 = 0 ;
46370 PyObject * obj0 = 0 ;
46371 PyObject * obj1 = 0 ;
46372 char * kwnames[] = {
46373 (char *) "self",(char *) "item", NULL
46374 };
46375
46376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46378 if (!SWIG_IsOK(res1)) {
46379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46380 }
46381 arg1 = reinterpret_cast< wxSizer * >(argp1);
46382 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46383 if (!SWIG_IsOK(res2)) {
46384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46385 }
46386 {
46387 PyThreadState* __tstate = wxPyBeginAllowThreads();
46388 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46389 wxPyEndAllowThreads(__tstate);
46390 if (PyErr_Occurred()) SWIG_fail;
46391 }
46392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46393 return resultobj;
46394 fail:
46395 return NULL;
46396 }
46397
46398
46399 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46400 PyObject *resultobj = 0;
46401 wxSizer *arg1 = (wxSizer *) 0 ;
46402 int arg2 ;
46403 int arg3 ;
46404 int arg4 ;
46405 int arg5 ;
46406 void *argp1 = 0 ;
46407 int res1 = 0 ;
46408 int val2 ;
46409 int ecode2 = 0 ;
46410 int val3 ;
46411 int ecode3 = 0 ;
46412 int val4 ;
46413 int ecode4 = 0 ;
46414 int val5 ;
46415 int ecode5 = 0 ;
46416 PyObject * obj0 = 0 ;
46417 PyObject * obj1 = 0 ;
46418 PyObject * obj2 = 0 ;
46419 PyObject * obj3 = 0 ;
46420 PyObject * obj4 = 0 ;
46421 char * kwnames[] = {
46422 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46423 };
46424
46425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46427 if (!SWIG_IsOK(res1)) {
46428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46429 }
46430 arg1 = reinterpret_cast< wxSizer * >(argp1);
46431 ecode2 = SWIG_AsVal_int(obj1, &val2);
46432 if (!SWIG_IsOK(ecode2)) {
46433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46434 }
46435 arg2 = static_cast< int >(val2);
46436 ecode3 = SWIG_AsVal_int(obj2, &val3);
46437 if (!SWIG_IsOK(ecode3)) {
46438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46439 }
46440 arg3 = static_cast< int >(val3);
46441 ecode4 = SWIG_AsVal_int(obj3, &val4);
46442 if (!SWIG_IsOK(ecode4)) {
46443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46444 }
46445 arg4 = static_cast< int >(val4);
46446 ecode5 = SWIG_AsVal_int(obj4, &val5);
46447 if (!SWIG_IsOK(ecode5)) {
46448 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46449 }
46450 arg5 = static_cast< int >(val5);
46451 {
46452 PyThreadState* __tstate = wxPyBeginAllowThreads();
46453 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46454 wxPyEndAllowThreads(__tstate);
46455 if (PyErr_Occurred()) SWIG_fail;
46456 }
46457 resultobj = SWIG_Py_Void();
46458 return resultobj;
46459 fail:
46460 return NULL;
46461 }
46462
46463
46464 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46465 PyObject *resultobj = 0;
46466 wxSizer *arg1 = (wxSizer *) 0 ;
46467 wxSize *arg2 = 0 ;
46468 void *argp1 = 0 ;
46469 int res1 = 0 ;
46470 wxSize temp2 ;
46471 PyObject * obj0 = 0 ;
46472 PyObject * obj1 = 0 ;
46473 char * kwnames[] = {
46474 (char *) "self",(char *) "size", NULL
46475 };
46476
46477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46479 if (!SWIG_IsOK(res1)) {
46480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46481 }
46482 arg1 = reinterpret_cast< wxSizer * >(argp1);
46483 {
46484 arg2 = &temp2;
46485 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46486 }
46487 {
46488 PyThreadState* __tstate = wxPyBeginAllowThreads();
46489 (arg1)->SetMinSize((wxSize const &)*arg2);
46490 wxPyEndAllowThreads(__tstate);
46491 if (PyErr_Occurred()) SWIG_fail;
46492 }
46493 resultobj = SWIG_Py_Void();
46494 return resultobj;
46495 fail:
46496 return NULL;
46497 }
46498
46499
46500 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46501 PyObject *resultobj = 0;
46502 wxSizer *arg1 = (wxSizer *) 0 ;
46503 wxSize result;
46504 void *argp1 = 0 ;
46505 int res1 = 0 ;
46506 PyObject *swig_obj[1] ;
46507
46508 if (!args) SWIG_fail;
46509 swig_obj[0] = args;
46510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46511 if (!SWIG_IsOK(res1)) {
46512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46513 }
46514 arg1 = reinterpret_cast< wxSizer * >(argp1);
46515 {
46516 PyThreadState* __tstate = wxPyBeginAllowThreads();
46517 result = (arg1)->GetSize();
46518 wxPyEndAllowThreads(__tstate);
46519 if (PyErr_Occurred()) SWIG_fail;
46520 }
46521 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46522 return resultobj;
46523 fail:
46524 return NULL;
46525 }
46526
46527
46528 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46529 PyObject *resultobj = 0;
46530 wxSizer *arg1 = (wxSizer *) 0 ;
46531 wxPoint result;
46532 void *argp1 = 0 ;
46533 int res1 = 0 ;
46534 PyObject *swig_obj[1] ;
46535
46536 if (!args) SWIG_fail;
46537 swig_obj[0] = args;
46538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46539 if (!SWIG_IsOK(res1)) {
46540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46541 }
46542 arg1 = reinterpret_cast< wxSizer * >(argp1);
46543 {
46544 PyThreadState* __tstate = wxPyBeginAllowThreads();
46545 result = (arg1)->GetPosition();
46546 wxPyEndAllowThreads(__tstate);
46547 if (PyErr_Occurred()) SWIG_fail;
46548 }
46549 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46550 return resultobj;
46551 fail:
46552 return NULL;
46553 }
46554
46555
46556 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46557 PyObject *resultobj = 0;
46558 wxSizer *arg1 = (wxSizer *) 0 ;
46559 wxSize result;
46560 void *argp1 = 0 ;
46561 int res1 = 0 ;
46562 PyObject *swig_obj[1] ;
46563
46564 if (!args) SWIG_fail;
46565 swig_obj[0] = args;
46566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46567 if (!SWIG_IsOK(res1)) {
46568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46569 }
46570 arg1 = reinterpret_cast< wxSizer * >(argp1);
46571 {
46572 PyThreadState* __tstate = wxPyBeginAllowThreads();
46573 result = (arg1)->GetMinSize();
46574 wxPyEndAllowThreads(__tstate);
46575 if (PyErr_Occurred()) SWIG_fail;
46576 }
46577 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46578 return resultobj;
46579 fail:
46580 return NULL;
46581 }
46582
46583
46584 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46585 PyObject *resultobj = 0;
46586 wxSizer *arg1 = (wxSizer *) 0 ;
46587 void *argp1 = 0 ;
46588 int res1 = 0 ;
46589 PyObject *swig_obj[1] ;
46590
46591 if (!args) SWIG_fail;
46592 swig_obj[0] = args;
46593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46596 }
46597 arg1 = reinterpret_cast< wxSizer * >(argp1);
46598 {
46599 PyThreadState* __tstate = wxPyBeginAllowThreads();
46600 (arg1)->RecalcSizes();
46601 wxPyEndAllowThreads(__tstate);
46602 if (PyErr_Occurred()) SWIG_fail;
46603 }
46604 resultobj = SWIG_Py_Void();
46605 return resultobj;
46606 fail:
46607 return NULL;
46608 }
46609
46610
46611 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46612 PyObject *resultobj = 0;
46613 wxSizer *arg1 = (wxSizer *) 0 ;
46614 wxSize result;
46615 void *argp1 = 0 ;
46616 int res1 = 0 ;
46617 PyObject *swig_obj[1] ;
46618
46619 if (!args) SWIG_fail;
46620 swig_obj[0] = args;
46621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46622 if (!SWIG_IsOK(res1)) {
46623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46624 }
46625 arg1 = reinterpret_cast< wxSizer * >(argp1);
46626 {
46627 PyThreadState* __tstate = wxPyBeginAllowThreads();
46628 result = (arg1)->CalcMin();
46629 wxPyEndAllowThreads(__tstate);
46630 if (PyErr_Occurred()) SWIG_fail;
46631 }
46632 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46633 return resultobj;
46634 fail:
46635 return NULL;
46636 }
46637
46638
46639 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46640 PyObject *resultobj = 0;
46641 wxSizer *arg1 = (wxSizer *) 0 ;
46642 void *argp1 = 0 ;
46643 int res1 = 0 ;
46644 PyObject *swig_obj[1] ;
46645
46646 if (!args) SWIG_fail;
46647 swig_obj[0] = args;
46648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46649 if (!SWIG_IsOK(res1)) {
46650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46651 }
46652 arg1 = reinterpret_cast< wxSizer * >(argp1);
46653 {
46654 PyThreadState* __tstate = wxPyBeginAllowThreads();
46655 (arg1)->Layout();
46656 wxPyEndAllowThreads(__tstate);
46657 if (PyErr_Occurred()) SWIG_fail;
46658 }
46659 resultobj = SWIG_Py_Void();
46660 return resultobj;
46661 fail:
46662 return NULL;
46663 }
46664
46665
46666 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46667 PyObject *resultobj = 0;
46668 wxSizer *arg1 = (wxSizer *) 0 ;
46669 wxWindow *arg2 = (wxWindow *) 0 ;
46670 wxSize result;
46671 void *argp1 = 0 ;
46672 int res1 = 0 ;
46673 void *argp2 = 0 ;
46674 int res2 = 0 ;
46675 PyObject * obj0 = 0 ;
46676 PyObject * obj1 = 0 ;
46677 char * kwnames[] = {
46678 (char *) "self",(char *) "window", NULL
46679 };
46680
46681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46683 if (!SWIG_IsOK(res1)) {
46684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46685 }
46686 arg1 = reinterpret_cast< wxSizer * >(argp1);
46687 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46688 if (!SWIG_IsOK(res2)) {
46689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46690 }
46691 arg2 = reinterpret_cast< wxWindow * >(argp2);
46692 {
46693 PyThreadState* __tstate = wxPyBeginAllowThreads();
46694 result = (arg1)->Fit(arg2);
46695 wxPyEndAllowThreads(__tstate);
46696 if (PyErr_Occurred()) SWIG_fail;
46697 }
46698 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46699 return resultobj;
46700 fail:
46701 return NULL;
46702 }
46703
46704
46705 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46706 PyObject *resultobj = 0;
46707 wxSizer *arg1 = (wxSizer *) 0 ;
46708 wxWindow *arg2 = (wxWindow *) 0 ;
46709 void *argp1 = 0 ;
46710 int res1 = 0 ;
46711 void *argp2 = 0 ;
46712 int res2 = 0 ;
46713 PyObject * obj0 = 0 ;
46714 PyObject * obj1 = 0 ;
46715 char * kwnames[] = {
46716 (char *) "self",(char *) "window", NULL
46717 };
46718
46719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46721 if (!SWIG_IsOK(res1)) {
46722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46723 }
46724 arg1 = reinterpret_cast< wxSizer * >(argp1);
46725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46726 if (!SWIG_IsOK(res2)) {
46727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46728 }
46729 arg2 = reinterpret_cast< wxWindow * >(argp2);
46730 {
46731 PyThreadState* __tstate = wxPyBeginAllowThreads();
46732 (arg1)->FitInside(arg2);
46733 wxPyEndAllowThreads(__tstate);
46734 if (PyErr_Occurred()) SWIG_fail;
46735 }
46736 resultobj = SWIG_Py_Void();
46737 return resultobj;
46738 fail:
46739 return NULL;
46740 }
46741
46742
46743 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46744 PyObject *resultobj = 0;
46745 wxSizer *arg1 = (wxSizer *) 0 ;
46746 wxWindow *arg2 = (wxWindow *) 0 ;
46747 void *argp1 = 0 ;
46748 int res1 = 0 ;
46749 void *argp2 = 0 ;
46750 int res2 = 0 ;
46751 PyObject * obj0 = 0 ;
46752 PyObject * obj1 = 0 ;
46753 char * kwnames[] = {
46754 (char *) "self",(char *) "window", NULL
46755 };
46756
46757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46759 if (!SWIG_IsOK(res1)) {
46760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46761 }
46762 arg1 = reinterpret_cast< wxSizer * >(argp1);
46763 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46764 if (!SWIG_IsOK(res2)) {
46765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46766 }
46767 arg2 = reinterpret_cast< wxWindow * >(argp2);
46768 {
46769 PyThreadState* __tstate = wxPyBeginAllowThreads();
46770 (arg1)->SetSizeHints(arg2);
46771 wxPyEndAllowThreads(__tstate);
46772 if (PyErr_Occurred()) SWIG_fail;
46773 }
46774 resultobj = SWIG_Py_Void();
46775 return resultobj;
46776 fail:
46777 return NULL;
46778 }
46779
46780
46781 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46782 PyObject *resultobj = 0;
46783 wxSizer *arg1 = (wxSizer *) 0 ;
46784 wxWindow *arg2 = (wxWindow *) 0 ;
46785 void *argp1 = 0 ;
46786 int res1 = 0 ;
46787 void *argp2 = 0 ;
46788 int res2 = 0 ;
46789 PyObject * obj0 = 0 ;
46790 PyObject * obj1 = 0 ;
46791 char * kwnames[] = {
46792 (char *) "self",(char *) "window", NULL
46793 };
46794
46795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46797 if (!SWIG_IsOK(res1)) {
46798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46799 }
46800 arg1 = reinterpret_cast< wxSizer * >(argp1);
46801 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46802 if (!SWIG_IsOK(res2)) {
46803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46804 }
46805 arg2 = reinterpret_cast< wxWindow * >(argp2);
46806 {
46807 PyThreadState* __tstate = wxPyBeginAllowThreads();
46808 (arg1)->SetVirtualSizeHints(arg2);
46809 wxPyEndAllowThreads(__tstate);
46810 if (PyErr_Occurred()) SWIG_fail;
46811 }
46812 resultobj = SWIG_Py_Void();
46813 return resultobj;
46814 fail:
46815 return NULL;
46816 }
46817
46818
46819 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46820 PyObject *resultobj = 0;
46821 wxSizer *arg1 = (wxSizer *) 0 ;
46822 bool arg2 = (bool) false ;
46823 void *argp1 = 0 ;
46824 int res1 = 0 ;
46825 bool val2 ;
46826 int ecode2 = 0 ;
46827 PyObject * obj0 = 0 ;
46828 PyObject * obj1 = 0 ;
46829 char * kwnames[] = {
46830 (char *) "self",(char *) "deleteWindows", NULL
46831 };
46832
46833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46835 if (!SWIG_IsOK(res1)) {
46836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46837 }
46838 arg1 = reinterpret_cast< wxSizer * >(argp1);
46839 if (obj1) {
46840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46841 if (!SWIG_IsOK(ecode2)) {
46842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46843 }
46844 arg2 = static_cast< bool >(val2);
46845 }
46846 {
46847 PyThreadState* __tstate = wxPyBeginAllowThreads();
46848 (arg1)->Clear(arg2);
46849 wxPyEndAllowThreads(__tstate);
46850 if (PyErr_Occurred()) SWIG_fail;
46851 }
46852 resultobj = SWIG_Py_Void();
46853 return resultobj;
46854 fail:
46855 return NULL;
46856 }
46857
46858
46859 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46860 PyObject *resultobj = 0;
46861 wxSizer *arg1 = (wxSizer *) 0 ;
46862 void *argp1 = 0 ;
46863 int res1 = 0 ;
46864 PyObject *swig_obj[1] ;
46865
46866 if (!args) SWIG_fail;
46867 swig_obj[0] = args;
46868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46869 if (!SWIG_IsOK(res1)) {
46870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46871 }
46872 arg1 = reinterpret_cast< wxSizer * >(argp1);
46873 {
46874 PyThreadState* __tstate = wxPyBeginAllowThreads();
46875 (arg1)->DeleteWindows();
46876 wxPyEndAllowThreads(__tstate);
46877 if (PyErr_Occurred()) SWIG_fail;
46878 }
46879 resultobj = SWIG_Py_Void();
46880 return resultobj;
46881 fail:
46882 return NULL;
46883 }
46884
46885
46886 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46887 PyObject *resultobj = 0;
46888 wxSizer *arg1 = (wxSizer *) 0 ;
46889 PyObject *result = 0 ;
46890 void *argp1 = 0 ;
46891 int res1 = 0 ;
46892 PyObject *swig_obj[1] ;
46893
46894 if (!args) SWIG_fail;
46895 swig_obj[0] = args;
46896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46897 if (!SWIG_IsOK(res1)) {
46898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46899 }
46900 arg1 = reinterpret_cast< wxSizer * >(argp1);
46901 {
46902 PyThreadState* __tstate = wxPyBeginAllowThreads();
46903 result = (PyObject *)wxSizer_GetChildren(arg1);
46904 wxPyEndAllowThreads(__tstate);
46905 if (PyErr_Occurred()) SWIG_fail;
46906 }
46907 resultobj = result;
46908 return resultobj;
46909 fail:
46910 return NULL;
46911 }
46912
46913
46914 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46915 PyObject *resultobj = 0;
46916 wxSizer *arg1 = (wxSizer *) 0 ;
46917 PyObject *arg2 = (PyObject *) 0 ;
46918 bool arg3 = (bool) true ;
46919 bool arg4 = (bool) false ;
46920 bool result;
46921 void *argp1 = 0 ;
46922 int res1 = 0 ;
46923 bool val3 ;
46924 int ecode3 = 0 ;
46925 bool val4 ;
46926 int ecode4 = 0 ;
46927 PyObject * obj0 = 0 ;
46928 PyObject * obj1 = 0 ;
46929 PyObject * obj2 = 0 ;
46930 PyObject * obj3 = 0 ;
46931 char * kwnames[] = {
46932 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46933 };
46934
46935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
46936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46937 if (!SWIG_IsOK(res1)) {
46938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
46939 }
46940 arg1 = reinterpret_cast< wxSizer * >(argp1);
46941 arg2 = obj1;
46942 if (obj2) {
46943 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46944 if (!SWIG_IsOK(ecode3)) {
46945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
46946 }
46947 arg3 = static_cast< bool >(val3);
46948 }
46949 if (obj3) {
46950 ecode4 = SWIG_AsVal_bool(obj3, &val4);
46951 if (!SWIG_IsOK(ecode4)) {
46952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
46953 }
46954 arg4 = static_cast< bool >(val4);
46955 }
46956 {
46957 PyThreadState* __tstate = wxPyBeginAllowThreads();
46958 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
46959 wxPyEndAllowThreads(__tstate);
46960 if (PyErr_Occurred()) SWIG_fail;
46961 }
46962 {
46963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46964 }
46965 return resultobj;
46966 fail:
46967 return NULL;
46968 }
46969
46970
46971 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46972 PyObject *resultobj = 0;
46973 wxSizer *arg1 = (wxSizer *) 0 ;
46974 PyObject *arg2 = (PyObject *) 0 ;
46975 bool result;
46976 void *argp1 = 0 ;
46977 int res1 = 0 ;
46978 PyObject * obj0 = 0 ;
46979 PyObject * obj1 = 0 ;
46980 char * kwnames[] = {
46981 (char *) "self",(char *) "item", NULL
46982 };
46983
46984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
46985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46986 if (!SWIG_IsOK(res1)) {
46987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
46988 }
46989 arg1 = reinterpret_cast< wxSizer * >(argp1);
46990 arg2 = obj1;
46991 {
46992 PyThreadState* __tstate = wxPyBeginAllowThreads();
46993 result = (bool)wxSizer_IsShown(arg1,arg2);
46994 wxPyEndAllowThreads(__tstate);
46995 if (PyErr_Occurred()) SWIG_fail;
46996 }
46997 {
46998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46999 }
47000 return resultobj;
47001 fail:
47002 return NULL;
47003 }
47004
47005
47006 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47007 PyObject *resultobj = 0;
47008 wxSizer *arg1 = (wxSizer *) 0 ;
47009 bool arg2 ;
47010 void *argp1 = 0 ;
47011 int res1 = 0 ;
47012 bool val2 ;
47013 int ecode2 = 0 ;
47014 PyObject * obj0 = 0 ;
47015 PyObject * obj1 = 0 ;
47016 char * kwnames[] = {
47017 (char *) "self",(char *) "show", NULL
47018 };
47019
47020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47022 if (!SWIG_IsOK(res1)) {
47023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47024 }
47025 arg1 = reinterpret_cast< wxSizer * >(argp1);
47026 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47027 if (!SWIG_IsOK(ecode2)) {
47028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47029 }
47030 arg2 = static_cast< bool >(val2);
47031 {
47032 PyThreadState* __tstate = wxPyBeginAllowThreads();
47033 (arg1)->ShowItems(arg2);
47034 wxPyEndAllowThreads(__tstate);
47035 if (PyErr_Occurred()) SWIG_fail;
47036 }
47037 resultobj = SWIG_Py_Void();
47038 return resultobj;
47039 fail:
47040 return NULL;
47041 }
47042
47043
47044 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47045 PyObject *obj;
47046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47047 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47048 return SWIG_Py_Void();
47049 }
47050
47051 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47052 PyObject *resultobj = 0;
47053 wxPySizer *result = 0 ;
47054
47055 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47056 {
47057 PyThreadState* __tstate = wxPyBeginAllowThreads();
47058 result = (wxPySizer *)new wxPySizer();
47059 wxPyEndAllowThreads(__tstate);
47060 if (PyErr_Occurred()) SWIG_fail;
47061 }
47062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47063 return resultobj;
47064 fail:
47065 return NULL;
47066 }
47067
47068
47069 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47070 PyObject *resultobj = 0;
47071 wxPySizer *arg1 = (wxPySizer *) 0 ;
47072 PyObject *arg2 = (PyObject *) 0 ;
47073 PyObject *arg3 = (PyObject *) 0 ;
47074 void *argp1 = 0 ;
47075 int res1 = 0 ;
47076 PyObject * obj0 = 0 ;
47077 PyObject * obj1 = 0 ;
47078 PyObject * obj2 = 0 ;
47079 char * kwnames[] = {
47080 (char *) "self",(char *) "self",(char *) "_class", NULL
47081 };
47082
47083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47085 if (!SWIG_IsOK(res1)) {
47086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47087 }
47088 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47089 arg2 = obj1;
47090 arg3 = obj2;
47091 {
47092 PyThreadState* __tstate = wxPyBeginAllowThreads();
47093 (arg1)->_setCallbackInfo(arg2,arg3);
47094 wxPyEndAllowThreads(__tstate);
47095 if (PyErr_Occurred()) SWIG_fail;
47096 }
47097 resultobj = SWIG_Py_Void();
47098 return resultobj;
47099 fail:
47100 return NULL;
47101 }
47102
47103
47104 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47105 PyObject *obj;
47106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47107 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47108 return SWIG_Py_Void();
47109 }
47110
47111 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47112 return SWIG_Python_InitShadowInstance(args);
47113 }
47114
47115 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47116 PyObject *resultobj = 0;
47117 int arg1 = (int) wxHORIZONTAL ;
47118 wxBoxSizer *result = 0 ;
47119 int val1 ;
47120 int ecode1 = 0 ;
47121 PyObject * obj0 = 0 ;
47122 char * kwnames[] = {
47123 (char *) "orient", NULL
47124 };
47125
47126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47127 if (obj0) {
47128 ecode1 = SWIG_AsVal_int(obj0, &val1);
47129 if (!SWIG_IsOK(ecode1)) {
47130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47131 }
47132 arg1 = static_cast< int >(val1);
47133 }
47134 {
47135 PyThreadState* __tstate = wxPyBeginAllowThreads();
47136 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47137 wxPyEndAllowThreads(__tstate);
47138 if (PyErr_Occurred()) SWIG_fail;
47139 }
47140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47141 return resultobj;
47142 fail:
47143 return NULL;
47144 }
47145
47146
47147 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47148 PyObject *resultobj = 0;
47149 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47150 int result;
47151 void *argp1 = 0 ;
47152 int res1 = 0 ;
47153 PyObject *swig_obj[1] ;
47154
47155 if (!args) SWIG_fail;
47156 swig_obj[0] = args;
47157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47158 if (!SWIG_IsOK(res1)) {
47159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47160 }
47161 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47162 {
47163 PyThreadState* __tstate = wxPyBeginAllowThreads();
47164 result = (int)(arg1)->GetOrientation();
47165 wxPyEndAllowThreads(__tstate);
47166 if (PyErr_Occurred()) SWIG_fail;
47167 }
47168 resultobj = SWIG_From_int(static_cast< int >(result));
47169 return resultobj;
47170 fail:
47171 return NULL;
47172 }
47173
47174
47175 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47176 PyObject *resultobj = 0;
47177 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47178 int arg2 ;
47179 void *argp1 = 0 ;
47180 int res1 = 0 ;
47181 int val2 ;
47182 int ecode2 = 0 ;
47183 PyObject * obj0 = 0 ;
47184 PyObject * obj1 = 0 ;
47185 char * kwnames[] = {
47186 (char *) "self",(char *) "orient", NULL
47187 };
47188
47189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47191 if (!SWIG_IsOK(res1)) {
47192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47193 }
47194 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47195 ecode2 = SWIG_AsVal_int(obj1, &val2);
47196 if (!SWIG_IsOK(ecode2)) {
47197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47198 }
47199 arg2 = static_cast< int >(val2);
47200 {
47201 PyThreadState* __tstate = wxPyBeginAllowThreads();
47202 (arg1)->SetOrientation(arg2);
47203 wxPyEndAllowThreads(__tstate);
47204 if (PyErr_Occurred()) SWIG_fail;
47205 }
47206 resultobj = SWIG_Py_Void();
47207 return resultobj;
47208 fail:
47209 return NULL;
47210 }
47211
47212
47213 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47214 PyObject *obj;
47215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47216 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47217 return SWIG_Py_Void();
47218 }
47219
47220 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47221 return SWIG_Python_InitShadowInstance(args);
47222 }
47223
47224 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47225 PyObject *resultobj = 0;
47226 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47227 int arg2 = (int) wxHORIZONTAL ;
47228 wxStaticBoxSizer *result = 0 ;
47229 void *argp1 = 0 ;
47230 int res1 = 0 ;
47231 int val2 ;
47232 int ecode2 = 0 ;
47233 PyObject * obj0 = 0 ;
47234 PyObject * obj1 = 0 ;
47235 char * kwnames[] = {
47236 (char *) "box",(char *) "orient", NULL
47237 };
47238
47239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47241 if (!SWIG_IsOK(res1)) {
47242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47243 }
47244 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47245 if (obj1) {
47246 ecode2 = SWIG_AsVal_int(obj1, &val2);
47247 if (!SWIG_IsOK(ecode2)) {
47248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47249 }
47250 arg2 = static_cast< int >(val2);
47251 }
47252 {
47253 PyThreadState* __tstate = wxPyBeginAllowThreads();
47254 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47255 wxPyEndAllowThreads(__tstate);
47256 if (PyErr_Occurred()) SWIG_fail;
47257 }
47258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47259 return resultobj;
47260 fail:
47261 return NULL;
47262 }
47263
47264
47265 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47266 PyObject *resultobj = 0;
47267 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47268 wxStaticBox *result = 0 ;
47269 void *argp1 = 0 ;
47270 int res1 = 0 ;
47271 PyObject *swig_obj[1] ;
47272
47273 if (!args) SWIG_fail;
47274 swig_obj[0] = args;
47275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47276 if (!SWIG_IsOK(res1)) {
47277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47278 }
47279 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47280 {
47281 PyThreadState* __tstate = wxPyBeginAllowThreads();
47282 result = (wxStaticBox *)(arg1)->GetStaticBox();
47283 wxPyEndAllowThreads(__tstate);
47284 if (PyErr_Occurred()) SWIG_fail;
47285 }
47286 {
47287 resultobj = wxPyMake_wxObject(result, (bool)0);
47288 }
47289 return resultobj;
47290 fail:
47291 return NULL;
47292 }
47293
47294
47295 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47296 PyObject *obj;
47297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47298 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47299 return SWIG_Py_Void();
47300 }
47301
47302 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47303 return SWIG_Python_InitShadowInstance(args);
47304 }
47305
47306 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47307 PyObject *resultobj = 0;
47308 int arg1 = (int) 1 ;
47309 int arg2 = (int) 0 ;
47310 int arg3 = (int) 0 ;
47311 int arg4 = (int) 0 ;
47312 wxGridSizer *result = 0 ;
47313 int val1 ;
47314 int ecode1 = 0 ;
47315 int val2 ;
47316 int ecode2 = 0 ;
47317 int val3 ;
47318 int ecode3 = 0 ;
47319 int val4 ;
47320 int ecode4 = 0 ;
47321 PyObject * obj0 = 0 ;
47322 PyObject * obj1 = 0 ;
47323 PyObject * obj2 = 0 ;
47324 PyObject * obj3 = 0 ;
47325 char * kwnames[] = {
47326 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47327 };
47328
47329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47330 if (obj0) {
47331 ecode1 = SWIG_AsVal_int(obj0, &val1);
47332 if (!SWIG_IsOK(ecode1)) {
47333 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47334 }
47335 arg1 = static_cast< int >(val1);
47336 }
47337 if (obj1) {
47338 ecode2 = SWIG_AsVal_int(obj1, &val2);
47339 if (!SWIG_IsOK(ecode2)) {
47340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47341 }
47342 arg2 = static_cast< int >(val2);
47343 }
47344 if (obj2) {
47345 ecode3 = SWIG_AsVal_int(obj2, &val3);
47346 if (!SWIG_IsOK(ecode3)) {
47347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47348 }
47349 arg3 = static_cast< int >(val3);
47350 }
47351 if (obj3) {
47352 ecode4 = SWIG_AsVal_int(obj3, &val4);
47353 if (!SWIG_IsOK(ecode4)) {
47354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47355 }
47356 arg4 = static_cast< int >(val4);
47357 }
47358 {
47359 PyThreadState* __tstate = wxPyBeginAllowThreads();
47360 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47361 wxPyEndAllowThreads(__tstate);
47362 if (PyErr_Occurred()) SWIG_fail;
47363 }
47364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47365 return resultobj;
47366 fail:
47367 return NULL;
47368 }
47369
47370
47371 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47372 PyObject *resultobj = 0;
47373 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47374 int arg2 ;
47375 void *argp1 = 0 ;
47376 int res1 = 0 ;
47377 int val2 ;
47378 int ecode2 = 0 ;
47379 PyObject * obj0 = 0 ;
47380 PyObject * obj1 = 0 ;
47381 char * kwnames[] = {
47382 (char *) "self",(char *) "cols", NULL
47383 };
47384
47385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47387 if (!SWIG_IsOK(res1)) {
47388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47389 }
47390 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47391 ecode2 = SWIG_AsVal_int(obj1, &val2);
47392 if (!SWIG_IsOK(ecode2)) {
47393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47394 }
47395 arg2 = static_cast< int >(val2);
47396 {
47397 PyThreadState* __tstate = wxPyBeginAllowThreads();
47398 (arg1)->SetCols(arg2);
47399 wxPyEndAllowThreads(__tstate);
47400 if (PyErr_Occurred()) SWIG_fail;
47401 }
47402 resultobj = SWIG_Py_Void();
47403 return resultobj;
47404 fail:
47405 return NULL;
47406 }
47407
47408
47409 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47410 PyObject *resultobj = 0;
47411 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47412 int arg2 ;
47413 void *argp1 = 0 ;
47414 int res1 = 0 ;
47415 int val2 ;
47416 int ecode2 = 0 ;
47417 PyObject * obj0 = 0 ;
47418 PyObject * obj1 = 0 ;
47419 char * kwnames[] = {
47420 (char *) "self",(char *) "rows", NULL
47421 };
47422
47423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47425 if (!SWIG_IsOK(res1)) {
47426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47427 }
47428 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47429 ecode2 = SWIG_AsVal_int(obj1, &val2);
47430 if (!SWIG_IsOK(ecode2)) {
47431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47432 }
47433 arg2 = static_cast< int >(val2);
47434 {
47435 PyThreadState* __tstate = wxPyBeginAllowThreads();
47436 (arg1)->SetRows(arg2);
47437 wxPyEndAllowThreads(__tstate);
47438 if (PyErr_Occurred()) SWIG_fail;
47439 }
47440 resultobj = SWIG_Py_Void();
47441 return resultobj;
47442 fail:
47443 return NULL;
47444 }
47445
47446
47447 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47448 PyObject *resultobj = 0;
47449 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47450 int arg2 ;
47451 void *argp1 = 0 ;
47452 int res1 = 0 ;
47453 int val2 ;
47454 int ecode2 = 0 ;
47455 PyObject * obj0 = 0 ;
47456 PyObject * obj1 = 0 ;
47457 char * kwnames[] = {
47458 (char *) "self",(char *) "gap", NULL
47459 };
47460
47461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47463 if (!SWIG_IsOK(res1)) {
47464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47465 }
47466 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47467 ecode2 = SWIG_AsVal_int(obj1, &val2);
47468 if (!SWIG_IsOK(ecode2)) {
47469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47470 }
47471 arg2 = static_cast< int >(val2);
47472 {
47473 PyThreadState* __tstate = wxPyBeginAllowThreads();
47474 (arg1)->SetVGap(arg2);
47475 wxPyEndAllowThreads(__tstate);
47476 if (PyErr_Occurred()) SWIG_fail;
47477 }
47478 resultobj = SWIG_Py_Void();
47479 return resultobj;
47480 fail:
47481 return NULL;
47482 }
47483
47484
47485 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47486 PyObject *resultobj = 0;
47487 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47488 int arg2 ;
47489 void *argp1 = 0 ;
47490 int res1 = 0 ;
47491 int val2 ;
47492 int ecode2 = 0 ;
47493 PyObject * obj0 = 0 ;
47494 PyObject * obj1 = 0 ;
47495 char * kwnames[] = {
47496 (char *) "self",(char *) "gap", NULL
47497 };
47498
47499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47501 if (!SWIG_IsOK(res1)) {
47502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47503 }
47504 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47505 ecode2 = SWIG_AsVal_int(obj1, &val2);
47506 if (!SWIG_IsOK(ecode2)) {
47507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47508 }
47509 arg2 = static_cast< int >(val2);
47510 {
47511 PyThreadState* __tstate = wxPyBeginAllowThreads();
47512 (arg1)->SetHGap(arg2);
47513 wxPyEndAllowThreads(__tstate);
47514 if (PyErr_Occurred()) SWIG_fail;
47515 }
47516 resultobj = SWIG_Py_Void();
47517 return resultobj;
47518 fail:
47519 return NULL;
47520 }
47521
47522
47523 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47524 PyObject *resultobj = 0;
47525 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47526 int result;
47527 void *argp1 = 0 ;
47528 int res1 = 0 ;
47529 PyObject *swig_obj[1] ;
47530
47531 if (!args) SWIG_fail;
47532 swig_obj[0] = args;
47533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47534 if (!SWIG_IsOK(res1)) {
47535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47536 }
47537 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47538 {
47539 PyThreadState* __tstate = wxPyBeginAllowThreads();
47540 result = (int)(arg1)->GetCols();
47541 wxPyEndAllowThreads(__tstate);
47542 if (PyErr_Occurred()) SWIG_fail;
47543 }
47544 resultobj = SWIG_From_int(static_cast< int >(result));
47545 return resultobj;
47546 fail:
47547 return NULL;
47548 }
47549
47550
47551 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47552 PyObject *resultobj = 0;
47553 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47554 int result;
47555 void *argp1 = 0 ;
47556 int res1 = 0 ;
47557 PyObject *swig_obj[1] ;
47558
47559 if (!args) SWIG_fail;
47560 swig_obj[0] = args;
47561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47562 if (!SWIG_IsOK(res1)) {
47563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47564 }
47565 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47566 {
47567 PyThreadState* __tstate = wxPyBeginAllowThreads();
47568 result = (int)(arg1)->GetRows();
47569 wxPyEndAllowThreads(__tstate);
47570 if (PyErr_Occurred()) SWIG_fail;
47571 }
47572 resultobj = SWIG_From_int(static_cast< int >(result));
47573 return resultobj;
47574 fail:
47575 return NULL;
47576 }
47577
47578
47579 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47580 PyObject *resultobj = 0;
47581 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47582 int result;
47583 void *argp1 = 0 ;
47584 int res1 = 0 ;
47585 PyObject *swig_obj[1] ;
47586
47587 if (!args) SWIG_fail;
47588 swig_obj[0] = args;
47589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47590 if (!SWIG_IsOK(res1)) {
47591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47592 }
47593 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47594 {
47595 PyThreadState* __tstate = wxPyBeginAllowThreads();
47596 result = (int)(arg1)->GetVGap();
47597 wxPyEndAllowThreads(__tstate);
47598 if (PyErr_Occurred()) SWIG_fail;
47599 }
47600 resultobj = SWIG_From_int(static_cast< int >(result));
47601 return resultobj;
47602 fail:
47603 return NULL;
47604 }
47605
47606
47607 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47608 PyObject *resultobj = 0;
47609 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47610 int result;
47611 void *argp1 = 0 ;
47612 int res1 = 0 ;
47613 PyObject *swig_obj[1] ;
47614
47615 if (!args) SWIG_fail;
47616 swig_obj[0] = args;
47617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47618 if (!SWIG_IsOK(res1)) {
47619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47620 }
47621 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47622 {
47623 PyThreadState* __tstate = wxPyBeginAllowThreads();
47624 result = (int)(arg1)->GetHGap();
47625 wxPyEndAllowThreads(__tstate);
47626 if (PyErr_Occurred()) SWIG_fail;
47627 }
47628 resultobj = SWIG_From_int(static_cast< int >(result));
47629 return resultobj;
47630 fail:
47631 return NULL;
47632 }
47633
47634
47635 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47636 PyObject *obj;
47637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47638 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47639 return SWIG_Py_Void();
47640 }
47641
47642 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47643 return SWIG_Python_InitShadowInstance(args);
47644 }
47645
47646 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47647 PyObject *resultobj = 0;
47648 int arg1 = (int) 1 ;
47649 int arg2 = (int) 0 ;
47650 int arg3 = (int) 0 ;
47651 int arg4 = (int) 0 ;
47652 wxFlexGridSizer *result = 0 ;
47653 int val1 ;
47654 int ecode1 = 0 ;
47655 int val2 ;
47656 int ecode2 = 0 ;
47657 int val3 ;
47658 int ecode3 = 0 ;
47659 int val4 ;
47660 int ecode4 = 0 ;
47661 PyObject * obj0 = 0 ;
47662 PyObject * obj1 = 0 ;
47663 PyObject * obj2 = 0 ;
47664 PyObject * obj3 = 0 ;
47665 char * kwnames[] = {
47666 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47667 };
47668
47669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47670 if (obj0) {
47671 ecode1 = SWIG_AsVal_int(obj0, &val1);
47672 if (!SWIG_IsOK(ecode1)) {
47673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47674 }
47675 arg1 = static_cast< int >(val1);
47676 }
47677 if (obj1) {
47678 ecode2 = SWIG_AsVal_int(obj1, &val2);
47679 if (!SWIG_IsOK(ecode2)) {
47680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47681 }
47682 arg2 = static_cast< int >(val2);
47683 }
47684 if (obj2) {
47685 ecode3 = SWIG_AsVal_int(obj2, &val3);
47686 if (!SWIG_IsOK(ecode3)) {
47687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47688 }
47689 arg3 = static_cast< int >(val3);
47690 }
47691 if (obj3) {
47692 ecode4 = SWIG_AsVal_int(obj3, &val4);
47693 if (!SWIG_IsOK(ecode4)) {
47694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47695 }
47696 arg4 = static_cast< int >(val4);
47697 }
47698 {
47699 PyThreadState* __tstate = wxPyBeginAllowThreads();
47700 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47701 wxPyEndAllowThreads(__tstate);
47702 if (PyErr_Occurred()) SWIG_fail;
47703 }
47704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47705 return resultobj;
47706 fail:
47707 return NULL;
47708 }
47709
47710
47711 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47712 PyObject *resultobj = 0;
47713 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47714 size_t arg2 ;
47715 int arg3 = (int) 0 ;
47716 void *argp1 = 0 ;
47717 int res1 = 0 ;
47718 size_t val2 ;
47719 int ecode2 = 0 ;
47720 int val3 ;
47721 int ecode3 = 0 ;
47722 PyObject * obj0 = 0 ;
47723 PyObject * obj1 = 0 ;
47724 PyObject * obj2 = 0 ;
47725 char * kwnames[] = {
47726 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47727 };
47728
47729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47731 if (!SWIG_IsOK(res1)) {
47732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47733 }
47734 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47735 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47736 if (!SWIG_IsOK(ecode2)) {
47737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47738 }
47739 arg2 = static_cast< size_t >(val2);
47740 if (obj2) {
47741 ecode3 = SWIG_AsVal_int(obj2, &val3);
47742 if (!SWIG_IsOK(ecode3)) {
47743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47744 }
47745 arg3 = static_cast< int >(val3);
47746 }
47747 {
47748 PyThreadState* __tstate = wxPyBeginAllowThreads();
47749 (arg1)->AddGrowableRow(arg2,arg3);
47750 wxPyEndAllowThreads(__tstate);
47751 if (PyErr_Occurred()) SWIG_fail;
47752 }
47753 resultobj = SWIG_Py_Void();
47754 return resultobj;
47755 fail:
47756 return NULL;
47757 }
47758
47759
47760 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47761 PyObject *resultobj = 0;
47762 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47763 size_t arg2 ;
47764 void *argp1 = 0 ;
47765 int res1 = 0 ;
47766 size_t val2 ;
47767 int ecode2 = 0 ;
47768 PyObject * obj0 = 0 ;
47769 PyObject * obj1 = 0 ;
47770 char * kwnames[] = {
47771 (char *) "self",(char *) "idx", NULL
47772 };
47773
47774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47776 if (!SWIG_IsOK(res1)) {
47777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47778 }
47779 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47780 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47781 if (!SWIG_IsOK(ecode2)) {
47782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47783 }
47784 arg2 = static_cast< size_t >(val2);
47785 {
47786 PyThreadState* __tstate = wxPyBeginAllowThreads();
47787 (arg1)->RemoveGrowableRow(arg2);
47788 wxPyEndAllowThreads(__tstate);
47789 if (PyErr_Occurred()) SWIG_fail;
47790 }
47791 resultobj = SWIG_Py_Void();
47792 return resultobj;
47793 fail:
47794 return NULL;
47795 }
47796
47797
47798 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47799 PyObject *resultobj = 0;
47800 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47801 size_t arg2 ;
47802 int arg3 = (int) 0 ;
47803 void *argp1 = 0 ;
47804 int res1 = 0 ;
47805 size_t val2 ;
47806 int ecode2 = 0 ;
47807 int val3 ;
47808 int ecode3 = 0 ;
47809 PyObject * obj0 = 0 ;
47810 PyObject * obj1 = 0 ;
47811 PyObject * obj2 = 0 ;
47812 char * kwnames[] = {
47813 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47814 };
47815
47816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47818 if (!SWIG_IsOK(res1)) {
47819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47820 }
47821 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47822 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47823 if (!SWIG_IsOK(ecode2)) {
47824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47825 }
47826 arg2 = static_cast< size_t >(val2);
47827 if (obj2) {
47828 ecode3 = SWIG_AsVal_int(obj2, &val3);
47829 if (!SWIG_IsOK(ecode3)) {
47830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47831 }
47832 arg3 = static_cast< int >(val3);
47833 }
47834 {
47835 PyThreadState* __tstate = wxPyBeginAllowThreads();
47836 (arg1)->AddGrowableCol(arg2,arg3);
47837 wxPyEndAllowThreads(__tstate);
47838 if (PyErr_Occurred()) SWIG_fail;
47839 }
47840 resultobj = SWIG_Py_Void();
47841 return resultobj;
47842 fail:
47843 return NULL;
47844 }
47845
47846
47847 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47848 PyObject *resultobj = 0;
47849 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47850 size_t arg2 ;
47851 void *argp1 = 0 ;
47852 int res1 = 0 ;
47853 size_t val2 ;
47854 int ecode2 = 0 ;
47855 PyObject * obj0 = 0 ;
47856 PyObject * obj1 = 0 ;
47857 char * kwnames[] = {
47858 (char *) "self",(char *) "idx", NULL
47859 };
47860
47861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47863 if (!SWIG_IsOK(res1)) {
47864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47865 }
47866 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47867 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47868 if (!SWIG_IsOK(ecode2)) {
47869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47870 }
47871 arg2 = static_cast< size_t >(val2);
47872 {
47873 PyThreadState* __tstate = wxPyBeginAllowThreads();
47874 (arg1)->RemoveGrowableCol(arg2);
47875 wxPyEndAllowThreads(__tstate);
47876 if (PyErr_Occurred()) SWIG_fail;
47877 }
47878 resultobj = SWIG_Py_Void();
47879 return resultobj;
47880 fail:
47881 return NULL;
47882 }
47883
47884
47885 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47886 PyObject *resultobj = 0;
47887 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47888 int arg2 ;
47889 void *argp1 = 0 ;
47890 int res1 = 0 ;
47891 int val2 ;
47892 int ecode2 = 0 ;
47893 PyObject * obj0 = 0 ;
47894 PyObject * obj1 = 0 ;
47895 char * kwnames[] = {
47896 (char *) "self",(char *) "direction", NULL
47897 };
47898
47899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47901 if (!SWIG_IsOK(res1)) {
47902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47903 }
47904 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47905 ecode2 = SWIG_AsVal_int(obj1, &val2);
47906 if (!SWIG_IsOK(ecode2)) {
47907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47908 }
47909 arg2 = static_cast< int >(val2);
47910 {
47911 PyThreadState* __tstate = wxPyBeginAllowThreads();
47912 (arg1)->SetFlexibleDirection(arg2);
47913 wxPyEndAllowThreads(__tstate);
47914 if (PyErr_Occurred()) SWIG_fail;
47915 }
47916 resultobj = SWIG_Py_Void();
47917 return resultobj;
47918 fail:
47919 return NULL;
47920 }
47921
47922
47923 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47924 PyObject *resultobj = 0;
47925 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47926 int result;
47927 void *argp1 = 0 ;
47928 int res1 = 0 ;
47929 PyObject *swig_obj[1] ;
47930
47931 if (!args) SWIG_fail;
47932 swig_obj[0] = args;
47933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47934 if (!SWIG_IsOK(res1)) {
47935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47936 }
47937 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47938 {
47939 PyThreadState* __tstate = wxPyBeginAllowThreads();
47940 result = (int)(arg1)->GetFlexibleDirection();
47941 wxPyEndAllowThreads(__tstate);
47942 if (PyErr_Occurred()) SWIG_fail;
47943 }
47944 resultobj = SWIG_From_int(static_cast< int >(result));
47945 return resultobj;
47946 fail:
47947 return NULL;
47948 }
47949
47950
47951 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47952 PyObject *resultobj = 0;
47953 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47954 wxFlexSizerGrowMode arg2 ;
47955 void *argp1 = 0 ;
47956 int res1 = 0 ;
47957 int val2 ;
47958 int ecode2 = 0 ;
47959 PyObject * obj0 = 0 ;
47960 PyObject * obj1 = 0 ;
47961 char * kwnames[] = {
47962 (char *) "self",(char *) "mode", NULL
47963 };
47964
47965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
47966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47967 if (!SWIG_IsOK(res1)) {
47968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47969 }
47970 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47971 ecode2 = SWIG_AsVal_int(obj1, &val2);
47972 if (!SWIG_IsOK(ecode2)) {
47973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
47974 }
47975 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
47976 {
47977 PyThreadState* __tstate = wxPyBeginAllowThreads();
47978 (arg1)->SetNonFlexibleGrowMode(arg2);
47979 wxPyEndAllowThreads(__tstate);
47980 if (PyErr_Occurred()) SWIG_fail;
47981 }
47982 resultobj = SWIG_Py_Void();
47983 return resultobj;
47984 fail:
47985 return NULL;
47986 }
47987
47988
47989 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47990 PyObject *resultobj = 0;
47991 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47992 wxFlexSizerGrowMode result;
47993 void *argp1 = 0 ;
47994 int res1 = 0 ;
47995 PyObject *swig_obj[1] ;
47996
47997 if (!args) SWIG_fail;
47998 swig_obj[0] = args;
47999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48000 if (!SWIG_IsOK(res1)) {
48001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48002 }
48003 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48004 {
48005 PyThreadState* __tstate = wxPyBeginAllowThreads();
48006 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48007 wxPyEndAllowThreads(__tstate);
48008 if (PyErr_Occurred()) SWIG_fail;
48009 }
48010 resultobj = SWIG_From_int(static_cast< int >(result));
48011 return resultobj;
48012 fail:
48013 return NULL;
48014 }
48015
48016
48017 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48018 PyObject *resultobj = 0;
48019 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48020 wxArrayInt *result = 0 ;
48021 void *argp1 = 0 ;
48022 int res1 = 0 ;
48023 PyObject *swig_obj[1] ;
48024
48025 if (!args) SWIG_fail;
48026 swig_obj[0] = args;
48027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48028 if (!SWIG_IsOK(res1)) {
48029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48030 }
48031 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48032 {
48033 PyThreadState* __tstate = wxPyBeginAllowThreads();
48034 {
48035 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48036 result = (wxArrayInt *) &_result_ref;
48037 }
48038 wxPyEndAllowThreads(__tstate);
48039 if (PyErr_Occurred()) SWIG_fail;
48040 }
48041 {
48042 resultobj = PyList_New(0);
48043 size_t idx;
48044 for (idx = 0; idx < result->GetCount(); idx += 1) {
48045 PyObject* val = PyInt_FromLong( result->Item(idx) );
48046 PyList_Append(resultobj, val);
48047 Py_DECREF(val);
48048 }
48049 }
48050 return resultobj;
48051 fail:
48052 return NULL;
48053 }
48054
48055
48056 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48057 PyObject *resultobj = 0;
48058 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48059 wxArrayInt *result = 0 ;
48060 void *argp1 = 0 ;
48061 int res1 = 0 ;
48062 PyObject *swig_obj[1] ;
48063
48064 if (!args) SWIG_fail;
48065 swig_obj[0] = args;
48066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48067 if (!SWIG_IsOK(res1)) {
48068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48069 }
48070 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48071 {
48072 PyThreadState* __tstate = wxPyBeginAllowThreads();
48073 {
48074 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48075 result = (wxArrayInt *) &_result_ref;
48076 }
48077 wxPyEndAllowThreads(__tstate);
48078 if (PyErr_Occurred()) SWIG_fail;
48079 }
48080 {
48081 resultobj = PyList_New(0);
48082 size_t idx;
48083 for (idx = 0; idx < result->GetCount(); idx += 1) {
48084 PyObject* val = PyInt_FromLong( result->Item(idx) );
48085 PyList_Append(resultobj, val);
48086 Py_DECREF(val);
48087 }
48088 }
48089 return resultobj;
48090 fail:
48091 return NULL;
48092 }
48093
48094
48095 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48096 PyObject *obj;
48097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48098 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48099 return SWIG_Py_Void();
48100 }
48101
48102 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48103 return SWIG_Python_InitShadowInstance(args);
48104 }
48105
48106 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48107 PyObject *resultobj = 0;
48108 wxStdDialogButtonSizer *result = 0 ;
48109
48110 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48111 {
48112 PyThreadState* __tstate = wxPyBeginAllowThreads();
48113 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48114 wxPyEndAllowThreads(__tstate);
48115 if (PyErr_Occurred()) SWIG_fail;
48116 }
48117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48118 return resultobj;
48119 fail:
48120 return NULL;
48121 }
48122
48123
48124 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48125 PyObject *resultobj = 0;
48126 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48127 wxButton *arg2 = (wxButton *) 0 ;
48128 void *argp1 = 0 ;
48129 int res1 = 0 ;
48130 void *argp2 = 0 ;
48131 int res2 = 0 ;
48132 PyObject * obj0 = 0 ;
48133 PyObject * obj1 = 0 ;
48134 char * kwnames[] = {
48135 (char *) "self",(char *) "button", NULL
48136 };
48137
48138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48140 if (!SWIG_IsOK(res1)) {
48141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48142 }
48143 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48145 if (!SWIG_IsOK(res2)) {
48146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48147 }
48148 arg2 = reinterpret_cast< wxButton * >(argp2);
48149 {
48150 PyThreadState* __tstate = wxPyBeginAllowThreads();
48151 (arg1)->AddButton(arg2);
48152 wxPyEndAllowThreads(__tstate);
48153 if (PyErr_Occurred()) SWIG_fail;
48154 }
48155 resultobj = SWIG_Py_Void();
48156 return resultobj;
48157 fail:
48158 return NULL;
48159 }
48160
48161
48162 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48163 PyObject *resultobj = 0;
48164 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48165 void *argp1 = 0 ;
48166 int res1 = 0 ;
48167 PyObject *swig_obj[1] ;
48168
48169 if (!args) SWIG_fail;
48170 swig_obj[0] = args;
48171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48172 if (!SWIG_IsOK(res1)) {
48173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48174 }
48175 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48176 {
48177 PyThreadState* __tstate = wxPyBeginAllowThreads();
48178 (arg1)->Realize();
48179 wxPyEndAllowThreads(__tstate);
48180 if (PyErr_Occurred()) SWIG_fail;
48181 }
48182 resultobj = SWIG_Py_Void();
48183 return resultobj;
48184 fail:
48185 return NULL;
48186 }
48187
48188
48189 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48190 PyObject *resultobj = 0;
48191 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48192 wxButton *arg2 = (wxButton *) 0 ;
48193 void *argp1 = 0 ;
48194 int res1 = 0 ;
48195 void *argp2 = 0 ;
48196 int res2 = 0 ;
48197 PyObject * obj0 = 0 ;
48198 PyObject * obj1 = 0 ;
48199 char * kwnames[] = {
48200 (char *) "self",(char *) "button", NULL
48201 };
48202
48203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48205 if (!SWIG_IsOK(res1)) {
48206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48207 }
48208 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48210 if (!SWIG_IsOK(res2)) {
48211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48212 }
48213 arg2 = reinterpret_cast< wxButton * >(argp2);
48214 {
48215 PyThreadState* __tstate = wxPyBeginAllowThreads();
48216 (arg1)->SetAffirmativeButton(arg2);
48217 wxPyEndAllowThreads(__tstate);
48218 if (PyErr_Occurred()) SWIG_fail;
48219 }
48220 resultobj = SWIG_Py_Void();
48221 return resultobj;
48222 fail:
48223 return NULL;
48224 }
48225
48226
48227 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48228 PyObject *resultobj = 0;
48229 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48230 wxButton *arg2 = (wxButton *) 0 ;
48231 void *argp1 = 0 ;
48232 int res1 = 0 ;
48233 void *argp2 = 0 ;
48234 int res2 = 0 ;
48235 PyObject * obj0 = 0 ;
48236 PyObject * obj1 = 0 ;
48237 char * kwnames[] = {
48238 (char *) "self",(char *) "button", NULL
48239 };
48240
48241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48243 if (!SWIG_IsOK(res1)) {
48244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48245 }
48246 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48248 if (!SWIG_IsOK(res2)) {
48249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48250 }
48251 arg2 = reinterpret_cast< wxButton * >(argp2);
48252 {
48253 PyThreadState* __tstate = wxPyBeginAllowThreads();
48254 (arg1)->SetNegativeButton(arg2);
48255 wxPyEndAllowThreads(__tstate);
48256 if (PyErr_Occurred()) SWIG_fail;
48257 }
48258 resultobj = SWIG_Py_Void();
48259 return resultobj;
48260 fail:
48261 return NULL;
48262 }
48263
48264
48265 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48266 PyObject *resultobj = 0;
48267 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48268 wxButton *arg2 = (wxButton *) 0 ;
48269 void *argp1 = 0 ;
48270 int res1 = 0 ;
48271 void *argp2 = 0 ;
48272 int res2 = 0 ;
48273 PyObject * obj0 = 0 ;
48274 PyObject * obj1 = 0 ;
48275 char * kwnames[] = {
48276 (char *) "self",(char *) "button", NULL
48277 };
48278
48279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48281 if (!SWIG_IsOK(res1)) {
48282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48283 }
48284 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48286 if (!SWIG_IsOK(res2)) {
48287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48288 }
48289 arg2 = reinterpret_cast< wxButton * >(argp2);
48290 {
48291 PyThreadState* __tstate = wxPyBeginAllowThreads();
48292 (arg1)->SetCancelButton(arg2);
48293 wxPyEndAllowThreads(__tstate);
48294 if (PyErr_Occurred()) SWIG_fail;
48295 }
48296 resultobj = SWIG_Py_Void();
48297 return resultobj;
48298 fail:
48299 return NULL;
48300 }
48301
48302
48303 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48304 PyObject *resultobj = 0;
48305 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48306 wxButton *result = 0 ;
48307 void *argp1 = 0 ;
48308 int res1 = 0 ;
48309 PyObject *swig_obj[1] ;
48310
48311 if (!args) SWIG_fail;
48312 swig_obj[0] = args;
48313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48314 if (!SWIG_IsOK(res1)) {
48315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48316 }
48317 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48318 {
48319 PyThreadState* __tstate = wxPyBeginAllowThreads();
48320 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48321 wxPyEndAllowThreads(__tstate);
48322 if (PyErr_Occurred()) SWIG_fail;
48323 }
48324 {
48325 resultobj = wxPyMake_wxObject(result, (bool)0);
48326 }
48327 return resultobj;
48328 fail:
48329 return NULL;
48330 }
48331
48332
48333 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48334 PyObject *resultobj = 0;
48335 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48336 wxButton *result = 0 ;
48337 void *argp1 = 0 ;
48338 int res1 = 0 ;
48339 PyObject *swig_obj[1] ;
48340
48341 if (!args) SWIG_fail;
48342 swig_obj[0] = args;
48343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48344 if (!SWIG_IsOK(res1)) {
48345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48346 }
48347 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48348 {
48349 PyThreadState* __tstate = wxPyBeginAllowThreads();
48350 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48351 wxPyEndAllowThreads(__tstate);
48352 if (PyErr_Occurred()) SWIG_fail;
48353 }
48354 {
48355 resultobj = wxPyMake_wxObject(result, (bool)0);
48356 }
48357 return resultobj;
48358 fail:
48359 return NULL;
48360 }
48361
48362
48363 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48364 PyObject *resultobj = 0;
48365 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48366 wxButton *result = 0 ;
48367 void *argp1 = 0 ;
48368 int res1 = 0 ;
48369 PyObject *swig_obj[1] ;
48370
48371 if (!args) SWIG_fail;
48372 swig_obj[0] = args;
48373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48374 if (!SWIG_IsOK(res1)) {
48375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48376 }
48377 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48378 {
48379 PyThreadState* __tstate = wxPyBeginAllowThreads();
48380 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48381 wxPyEndAllowThreads(__tstate);
48382 if (PyErr_Occurred()) SWIG_fail;
48383 }
48384 {
48385 resultobj = wxPyMake_wxObject(result, (bool)0);
48386 }
48387 return resultobj;
48388 fail:
48389 return NULL;
48390 }
48391
48392
48393 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48394 PyObject *resultobj = 0;
48395 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48396 wxButton *result = 0 ;
48397 void *argp1 = 0 ;
48398 int res1 = 0 ;
48399 PyObject *swig_obj[1] ;
48400
48401 if (!args) SWIG_fail;
48402 swig_obj[0] = args;
48403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48404 if (!SWIG_IsOK(res1)) {
48405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48406 }
48407 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48408 {
48409 PyThreadState* __tstate = wxPyBeginAllowThreads();
48410 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48411 wxPyEndAllowThreads(__tstate);
48412 if (PyErr_Occurred()) SWIG_fail;
48413 }
48414 {
48415 resultobj = wxPyMake_wxObject(result, (bool)0);
48416 }
48417 return resultobj;
48418 fail:
48419 return NULL;
48420 }
48421
48422
48423 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48424 PyObject *resultobj = 0;
48425 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48426 wxButton *result = 0 ;
48427 void *argp1 = 0 ;
48428 int res1 = 0 ;
48429 PyObject *swig_obj[1] ;
48430
48431 if (!args) SWIG_fail;
48432 swig_obj[0] = args;
48433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48434 if (!SWIG_IsOK(res1)) {
48435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48436 }
48437 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48438 {
48439 PyThreadState* __tstate = wxPyBeginAllowThreads();
48440 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48441 wxPyEndAllowThreads(__tstate);
48442 if (PyErr_Occurred()) SWIG_fail;
48443 }
48444 {
48445 resultobj = wxPyMake_wxObject(result, (bool)0);
48446 }
48447 return resultobj;
48448 fail:
48449 return NULL;
48450 }
48451
48452
48453 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48454 PyObject *obj;
48455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48456 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48457 return SWIG_Py_Void();
48458 }
48459
48460 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48461 return SWIG_Python_InitShadowInstance(args);
48462 }
48463
48464 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48465 PyObject *resultobj = 0;
48466 int arg1 = (int) 0 ;
48467 int arg2 = (int) 0 ;
48468 wxGBPosition *result = 0 ;
48469 int val1 ;
48470 int ecode1 = 0 ;
48471 int val2 ;
48472 int ecode2 = 0 ;
48473 PyObject * obj0 = 0 ;
48474 PyObject * obj1 = 0 ;
48475 char * kwnames[] = {
48476 (char *) "row",(char *) "col", NULL
48477 };
48478
48479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48480 if (obj0) {
48481 ecode1 = SWIG_AsVal_int(obj0, &val1);
48482 if (!SWIG_IsOK(ecode1)) {
48483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48484 }
48485 arg1 = static_cast< int >(val1);
48486 }
48487 if (obj1) {
48488 ecode2 = SWIG_AsVal_int(obj1, &val2);
48489 if (!SWIG_IsOK(ecode2)) {
48490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48491 }
48492 arg2 = static_cast< int >(val2);
48493 }
48494 {
48495 PyThreadState* __tstate = wxPyBeginAllowThreads();
48496 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48497 wxPyEndAllowThreads(__tstate);
48498 if (PyErr_Occurred()) SWIG_fail;
48499 }
48500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48501 return resultobj;
48502 fail:
48503 return NULL;
48504 }
48505
48506
48507 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48508 PyObject *resultobj = 0;
48509 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48510 void *argp1 = 0 ;
48511 int res1 = 0 ;
48512 PyObject *swig_obj[1] ;
48513
48514 if (!args) SWIG_fail;
48515 swig_obj[0] = args;
48516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48517 if (!SWIG_IsOK(res1)) {
48518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48519 }
48520 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48521 {
48522 PyThreadState* __tstate = wxPyBeginAllowThreads();
48523 delete arg1;
48524
48525 wxPyEndAllowThreads(__tstate);
48526 if (PyErr_Occurred()) SWIG_fail;
48527 }
48528 resultobj = SWIG_Py_Void();
48529 return resultobj;
48530 fail:
48531 return NULL;
48532 }
48533
48534
48535 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48536 PyObject *resultobj = 0;
48537 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48538 int result;
48539 void *argp1 = 0 ;
48540 int res1 = 0 ;
48541 PyObject *swig_obj[1] ;
48542
48543 if (!args) SWIG_fail;
48544 swig_obj[0] = args;
48545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48546 if (!SWIG_IsOK(res1)) {
48547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48548 }
48549 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48550 {
48551 PyThreadState* __tstate = wxPyBeginAllowThreads();
48552 result = (int)((wxGBPosition const *)arg1)->GetRow();
48553 wxPyEndAllowThreads(__tstate);
48554 if (PyErr_Occurred()) SWIG_fail;
48555 }
48556 resultobj = SWIG_From_int(static_cast< int >(result));
48557 return resultobj;
48558 fail:
48559 return NULL;
48560 }
48561
48562
48563 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48564 PyObject *resultobj = 0;
48565 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48566 int result;
48567 void *argp1 = 0 ;
48568 int res1 = 0 ;
48569 PyObject *swig_obj[1] ;
48570
48571 if (!args) SWIG_fail;
48572 swig_obj[0] = args;
48573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48574 if (!SWIG_IsOK(res1)) {
48575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48576 }
48577 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48578 {
48579 PyThreadState* __tstate = wxPyBeginAllowThreads();
48580 result = (int)((wxGBPosition const *)arg1)->GetCol();
48581 wxPyEndAllowThreads(__tstate);
48582 if (PyErr_Occurred()) SWIG_fail;
48583 }
48584 resultobj = SWIG_From_int(static_cast< int >(result));
48585 return resultobj;
48586 fail:
48587 return NULL;
48588 }
48589
48590
48591 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48592 PyObject *resultobj = 0;
48593 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48594 int arg2 ;
48595 void *argp1 = 0 ;
48596 int res1 = 0 ;
48597 int val2 ;
48598 int ecode2 = 0 ;
48599 PyObject * obj0 = 0 ;
48600 PyObject * obj1 = 0 ;
48601 char * kwnames[] = {
48602 (char *) "self",(char *) "row", NULL
48603 };
48604
48605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48607 if (!SWIG_IsOK(res1)) {
48608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48609 }
48610 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48611 ecode2 = SWIG_AsVal_int(obj1, &val2);
48612 if (!SWIG_IsOK(ecode2)) {
48613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48614 }
48615 arg2 = static_cast< int >(val2);
48616 {
48617 PyThreadState* __tstate = wxPyBeginAllowThreads();
48618 (arg1)->SetRow(arg2);
48619 wxPyEndAllowThreads(__tstate);
48620 if (PyErr_Occurred()) SWIG_fail;
48621 }
48622 resultobj = SWIG_Py_Void();
48623 return resultobj;
48624 fail:
48625 return NULL;
48626 }
48627
48628
48629 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48630 PyObject *resultobj = 0;
48631 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48632 int arg2 ;
48633 void *argp1 = 0 ;
48634 int res1 = 0 ;
48635 int val2 ;
48636 int ecode2 = 0 ;
48637 PyObject * obj0 = 0 ;
48638 PyObject * obj1 = 0 ;
48639 char * kwnames[] = {
48640 (char *) "self",(char *) "col", NULL
48641 };
48642
48643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48645 if (!SWIG_IsOK(res1)) {
48646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48647 }
48648 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48649 ecode2 = SWIG_AsVal_int(obj1, &val2);
48650 if (!SWIG_IsOK(ecode2)) {
48651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48652 }
48653 arg2 = static_cast< int >(val2);
48654 {
48655 PyThreadState* __tstate = wxPyBeginAllowThreads();
48656 (arg1)->SetCol(arg2);
48657 wxPyEndAllowThreads(__tstate);
48658 if (PyErr_Occurred()) SWIG_fail;
48659 }
48660 resultobj = SWIG_Py_Void();
48661 return resultobj;
48662 fail:
48663 return NULL;
48664 }
48665
48666
48667 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48668 PyObject *resultobj = 0;
48669 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48670 wxGBPosition *arg2 = 0 ;
48671 bool result;
48672 void *argp1 = 0 ;
48673 int res1 = 0 ;
48674 wxGBPosition temp2 ;
48675 PyObject * obj0 = 0 ;
48676 PyObject * obj1 = 0 ;
48677 char * kwnames[] = {
48678 (char *) "self",(char *) "other", NULL
48679 };
48680
48681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48683 if (!SWIG_IsOK(res1)) {
48684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48685 }
48686 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48687 {
48688 arg2 = &temp2;
48689 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48690 }
48691 {
48692 PyThreadState* __tstate = wxPyBeginAllowThreads();
48693 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
48694 wxPyEndAllowThreads(__tstate);
48695 if (PyErr_Occurred()) SWIG_fail;
48696 }
48697 {
48698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48699 }
48700 return resultobj;
48701 fail:
48702 return NULL;
48703 }
48704
48705
48706 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48707 PyObject *resultobj = 0;
48708 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48709 wxGBPosition *arg2 = 0 ;
48710 bool result;
48711 void *argp1 = 0 ;
48712 int res1 = 0 ;
48713 wxGBPosition temp2 ;
48714 PyObject * obj0 = 0 ;
48715 PyObject * obj1 = 0 ;
48716 char * kwnames[] = {
48717 (char *) "self",(char *) "other", NULL
48718 };
48719
48720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48722 if (!SWIG_IsOK(res1)) {
48723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48724 }
48725 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48726 {
48727 arg2 = &temp2;
48728 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48729 }
48730 {
48731 PyThreadState* __tstate = wxPyBeginAllowThreads();
48732 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
48733 wxPyEndAllowThreads(__tstate);
48734 if (PyErr_Occurred()) SWIG_fail;
48735 }
48736 {
48737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48738 }
48739 return resultobj;
48740 fail:
48741 return NULL;
48742 }
48743
48744
48745 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48746 PyObject *resultobj = 0;
48747 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48748 int arg2 = (int) 0 ;
48749 int arg3 = (int) 0 ;
48750 void *argp1 = 0 ;
48751 int res1 = 0 ;
48752 int val2 ;
48753 int ecode2 = 0 ;
48754 int val3 ;
48755 int ecode3 = 0 ;
48756 PyObject * obj0 = 0 ;
48757 PyObject * obj1 = 0 ;
48758 PyObject * obj2 = 0 ;
48759 char * kwnames[] = {
48760 (char *) "self",(char *) "row",(char *) "col", NULL
48761 };
48762
48763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48765 if (!SWIG_IsOK(res1)) {
48766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48767 }
48768 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48769 if (obj1) {
48770 ecode2 = SWIG_AsVal_int(obj1, &val2);
48771 if (!SWIG_IsOK(ecode2)) {
48772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48773 }
48774 arg2 = static_cast< int >(val2);
48775 }
48776 if (obj2) {
48777 ecode3 = SWIG_AsVal_int(obj2, &val3);
48778 if (!SWIG_IsOK(ecode3)) {
48779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48780 }
48781 arg3 = static_cast< int >(val3);
48782 }
48783 {
48784 PyThreadState* __tstate = wxPyBeginAllowThreads();
48785 wxGBPosition_Set(arg1,arg2,arg3);
48786 wxPyEndAllowThreads(__tstate);
48787 if (PyErr_Occurred()) SWIG_fail;
48788 }
48789 resultobj = SWIG_Py_Void();
48790 return resultobj;
48791 fail:
48792 return NULL;
48793 }
48794
48795
48796 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48797 PyObject *resultobj = 0;
48798 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48799 PyObject *result = 0 ;
48800 void *argp1 = 0 ;
48801 int res1 = 0 ;
48802 PyObject *swig_obj[1] ;
48803
48804 if (!args) SWIG_fail;
48805 swig_obj[0] = args;
48806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48807 if (!SWIG_IsOK(res1)) {
48808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48809 }
48810 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48811 {
48812 PyThreadState* __tstate = wxPyBeginAllowThreads();
48813 result = (PyObject *)wxGBPosition_Get(arg1);
48814 wxPyEndAllowThreads(__tstate);
48815 if (PyErr_Occurred()) SWIG_fail;
48816 }
48817 resultobj = result;
48818 return resultobj;
48819 fail:
48820 return NULL;
48821 }
48822
48823
48824 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48825 PyObject *obj;
48826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48827 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48828 return SWIG_Py_Void();
48829 }
48830
48831 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48832 return SWIG_Python_InitShadowInstance(args);
48833 }
48834
48835 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48836 PyObject *resultobj = 0;
48837 int arg1 = (int) 1 ;
48838 int arg2 = (int) 1 ;
48839 wxGBSpan *result = 0 ;
48840 int val1 ;
48841 int ecode1 = 0 ;
48842 int val2 ;
48843 int ecode2 = 0 ;
48844 PyObject * obj0 = 0 ;
48845 PyObject * obj1 = 0 ;
48846 char * kwnames[] = {
48847 (char *) "rowspan",(char *) "colspan", NULL
48848 };
48849
48850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48851 if (obj0) {
48852 ecode1 = SWIG_AsVal_int(obj0, &val1);
48853 if (!SWIG_IsOK(ecode1)) {
48854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48855 }
48856 arg1 = static_cast< int >(val1);
48857 }
48858 if (obj1) {
48859 ecode2 = SWIG_AsVal_int(obj1, &val2);
48860 if (!SWIG_IsOK(ecode2)) {
48861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48862 }
48863 arg2 = static_cast< int >(val2);
48864 }
48865 {
48866 PyThreadState* __tstate = wxPyBeginAllowThreads();
48867 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48868 wxPyEndAllowThreads(__tstate);
48869 if (PyErr_Occurred()) SWIG_fail;
48870 }
48871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48872 return resultobj;
48873 fail:
48874 return NULL;
48875 }
48876
48877
48878 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48879 PyObject *resultobj = 0;
48880 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48881 void *argp1 = 0 ;
48882 int res1 = 0 ;
48883 PyObject *swig_obj[1] ;
48884
48885 if (!args) SWIG_fail;
48886 swig_obj[0] = args;
48887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48888 if (!SWIG_IsOK(res1)) {
48889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48890 }
48891 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48892 {
48893 PyThreadState* __tstate = wxPyBeginAllowThreads();
48894 delete arg1;
48895
48896 wxPyEndAllowThreads(__tstate);
48897 if (PyErr_Occurred()) SWIG_fail;
48898 }
48899 resultobj = SWIG_Py_Void();
48900 return resultobj;
48901 fail:
48902 return NULL;
48903 }
48904
48905
48906 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48907 PyObject *resultobj = 0;
48908 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48909 int result;
48910 void *argp1 = 0 ;
48911 int res1 = 0 ;
48912 PyObject *swig_obj[1] ;
48913
48914 if (!args) SWIG_fail;
48915 swig_obj[0] = args;
48916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48917 if (!SWIG_IsOK(res1)) {
48918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48919 }
48920 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48921 {
48922 PyThreadState* __tstate = wxPyBeginAllowThreads();
48923 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48924 wxPyEndAllowThreads(__tstate);
48925 if (PyErr_Occurred()) SWIG_fail;
48926 }
48927 resultobj = SWIG_From_int(static_cast< int >(result));
48928 return resultobj;
48929 fail:
48930 return NULL;
48931 }
48932
48933
48934 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48935 PyObject *resultobj = 0;
48936 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48937 int result;
48938 void *argp1 = 0 ;
48939 int res1 = 0 ;
48940 PyObject *swig_obj[1] ;
48941
48942 if (!args) SWIG_fail;
48943 swig_obj[0] = args;
48944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48945 if (!SWIG_IsOK(res1)) {
48946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48947 }
48948 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48949 {
48950 PyThreadState* __tstate = wxPyBeginAllowThreads();
48951 result = (int)((wxGBSpan const *)arg1)->GetColspan();
48952 wxPyEndAllowThreads(__tstate);
48953 if (PyErr_Occurred()) SWIG_fail;
48954 }
48955 resultobj = SWIG_From_int(static_cast< int >(result));
48956 return resultobj;
48957 fail:
48958 return NULL;
48959 }
48960
48961
48962 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48963 PyObject *resultobj = 0;
48964 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48965 int arg2 ;
48966 void *argp1 = 0 ;
48967 int res1 = 0 ;
48968 int val2 ;
48969 int ecode2 = 0 ;
48970 PyObject * obj0 = 0 ;
48971 PyObject * obj1 = 0 ;
48972 char * kwnames[] = {
48973 (char *) "self",(char *) "rowspan", NULL
48974 };
48975
48976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
48977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48978 if (!SWIG_IsOK(res1)) {
48979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48980 }
48981 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48982 ecode2 = SWIG_AsVal_int(obj1, &val2);
48983 if (!SWIG_IsOK(ecode2)) {
48984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
48985 }
48986 arg2 = static_cast< int >(val2);
48987 {
48988 PyThreadState* __tstate = wxPyBeginAllowThreads();
48989 (arg1)->SetRowspan(arg2);
48990 wxPyEndAllowThreads(__tstate);
48991 if (PyErr_Occurred()) SWIG_fail;
48992 }
48993 resultobj = SWIG_Py_Void();
48994 return resultobj;
48995 fail:
48996 return NULL;
48997 }
48998
48999
49000 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49001 PyObject *resultobj = 0;
49002 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49003 int arg2 ;
49004 void *argp1 = 0 ;
49005 int res1 = 0 ;
49006 int val2 ;
49007 int ecode2 = 0 ;
49008 PyObject * obj0 = 0 ;
49009 PyObject * obj1 = 0 ;
49010 char * kwnames[] = {
49011 (char *) "self",(char *) "colspan", NULL
49012 };
49013
49014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49016 if (!SWIG_IsOK(res1)) {
49017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49018 }
49019 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49020 ecode2 = SWIG_AsVal_int(obj1, &val2);
49021 if (!SWIG_IsOK(ecode2)) {
49022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49023 }
49024 arg2 = static_cast< int >(val2);
49025 {
49026 PyThreadState* __tstate = wxPyBeginAllowThreads();
49027 (arg1)->SetColspan(arg2);
49028 wxPyEndAllowThreads(__tstate);
49029 if (PyErr_Occurred()) SWIG_fail;
49030 }
49031 resultobj = SWIG_Py_Void();
49032 return resultobj;
49033 fail:
49034 return NULL;
49035 }
49036
49037
49038 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49039 PyObject *resultobj = 0;
49040 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49041 wxGBSpan *arg2 = 0 ;
49042 bool result;
49043 void *argp1 = 0 ;
49044 int res1 = 0 ;
49045 wxGBSpan temp2 ;
49046 PyObject * obj0 = 0 ;
49047 PyObject * obj1 = 0 ;
49048 char * kwnames[] = {
49049 (char *) "self",(char *) "other", NULL
49050 };
49051
49052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49054 if (!SWIG_IsOK(res1)) {
49055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49056 }
49057 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49058 {
49059 arg2 = &temp2;
49060 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49061 }
49062 {
49063 PyThreadState* __tstate = wxPyBeginAllowThreads();
49064 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
49065 wxPyEndAllowThreads(__tstate);
49066 if (PyErr_Occurred()) SWIG_fail;
49067 }
49068 {
49069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49070 }
49071 return resultobj;
49072 fail:
49073 return NULL;
49074 }
49075
49076
49077 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49078 PyObject *resultobj = 0;
49079 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49080 wxGBSpan *arg2 = 0 ;
49081 bool result;
49082 void *argp1 = 0 ;
49083 int res1 = 0 ;
49084 wxGBSpan temp2 ;
49085 PyObject * obj0 = 0 ;
49086 PyObject * obj1 = 0 ;
49087 char * kwnames[] = {
49088 (char *) "self",(char *) "other", NULL
49089 };
49090
49091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49093 if (!SWIG_IsOK(res1)) {
49094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49095 }
49096 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49097 {
49098 arg2 = &temp2;
49099 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49100 }
49101 {
49102 PyThreadState* __tstate = wxPyBeginAllowThreads();
49103 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
49104 wxPyEndAllowThreads(__tstate);
49105 if (PyErr_Occurred()) SWIG_fail;
49106 }
49107 {
49108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49109 }
49110 return resultobj;
49111 fail:
49112 return NULL;
49113 }
49114
49115
49116 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49117 PyObject *resultobj = 0;
49118 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49119 int arg2 = (int) 1 ;
49120 int arg3 = (int) 1 ;
49121 void *argp1 = 0 ;
49122 int res1 = 0 ;
49123 int val2 ;
49124 int ecode2 = 0 ;
49125 int val3 ;
49126 int ecode3 = 0 ;
49127 PyObject * obj0 = 0 ;
49128 PyObject * obj1 = 0 ;
49129 PyObject * obj2 = 0 ;
49130 char * kwnames[] = {
49131 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49132 };
49133
49134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49136 if (!SWIG_IsOK(res1)) {
49137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49138 }
49139 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49140 if (obj1) {
49141 ecode2 = SWIG_AsVal_int(obj1, &val2);
49142 if (!SWIG_IsOK(ecode2)) {
49143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49144 }
49145 arg2 = static_cast< int >(val2);
49146 }
49147 if (obj2) {
49148 ecode3 = SWIG_AsVal_int(obj2, &val3);
49149 if (!SWIG_IsOK(ecode3)) {
49150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49151 }
49152 arg3 = static_cast< int >(val3);
49153 }
49154 {
49155 PyThreadState* __tstate = wxPyBeginAllowThreads();
49156 wxGBSpan_Set(arg1,arg2,arg3);
49157 wxPyEndAllowThreads(__tstate);
49158 if (PyErr_Occurred()) SWIG_fail;
49159 }
49160 resultobj = SWIG_Py_Void();
49161 return resultobj;
49162 fail:
49163 return NULL;
49164 }
49165
49166
49167 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49168 PyObject *resultobj = 0;
49169 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49170 PyObject *result = 0 ;
49171 void *argp1 = 0 ;
49172 int res1 = 0 ;
49173 PyObject *swig_obj[1] ;
49174
49175 if (!args) SWIG_fail;
49176 swig_obj[0] = args;
49177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49178 if (!SWIG_IsOK(res1)) {
49179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49180 }
49181 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49182 {
49183 PyThreadState* __tstate = wxPyBeginAllowThreads();
49184 result = (PyObject *)wxGBSpan_Get(arg1);
49185 wxPyEndAllowThreads(__tstate);
49186 if (PyErr_Occurred()) SWIG_fail;
49187 }
49188 resultobj = result;
49189 return resultobj;
49190 fail:
49191 return NULL;
49192 }
49193
49194
49195 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49196 PyObject *obj;
49197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49198 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49199 return SWIG_Py_Void();
49200 }
49201
49202 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49203 return SWIG_Python_InitShadowInstance(args);
49204 }
49205
49206 SWIGINTERN int DefaultSpan_set(PyObject *) {
49207 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49208 return 1;
49209 }
49210
49211
49212 SWIGINTERN PyObject *DefaultSpan_get(void) {
49213 PyObject *pyobj = 0;
49214
49215 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49216 return pyobj;
49217 }
49218
49219
49220 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49221 PyObject *resultobj = 0;
49222 wxGBSizerItem *result = 0 ;
49223
49224 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49225 {
49226 PyThreadState* __tstate = wxPyBeginAllowThreads();
49227 result = (wxGBSizerItem *)new wxGBSizerItem();
49228 wxPyEndAllowThreads(__tstate);
49229 if (PyErr_Occurred()) SWIG_fail;
49230 }
49231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49232 return resultobj;
49233 fail:
49234 return NULL;
49235 }
49236
49237
49238 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49239 PyObject *resultobj = 0;
49240 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49241 void *argp1 = 0 ;
49242 int res1 = 0 ;
49243 PyObject *swig_obj[1] ;
49244
49245 if (!args) SWIG_fail;
49246 swig_obj[0] = args;
49247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49248 if (!SWIG_IsOK(res1)) {
49249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49250 }
49251 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49252 {
49253 PyThreadState* __tstate = wxPyBeginAllowThreads();
49254 delete arg1;
49255
49256 wxPyEndAllowThreads(__tstate);
49257 if (PyErr_Occurred()) SWIG_fail;
49258 }
49259 resultobj = SWIG_Py_Void();
49260 return resultobj;
49261 fail:
49262 return NULL;
49263 }
49264
49265
49266 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49267 PyObject *resultobj = 0;
49268 wxWindow *arg1 = (wxWindow *) 0 ;
49269 wxGBPosition *arg2 = 0 ;
49270 wxGBSpan *arg3 = 0 ;
49271 int arg4 ;
49272 int arg5 ;
49273 PyObject *arg6 = (PyObject *) NULL ;
49274 wxGBSizerItem *result = 0 ;
49275 void *argp1 = 0 ;
49276 int res1 = 0 ;
49277 wxGBPosition temp2 ;
49278 wxGBSpan temp3 ;
49279 int val4 ;
49280 int ecode4 = 0 ;
49281 int val5 ;
49282 int ecode5 = 0 ;
49283 PyObject * obj0 = 0 ;
49284 PyObject * obj1 = 0 ;
49285 PyObject * obj2 = 0 ;
49286 PyObject * obj3 = 0 ;
49287 PyObject * obj4 = 0 ;
49288 PyObject * obj5 = 0 ;
49289 char * kwnames[] = {
49290 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49291 };
49292
49293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49295 if (!SWIG_IsOK(res1)) {
49296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49297 }
49298 arg1 = reinterpret_cast< wxWindow * >(argp1);
49299 {
49300 arg2 = &temp2;
49301 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49302 }
49303 {
49304 arg3 = &temp3;
49305 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49306 }
49307 ecode4 = SWIG_AsVal_int(obj3, &val4);
49308 if (!SWIG_IsOK(ecode4)) {
49309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49310 }
49311 arg4 = static_cast< int >(val4);
49312 ecode5 = SWIG_AsVal_int(obj4, &val5);
49313 if (!SWIG_IsOK(ecode5)) {
49314 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49315 }
49316 arg5 = static_cast< int >(val5);
49317 if (obj5) {
49318 arg6 = obj5;
49319 }
49320 {
49321 PyThreadState* __tstate = wxPyBeginAllowThreads();
49322 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49323 wxPyEndAllowThreads(__tstate);
49324 if (PyErr_Occurred()) SWIG_fail;
49325 }
49326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49327 return resultobj;
49328 fail:
49329 return NULL;
49330 }
49331
49332
49333 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49334 PyObject *resultobj = 0;
49335 wxSizer *arg1 = (wxSizer *) 0 ;
49336 wxGBPosition *arg2 = 0 ;
49337 wxGBSpan *arg3 = 0 ;
49338 int arg4 ;
49339 int arg5 ;
49340 PyObject *arg6 = (PyObject *) NULL ;
49341 wxGBSizerItem *result = 0 ;
49342 int res1 = 0 ;
49343 wxGBPosition temp2 ;
49344 wxGBSpan temp3 ;
49345 int val4 ;
49346 int ecode4 = 0 ;
49347 int val5 ;
49348 int ecode5 = 0 ;
49349 PyObject * obj0 = 0 ;
49350 PyObject * obj1 = 0 ;
49351 PyObject * obj2 = 0 ;
49352 PyObject * obj3 = 0 ;
49353 PyObject * obj4 = 0 ;
49354 PyObject * obj5 = 0 ;
49355 char * kwnames[] = {
49356 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49357 };
49358
49359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49360 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49361 if (!SWIG_IsOK(res1)) {
49362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49363 }
49364 {
49365 arg2 = &temp2;
49366 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49367 }
49368 {
49369 arg3 = &temp3;
49370 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49371 }
49372 ecode4 = SWIG_AsVal_int(obj3, &val4);
49373 if (!SWIG_IsOK(ecode4)) {
49374 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49375 }
49376 arg4 = static_cast< int >(val4);
49377 ecode5 = SWIG_AsVal_int(obj4, &val5);
49378 if (!SWIG_IsOK(ecode5)) {
49379 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49380 }
49381 arg5 = static_cast< int >(val5);
49382 if (obj5) {
49383 arg6 = obj5;
49384 }
49385 {
49386 PyThreadState* __tstate = wxPyBeginAllowThreads();
49387 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49388 wxPyEndAllowThreads(__tstate);
49389 if (PyErr_Occurred()) SWIG_fail;
49390 }
49391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49392 return resultobj;
49393 fail:
49394 return NULL;
49395 }
49396
49397
49398 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49399 PyObject *resultobj = 0;
49400 int arg1 ;
49401 int arg2 ;
49402 wxGBPosition *arg3 = 0 ;
49403 wxGBSpan *arg4 = 0 ;
49404 int arg5 ;
49405 int arg6 ;
49406 PyObject *arg7 = (PyObject *) NULL ;
49407 wxGBSizerItem *result = 0 ;
49408 int val1 ;
49409 int ecode1 = 0 ;
49410 int val2 ;
49411 int ecode2 = 0 ;
49412 wxGBPosition temp3 ;
49413 wxGBSpan temp4 ;
49414 int val5 ;
49415 int ecode5 = 0 ;
49416 int val6 ;
49417 int ecode6 = 0 ;
49418 PyObject * obj0 = 0 ;
49419 PyObject * obj1 = 0 ;
49420 PyObject * obj2 = 0 ;
49421 PyObject * obj3 = 0 ;
49422 PyObject * obj4 = 0 ;
49423 PyObject * obj5 = 0 ;
49424 PyObject * obj6 = 0 ;
49425 char * kwnames[] = {
49426 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49427 };
49428
49429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49430 ecode1 = SWIG_AsVal_int(obj0, &val1);
49431 if (!SWIG_IsOK(ecode1)) {
49432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49433 }
49434 arg1 = static_cast< int >(val1);
49435 ecode2 = SWIG_AsVal_int(obj1, &val2);
49436 if (!SWIG_IsOK(ecode2)) {
49437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49438 }
49439 arg2 = static_cast< int >(val2);
49440 {
49441 arg3 = &temp3;
49442 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49443 }
49444 {
49445 arg4 = &temp4;
49446 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49447 }
49448 ecode5 = SWIG_AsVal_int(obj4, &val5);
49449 if (!SWIG_IsOK(ecode5)) {
49450 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49451 }
49452 arg5 = static_cast< int >(val5);
49453 ecode6 = SWIG_AsVal_int(obj5, &val6);
49454 if (!SWIG_IsOK(ecode6)) {
49455 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49456 }
49457 arg6 = static_cast< int >(val6);
49458 if (obj6) {
49459 arg7 = obj6;
49460 }
49461 {
49462 PyThreadState* __tstate = wxPyBeginAllowThreads();
49463 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49464 wxPyEndAllowThreads(__tstate);
49465 if (PyErr_Occurred()) SWIG_fail;
49466 }
49467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49468 return resultobj;
49469 fail:
49470 return NULL;
49471 }
49472
49473
49474 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49475 PyObject *resultobj = 0;
49476 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49477 wxGBPosition result;
49478 void *argp1 = 0 ;
49479 int res1 = 0 ;
49480 PyObject *swig_obj[1] ;
49481
49482 if (!args) SWIG_fail;
49483 swig_obj[0] = args;
49484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49485 if (!SWIG_IsOK(res1)) {
49486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49487 }
49488 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49489 {
49490 PyThreadState* __tstate = wxPyBeginAllowThreads();
49491 result = ((wxGBSizerItem const *)arg1)->GetPos();
49492 wxPyEndAllowThreads(__tstate);
49493 if (PyErr_Occurred()) SWIG_fail;
49494 }
49495 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49496 return resultobj;
49497 fail:
49498 return NULL;
49499 }
49500
49501
49502 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49503 PyObject *resultobj = 0;
49504 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49505 wxGBSpan result;
49506 void *argp1 = 0 ;
49507 int res1 = 0 ;
49508 PyObject *swig_obj[1] ;
49509
49510 if (!args) SWIG_fail;
49511 swig_obj[0] = args;
49512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49513 if (!SWIG_IsOK(res1)) {
49514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49515 }
49516 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49517 {
49518 PyThreadState* __tstate = wxPyBeginAllowThreads();
49519 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49520 wxPyEndAllowThreads(__tstate);
49521 if (PyErr_Occurred()) SWIG_fail;
49522 }
49523 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49524 return resultobj;
49525 fail:
49526 return NULL;
49527 }
49528
49529
49530 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49531 PyObject *resultobj = 0;
49532 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49533 wxGBPosition *arg2 = 0 ;
49534 bool result;
49535 void *argp1 = 0 ;
49536 int res1 = 0 ;
49537 wxGBPosition temp2 ;
49538 PyObject * obj0 = 0 ;
49539 PyObject * obj1 = 0 ;
49540 char * kwnames[] = {
49541 (char *) "self",(char *) "pos", NULL
49542 };
49543
49544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49546 if (!SWIG_IsOK(res1)) {
49547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49548 }
49549 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49550 {
49551 arg2 = &temp2;
49552 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49553 }
49554 {
49555 PyThreadState* __tstate = wxPyBeginAllowThreads();
49556 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49557 wxPyEndAllowThreads(__tstate);
49558 if (PyErr_Occurred()) SWIG_fail;
49559 }
49560 {
49561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49562 }
49563 return resultobj;
49564 fail:
49565 return NULL;
49566 }
49567
49568
49569 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49570 PyObject *resultobj = 0;
49571 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49572 wxGBSpan *arg2 = 0 ;
49573 bool result;
49574 void *argp1 = 0 ;
49575 int res1 = 0 ;
49576 wxGBSpan temp2 ;
49577 PyObject * obj0 = 0 ;
49578 PyObject * obj1 = 0 ;
49579 char * kwnames[] = {
49580 (char *) "self",(char *) "span", NULL
49581 };
49582
49583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49585 if (!SWIG_IsOK(res1)) {
49586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49587 }
49588 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49589 {
49590 arg2 = &temp2;
49591 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49592 }
49593 {
49594 PyThreadState* __tstate = wxPyBeginAllowThreads();
49595 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49596 wxPyEndAllowThreads(__tstate);
49597 if (PyErr_Occurred()) SWIG_fail;
49598 }
49599 {
49600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49601 }
49602 return resultobj;
49603 fail:
49604 return NULL;
49605 }
49606
49607
49608 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49609 PyObject *resultobj = 0;
49610 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49611 wxGBSizerItem *arg2 = 0 ;
49612 bool result;
49613 void *argp1 = 0 ;
49614 int res1 = 0 ;
49615 void *argp2 = 0 ;
49616 int res2 = 0 ;
49617 PyObject * obj0 = 0 ;
49618 PyObject * obj1 = 0 ;
49619 char * kwnames[] = {
49620 (char *) "self",(char *) "other", NULL
49621 };
49622
49623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49625 if (!SWIG_IsOK(res1)) {
49626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49627 }
49628 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49629 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49630 if (!SWIG_IsOK(res2)) {
49631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49632 }
49633 if (!argp2) {
49634 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49635 }
49636 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49637 {
49638 PyThreadState* __tstate = wxPyBeginAllowThreads();
49639 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49640 wxPyEndAllowThreads(__tstate);
49641 if (PyErr_Occurred()) SWIG_fail;
49642 }
49643 {
49644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49645 }
49646 return resultobj;
49647 fail:
49648 return NULL;
49649 }
49650
49651
49652 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49653 PyObject *resultobj = 0;
49654 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49655 wxGBPosition *arg2 = 0 ;
49656 wxGBSpan *arg3 = 0 ;
49657 bool result;
49658 void *argp1 = 0 ;
49659 int res1 = 0 ;
49660 wxGBPosition temp2 ;
49661 wxGBSpan temp3 ;
49662 PyObject * obj0 = 0 ;
49663 PyObject * obj1 = 0 ;
49664 PyObject * obj2 = 0 ;
49665 char * kwnames[] = {
49666 (char *) "self",(char *) "pos",(char *) "span", NULL
49667 };
49668
49669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49671 if (!SWIG_IsOK(res1)) {
49672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49673 }
49674 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49675 {
49676 arg2 = &temp2;
49677 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49678 }
49679 {
49680 arg3 = &temp3;
49681 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49682 }
49683 {
49684 PyThreadState* __tstate = wxPyBeginAllowThreads();
49685 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49686 wxPyEndAllowThreads(__tstate);
49687 if (PyErr_Occurred()) SWIG_fail;
49688 }
49689 {
49690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49691 }
49692 return resultobj;
49693 fail:
49694 return NULL;
49695 }
49696
49697
49698 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49699 PyObject *resultobj = 0;
49700 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49701 wxGBPosition result;
49702 void *argp1 = 0 ;
49703 int res1 = 0 ;
49704 PyObject *swig_obj[1] ;
49705
49706 if (!args) SWIG_fail;
49707 swig_obj[0] = args;
49708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49709 if (!SWIG_IsOK(res1)) {
49710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49711 }
49712 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49713 {
49714 PyThreadState* __tstate = wxPyBeginAllowThreads();
49715 result = wxGBSizerItem_GetEndPos(arg1);
49716 wxPyEndAllowThreads(__tstate);
49717 if (PyErr_Occurred()) SWIG_fail;
49718 }
49719 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49720 return resultobj;
49721 fail:
49722 return NULL;
49723 }
49724
49725
49726 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49727 PyObject *resultobj = 0;
49728 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49729 wxGridBagSizer *result = 0 ;
49730 void *argp1 = 0 ;
49731 int res1 = 0 ;
49732 PyObject *swig_obj[1] ;
49733
49734 if (!args) SWIG_fail;
49735 swig_obj[0] = args;
49736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49737 if (!SWIG_IsOK(res1)) {
49738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49739 }
49740 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49741 {
49742 PyThreadState* __tstate = wxPyBeginAllowThreads();
49743 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49744 wxPyEndAllowThreads(__tstate);
49745 if (PyErr_Occurred()) SWIG_fail;
49746 }
49747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49748 return resultobj;
49749 fail:
49750 return NULL;
49751 }
49752
49753
49754 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49755 PyObject *resultobj = 0;
49756 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49757 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49758 void *argp1 = 0 ;
49759 int res1 = 0 ;
49760 void *argp2 = 0 ;
49761 int res2 = 0 ;
49762 PyObject * obj0 = 0 ;
49763 PyObject * obj1 = 0 ;
49764 char * kwnames[] = {
49765 (char *) "self",(char *) "sizer", NULL
49766 };
49767
49768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49770 if (!SWIG_IsOK(res1)) {
49771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49772 }
49773 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49775 if (!SWIG_IsOK(res2)) {
49776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49777 }
49778 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49779 {
49780 PyThreadState* __tstate = wxPyBeginAllowThreads();
49781 (arg1)->SetGBSizer(arg2);
49782 wxPyEndAllowThreads(__tstate);
49783 if (PyErr_Occurred()) SWIG_fail;
49784 }
49785 resultobj = SWIG_Py_Void();
49786 return resultobj;
49787 fail:
49788 return NULL;
49789 }
49790
49791
49792 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49793 PyObject *obj;
49794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49795 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49796 return SWIG_Py_Void();
49797 }
49798
49799 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49800 return SWIG_Python_InitShadowInstance(args);
49801 }
49802
49803 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49804 PyObject *resultobj = 0;
49805 int arg1 = (int) 0 ;
49806 int arg2 = (int) 0 ;
49807 wxGridBagSizer *result = 0 ;
49808 int val1 ;
49809 int ecode1 = 0 ;
49810 int val2 ;
49811 int ecode2 = 0 ;
49812 PyObject * obj0 = 0 ;
49813 PyObject * obj1 = 0 ;
49814 char * kwnames[] = {
49815 (char *) "vgap",(char *) "hgap", NULL
49816 };
49817
49818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49819 if (obj0) {
49820 ecode1 = SWIG_AsVal_int(obj0, &val1);
49821 if (!SWIG_IsOK(ecode1)) {
49822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49823 }
49824 arg1 = static_cast< int >(val1);
49825 }
49826 if (obj1) {
49827 ecode2 = SWIG_AsVal_int(obj1, &val2);
49828 if (!SWIG_IsOK(ecode2)) {
49829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49830 }
49831 arg2 = static_cast< int >(val2);
49832 }
49833 {
49834 PyThreadState* __tstate = wxPyBeginAllowThreads();
49835 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49836 wxPyEndAllowThreads(__tstate);
49837 if (PyErr_Occurred()) SWIG_fail;
49838 }
49839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49840 return resultobj;
49841 fail:
49842 return NULL;
49843 }
49844
49845
49846 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49847 PyObject *resultobj = 0;
49848 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49849 PyObject *arg2 = (PyObject *) 0 ;
49850 wxGBPosition *arg3 = 0 ;
49851 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49852 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49853 int arg5 = (int) 0 ;
49854 int arg6 = (int) 0 ;
49855 PyObject *arg7 = (PyObject *) NULL ;
49856 wxGBSizerItem *result = 0 ;
49857 void *argp1 = 0 ;
49858 int res1 = 0 ;
49859 wxGBPosition temp3 ;
49860 wxGBSpan temp4 ;
49861 int val5 ;
49862 int ecode5 = 0 ;
49863 int val6 ;
49864 int ecode6 = 0 ;
49865 PyObject * obj0 = 0 ;
49866 PyObject * obj1 = 0 ;
49867 PyObject * obj2 = 0 ;
49868 PyObject * obj3 = 0 ;
49869 PyObject * obj4 = 0 ;
49870 PyObject * obj5 = 0 ;
49871 PyObject * obj6 = 0 ;
49872 char * kwnames[] = {
49873 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49874 };
49875
49876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49878 if (!SWIG_IsOK(res1)) {
49879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49880 }
49881 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49882 arg2 = obj1;
49883 {
49884 arg3 = &temp3;
49885 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49886 }
49887 if (obj3) {
49888 {
49889 arg4 = &temp4;
49890 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49891 }
49892 }
49893 if (obj4) {
49894 ecode5 = SWIG_AsVal_int(obj4, &val5);
49895 if (!SWIG_IsOK(ecode5)) {
49896 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49897 }
49898 arg5 = static_cast< int >(val5);
49899 }
49900 if (obj5) {
49901 ecode6 = SWIG_AsVal_int(obj5, &val6);
49902 if (!SWIG_IsOK(ecode6)) {
49903 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49904 }
49905 arg6 = static_cast< int >(val6);
49906 }
49907 if (obj6) {
49908 arg7 = obj6;
49909 }
49910 {
49911 PyThreadState* __tstate = wxPyBeginAllowThreads();
49912 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49913 wxPyEndAllowThreads(__tstate);
49914 if (PyErr_Occurred()) SWIG_fail;
49915 }
49916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49917 return resultobj;
49918 fail:
49919 return NULL;
49920 }
49921
49922
49923 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49924 PyObject *resultobj = 0;
49925 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49926 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49927 wxGBSizerItem *result = 0 ;
49928 void *argp1 = 0 ;
49929 int res1 = 0 ;
49930 int res2 = 0 ;
49931 PyObject * obj0 = 0 ;
49932 PyObject * obj1 = 0 ;
49933 char * kwnames[] = {
49934 (char *) "self",(char *) "item", NULL
49935 };
49936
49937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49939 if (!SWIG_IsOK(res1)) {
49940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49941 }
49942 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49943 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49944 if (!SWIG_IsOK(res2)) {
49945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49946 }
49947 {
49948 PyThreadState* __tstate = wxPyBeginAllowThreads();
49949 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49950 wxPyEndAllowThreads(__tstate);
49951 if (PyErr_Occurred()) SWIG_fail;
49952 }
49953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49954 return resultobj;
49955 fail:
49956 return NULL;
49957 }
49958
49959
49960 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49961 PyObject *resultobj = 0;
49962 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49963 int arg2 ;
49964 int arg3 ;
49965 wxSize result;
49966 void *argp1 = 0 ;
49967 int res1 = 0 ;
49968 int val2 ;
49969 int ecode2 = 0 ;
49970 int val3 ;
49971 int ecode3 = 0 ;
49972 PyObject * obj0 = 0 ;
49973 PyObject * obj1 = 0 ;
49974 PyObject * obj2 = 0 ;
49975 char * kwnames[] = {
49976 (char *) "self",(char *) "row",(char *) "col", NULL
49977 };
49978
49979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49981 if (!SWIG_IsOK(res1)) {
49982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49983 }
49984 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49985 ecode2 = SWIG_AsVal_int(obj1, &val2);
49986 if (!SWIG_IsOK(ecode2)) {
49987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
49988 }
49989 arg2 = static_cast< int >(val2);
49990 ecode3 = SWIG_AsVal_int(obj2, &val3);
49991 if (!SWIG_IsOK(ecode3)) {
49992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
49993 }
49994 arg3 = static_cast< int >(val3);
49995 {
49996 PyThreadState* __tstate = wxPyBeginAllowThreads();
49997 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
49998 wxPyEndAllowThreads(__tstate);
49999 if (PyErr_Occurred()) SWIG_fail;
50000 }
50001 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50002 return resultobj;
50003 fail:
50004 return NULL;
50005 }
50006
50007
50008 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50009 PyObject *resultobj = 0;
50010 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50011 wxSize result;
50012 void *argp1 = 0 ;
50013 int res1 = 0 ;
50014 PyObject *swig_obj[1] ;
50015
50016 if (!args) SWIG_fail;
50017 swig_obj[0] = args;
50018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50019 if (!SWIG_IsOK(res1)) {
50020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50021 }
50022 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50023 {
50024 PyThreadState* __tstate = wxPyBeginAllowThreads();
50025 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50026 wxPyEndAllowThreads(__tstate);
50027 if (PyErr_Occurred()) SWIG_fail;
50028 }
50029 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50030 return resultobj;
50031 fail:
50032 return NULL;
50033 }
50034
50035
50036 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50037 PyObject *resultobj = 0;
50038 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50039 wxSize *arg2 = 0 ;
50040 void *argp1 = 0 ;
50041 int res1 = 0 ;
50042 wxSize temp2 ;
50043 PyObject * obj0 = 0 ;
50044 PyObject * obj1 = 0 ;
50045 char * kwnames[] = {
50046 (char *) "self",(char *) "sz", NULL
50047 };
50048
50049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50051 if (!SWIG_IsOK(res1)) {
50052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50053 }
50054 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50055 {
50056 arg2 = &temp2;
50057 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50058 }
50059 {
50060 PyThreadState* __tstate = wxPyBeginAllowThreads();
50061 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50062 wxPyEndAllowThreads(__tstate);
50063 if (PyErr_Occurred()) SWIG_fail;
50064 }
50065 resultobj = SWIG_Py_Void();
50066 return resultobj;
50067 fail:
50068 return NULL;
50069 }
50070
50071
50072 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50073 PyObject *resultobj = 0;
50074 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50075 wxWindow *arg2 = (wxWindow *) 0 ;
50076 wxGBPosition result;
50077 void *argp1 = 0 ;
50078 int res1 = 0 ;
50079 void *argp2 = 0 ;
50080 int res2 = 0 ;
50081
50082 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50084 if (!SWIG_IsOK(res1)) {
50085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50086 }
50087 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50088 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50089 if (!SWIG_IsOK(res2)) {
50090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50091 }
50092 arg2 = reinterpret_cast< wxWindow * >(argp2);
50093 {
50094 PyThreadState* __tstate = wxPyBeginAllowThreads();
50095 result = (arg1)->GetItemPosition(arg2);
50096 wxPyEndAllowThreads(__tstate);
50097 if (PyErr_Occurred()) SWIG_fail;
50098 }
50099 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50100 return resultobj;
50101 fail:
50102 return NULL;
50103 }
50104
50105
50106 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50107 PyObject *resultobj = 0;
50108 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50109 wxSizer *arg2 = (wxSizer *) 0 ;
50110 wxGBPosition result;
50111 void *argp1 = 0 ;
50112 int res1 = 0 ;
50113 void *argp2 = 0 ;
50114 int res2 = 0 ;
50115
50116 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50118 if (!SWIG_IsOK(res1)) {
50119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50120 }
50121 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50122 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50123 if (!SWIG_IsOK(res2)) {
50124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50125 }
50126 arg2 = reinterpret_cast< wxSizer * >(argp2);
50127 {
50128 PyThreadState* __tstate = wxPyBeginAllowThreads();
50129 result = (arg1)->GetItemPosition(arg2);
50130 wxPyEndAllowThreads(__tstate);
50131 if (PyErr_Occurred()) SWIG_fail;
50132 }
50133 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50134 return resultobj;
50135 fail:
50136 return NULL;
50137 }
50138
50139
50140 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50141 PyObject *resultobj = 0;
50142 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50143 size_t arg2 ;
50144 wxGBPosition result;
50145 void *argp1 = 0 ;
50146 int res1 = 0 ;
50147 size_t val2 ;
50148 int ecode2 = 0 ;
50149
50150 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50152 if (!SWIG_IsOK(res1)) {
50153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50154 }
50155 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50156 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50157 if (!SWIG_IsOK(ecode2)) {
50158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50159 }
50160 arg2 = static_cast< size_t >(val2);
50161 {
50162 PyThreadState* __tstate = wxPyBeginAllowThreads();
50163 result = (arg1)->GetItemPosition(arg2);
50164 wxPyEndAllowThreads(__tstate);
50165 if (PyErr_Occurred()) SWIG_fail;
50166 }
50167 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50168 return resultobj;
50169 fail:
50170 return NULL;
50171 }
50172
50173
50174 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50175 int argc;
50176 PyObject *argv[3];
50177
50178 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50179 --argc;
50180 if (argc == 2) {
50181 int _v = 0;
50182 {
50183 void *vptr = 0;
50184 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50185 _v = SWIG_CheckState(res);
50186 }
50187 if (!_v) goto check_1;
50188 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50189 }
50190 check_1:
50191
50192 if (argc == 2) {
50193 int _v = 0;
50194 {
50195 void *vptr = 0;
50196 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50197 _v = SWIG_CheckState(res);
50198 }
50199 if (!_v) goto check_2;
50200 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50201 }
50202 check_2:
50203
50204 if (argc == 2) {
50205 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50206 }
50207
50208 fail:
50209 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50210 return NULL;
50211 }
50212
50213
50214 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50215 PyObject *resultobj = 0;
50216 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50217 wxWindow *arg2 = (wxWindow *) 0 ;
50218 wxGBPosition *arg3 = 0 ;
50219 bool result;
50220 void *argp1 = 0 ;
50221 int res1 = 0 ;
50222 void *argp2 = 0 ;
50223 int res2 = 0 ;
50224 wxGBPosition temp3 ;
50225
50226 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50228 if (!SWIG_IsOK(res1)) {
50229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50230 }
50231 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50232 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50233 if (!SWIG_IsOK(res2)) {
50234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50235 }
50236 arg2 = reinterpret_cast< wxWindow * >(argp2);
50237 {
50238 arg3 = &temp3;
50239 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50240 }
50241 {
50242 PyThreadState* __tstate = wxPyBeginAllowThreads();
50243 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
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_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50257 PyObject *resultobj = 0;
50258 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50259 wxSizer *arg2 = (wxSizer *) 0 ;
50260 wxGBPosition *arg3 = 0 ;
50261 bool result;
50262 void *argp1 = 0 ;
50263 int res1 = 0 ;
50264 void *argp2 = 0 ;
50265 int res2 = 0 ;
50266 wxGBPosition temp3 ;
50267
50268 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50270 if (!SWIG_IsOK(res1)) {
50271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50272 }
50273 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50274 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50275 if (!SWIG_IsOK(res2)) {
50276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50277 }
50278 arg2 = reinterpret_cast< wxSizer * >(argp2);
50279 {
50280 arg3 = &temp3;
50281 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50282 }
50283 {
50284 PyThreadState* __tstate = wxPyBeginAllowThreads();
50285 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50286 wxPyEndAllowThreads(__tstate);
50287 if (PyErr_Occurred()) SWIG_fail;
50288 }
50289 {
50290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50291 }
50292 return resultobj;
50293 fail:
50294 return NULL;
50295 }
50296
50297
50298 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50299 PyObject *resultobj = 0;
50300 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50301 size_t arg2 ;
50302 wxGBPosition *arg3 = 0 ;
50303 bool result;
50304 void *argp1 = 0 ;
50305 int res1 = 0 ;
50306 size_t val2 ;
50307 int ecode2 = 0 ;
50308 wxGBPosition temp3 ;
50309
50310 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50312 if (!SWIG_IsOK(res1)) {
50313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50314 }
50315 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50316 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50317 if (!SWIG_IsOK(ecode2)) {
50318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50319 }
50320 arg2 = static_cast< size_t >(val2);
50321 {
50322 arg3 = &temp3;
50323 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50324 }
50325 {
50326 PyThreadState* __tstate = wxPyBeginAllowThreads();
50327 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50328 wxPyEndAllowThreads(__tstate);
50329 if (PyErr_Occurred()) SWIG_fail;
50330 }
50331 {
50332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50333 }
50334 return resultobj;
50335 fail:
50336 return NULL;
50337 }
50338
50339
50340 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50341 int argc;
50342 PyObject *argv[4];
50343
50344 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50345 --argc;
50346 if (argc == 3) {
50347 int _v = 0;
50348 {
50349 void *vptr = 0;
50350 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50351 _v = SWIG_CheckState(res);
50352 }
50353 if (!_v) goto check_1;
50354 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50355 }
50356 check_1:
50357
50358 if (argc == 3) {
50359 int _v = 0;
50360 {
50361 void *vptr = 0;
50362 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50363 _v = SWIG_CheckState(res);
50364 }
50365 if (!_v) goto check_2;
50366 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50367 }
50368 check_2:
50369
50370 if (argc == 3) {
50371 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50372 }
50373
50374 fail:
50375 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50376 return NULL;
50377 }
50378
50379
50380 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50381 PyObject *resultobj = 0;
50382 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50383 wxWindow *arg2 = (wxWindow *) 0 ;
50384 wxGBSpan result;
50385 void *argp1 = 0 ;
50386 int res1 = 0 ;
50387 void *argp2 = 0 ;
50388 int res2 = 0 ;
50389
50390 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50392 if (!SWIG_IsOK(res1)) {
50393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50394 }
50395 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50396 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50397 if (!SWIG_IsOK(res2)) {
50398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50399 }
50400 arg2 = reinterpret_cast< wxWindow * >(argp2);
50401 {
50402 PyThreadState* __tstate = wxPyBeginAllowThreads();
50403 result = (arg1)->GetItemSpan(arg2);
50404 wxPyEndAllowThreads(__tstate);
50405 if (PyErr_Occurred()) SWIG_fail;
50406 }
50407 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50408 return resultobj;
50409 fail:
50410 return NULL;
50411 }
50412
50413
50414 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50415 PyObject *resultobj = 0;
50416 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50417 wxSizer *arg2 = (wxSizer *) 0 ;
50418 wxGBSpan result;
50419 void *argp1 = 0 ;
50420 int res1 = 0 ;
50421 void *argp2 = 0 ;
50422 int res2 = 0 ;
50423
50424 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50426 if (!SWIG_IsOK(res1)) {
50427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50428 }
50429 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50430 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50431 if (!SWIG_IsOK(res2)) {
50432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50433 }
50434 arg2 = reinterpret_cast< wxSizer * >(argp2);
50435 {
50436 PyThreadState* __tstate = wxPyBeginAllowThreads();
50437 result = (arg1)->GetItemSpan(arg2);
50438 wxPyEndAllowThreads(__tstate);
50439 if (PyErr_Occurred()) SWIG_fail;
50440 }
50441 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50442 return resultobj;
50443 fail:
50444 return NULL;
50445 }
50446
50447
50448 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50449 PyObject *resultobj = 0;
50450 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50451 size_t arg2 ;
50452 wxGBSpan result;
50453 void *argp1 = 0 ;
50454 int res1 = 0 ;
50455 size_t val2 ;
50456 int ecode2 = 0 ;
50457
50458 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50460 if (!SWIG_IsOK(res1)) {
50461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50462 }
50463 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50464 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50465 if (!SWIG_IsOK(ecode2)) {
50466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50467 }
50468 arg2 = static_cast< size_t >(val2);
50469 {
50470 PyThreadState* __tstate = wxPyBeginAllowThreads();
50471 result = (arg1)->GetItemSpan(arg2);
50472 wxPyEndAllowThreads(__tstate);
50473 if (PyErr_Occurred()) SWIG_fail;
50474 }
50475 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50476 return resultobj;
50477 fail:
50478 return NULL;
50479 }
50480
50481
50482 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50483 int argc;
50484 PyObject *argv[3];
50485
50486 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50487 --argc;
50488 if (argc == 2) {
50489 int _v = 0;
50490 {
50491 void *vptr = 0;
50492 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50493 _v = SWIG_CheckState(res);
50494 }
50495 if (!_v) goto check_1;
50496 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50497 }
50498 check_1:
50499
50500 if (argc == 2) {
50501 int _v = 0;
50502 {
50503 void *vptr = 0;
50504 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50505 _v = SWIG_CheckState(res);
50506 }
50507 if (!_v) goto check_2;
50508 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50509 }
50510 check_2:
50511
50512 if (argc == 2) {
50513 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50514 }
50515
50516 fail:
50517 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50518 return NULL;
50519 }
50520
50521
50522 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50523 PyObject *resultobj = 0;
50524 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50525 wxWindow *arg2 = (wxWindow *) 0 ;
50526 wxGBSpan *arg3 = 0 ;
50527 bool result;
50528 void *argp1 = 0 ;
50529 int res1 = 0 ;
50530 void *argp2 = 0 ;
50531 int res2 = 0 ;
50532 wxGBSpan temp3 ;
50533
50534 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50536 if (!SWIG_IsOK(res1)) {
50537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50538 }
50539 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50540 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50541 if (!SWIG_IsOK(res2)) {
50542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50543 }
50544 arg2 = reinterpret_cast< wxWindow * >(argp2);
50545 {
50546 arg3 = &temp3;
50547 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50548 }
50549 {
50550 PyThreadState* __tstate = wxPyBeginAllowThreads();
50551 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50552 wxPyEndAllowThreads(__tstate);
50553 if (PyErr_Occurred()) SWIG_fail;
50554 }
50555 {
50556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50557 }
50558 return resultobj;
50559 fail:
50560 return NULL;
50561 }
50562
50563
50564 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50565 PyObject *resultobj = 0;
50566 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50567 wxSizer *arg2 = (wxSizer *) 0 ;
50568 wxGBSpan *arg3 = 0 ;
50569 bool result;
50570 void *argp1 = 0 ;
50571 int res1 = 0 ;
50572 void *argp2 = 0 ;
50573 int res2 = 0 ;
50574 wxGBSpan temp3 ;
50575
50576 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50578 if (!SWIG_IsOK(res1)) {
50579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50580 }
50581 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50582 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50583 if (!SWIG_IsOK(res2)) {
50584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50585 }
50586 arg2 = reinterpret_cast< wxSizer * >(argp2);
50587 {
50588 arg3 = &temp3;
50589 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50590 }
50591 {
50592 PyThreadState* __tstate = wxPyBeginAllowThreads();
50593 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50594 wxPyEndAllowThreads(__tstate);
50595 if (PyErr_Occurred()) SWIG_fail;
50596 }
50597 {
50598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50599 }
50600 return resultobj;
50601 fail:
50602 return NULL;
50603 }
50604
50605
50606 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50607 PyObject *resultobj = 0;
50608 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50609 size_t arg2 ;
50610 wxGBSpan *arg3 = 0 ;
50611 bool result;
50612 void *argp1 = 0 ;
50613 int res1 = 0 ;
50614 size_t val2 ;
50615 int ecode2 = 0 ;
50616 wxGBSpan temp3 ;
50617
50618 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50620 if (!SWIG_IsOK(res1)) {
50621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50622 }
50623 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50624 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50625 if (!SWIG_IsOK(ecode2)) {
50626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50627 }
50628 arg2 = static_cast< size_t >(val2);
50629 {
50630 arg3 = &temp3;
50631 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50632 }
50633 {
50634 PyThreadState* __tstate = wxPyBeginAllowThreads();
50635 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50636 wxPyEndAllowThreads(__tstate);
50637 if (PyErr_Occurred()) SWIG_fail;
50638 }
50639 {
50640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50641 }
50642 return resultobj;
50643 fail:
50644 return NULL;
50645 }
50646
50647
50648 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50649 int argc;
50650 PyObject *argv[4];
50651
50652 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50653 --argc;
50654 if (argc == 3) {
50655 int _v = 0;
50656 {
50657 void *vptr = 0;
50658 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50659 _v = SWIG_CheckState(res);
50660 }
50661 if (!_v) goto check_1;
50662 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50663 }
50664 check_1:
50665
50666 if (argc == 3) {
50667 int _v = 0;
50668 {
50669 void *vptr = 0;
50670 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50671 _v = SWIG_CheckState(res);
50672 }
50673 if (!_v) goto check_2;
50674 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50675 }
50676 check_2:
50677
50678 if (argc == 3) {
50679 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50680 }
50681
50682 fail:
50683 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50684 return NULL;
50685 }
50686
50687
50688 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50689 PyObject *resultobj = 0;
50690 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50691 wxWindow *arg2 = (wxWindow *) 0 ;
50692 wxGBSizerItem *result = 0 ;
50693 void *argp1 = 0 ;
50694 int res1 = 0 ;
50695 void *argp2 = 0 ;
50696 int res2 = 0 ;
50697
50698 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50700 if (!SWIG_IsOK(res1)) {
50701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50702 }
50703 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50704 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50705 if (!SWIG_IsOK(res2)) {
50706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50707 }
50708 arg2 = reinterpret_cast< wxWindow * >(argp2);
50709 {
50710 PyThreadState* __tstate = wxPyBeginAllowThreads();
50711 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50712 wxPyEndAllowThreads(__tstate);
50713 if (PyErr_Occurred()) SWIG_fail;
50714 }
50715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50716 return resultobj;
50717 fail:
50718 return NULL;
50719 }
50720
50721
50722 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50723 PyObject *resultobj = 0;
50724 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50725 wxSizer *arg2 = (wxSizer *) 0 ;
50726 wxGBSizerItem *result = 0 ;
50727 void *argp1 = 0 ;
50728 int res1 = 0 ;
50729 void *argp2 = 0 ;
50730 int res2 = 0 ;
50731
50732 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50734 if (!SWIG_IsOK(res1)) {
50735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50736 }
50737 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50738 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50739 if (!SWIG_IsOK(res2)) {
50740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50741 }
50742 arg2 = reinterpret_cast< wxSizer * >(argp2);
50743 {
50744 PyThreadState* __tstate = wxPyBeginAllowThreads();
50745 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50746 wxPyEndAllowThreads(__tstate);
50747 if (PyErr_Occurred()) SWIG_fail;
50748 }
50749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50750 return resultobj;
50751 fail:
50752 return NULL;
50753 }
50754
50755
50756 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50757 int argc;
50758 PyObject *argv[3];
50759
50760 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50761 --argc;
50762 if (argc == 2) {
50763 int _v = 0;
50764 {
50765 void *vptr = 0;
50766 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50767 _v = SWIG_CheckState(res);
50768 }
50769 if (!_v) goto check_1;
50770 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50771 }
50772 check_1:
50773
50774 if (argc == 2) {
50775 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50776 }
50777
50778 fail:
50779 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50780 return NULL;
50781 }
50782
50783
50784 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50785 PyObject *resultobj = 0;
50786 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50787 wxGBPosition *arg2 = 0 ;
50788 wxGBSizerItem *result = 0 ;
50789 void *argp1 = 0 ;
50790 int res1 = 0 ;
50791 wxGBPosition temp2 ;
50792 PyObject * obj0 = 0 ;
50793 PyObject * obj1 = 0 ;
50794 char * kwnames[] = {
50795 (char *) "self",(char *) "pos", NULL
50796 };
50797
50798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50800 if (!SWIG_IsOK(res1)) {
50801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50802 }
50803 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50804 {
50805 arg2 = &temp2;
50806 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50807 }
50808 {
50809 PyThreadState* __tstate = wxPyBeginAllowThreads();
50810 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50811 wxPyEndAllowThreads(__tstate);
50812 if (PyErr_Occurred()) SWIG_fail;
50813 }
50814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50815 return resultobj;
50816 fail:
50817 return NULL;
50818 }
50819
50820
50821 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50822 PyObject *resultobj = 0;
50823 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50824 wxPoint *arg2 = 0 ;
50825 wxGBSizerItem *result = 0 ;
50826 void *argp1 = 0 ;
50827 int res1 = 0 ;
50828 wxPoint temp2 ;
50829 PyObject * obj0 = 0 ;
50830 PyObject * obj1 = 0 ;
50831 char * kwnames[] = {
50832 (char *) "self",(char *) "pt", NULL
50833 };
50834
50835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50837 if (!SWIG_IsOK(res1)) {
50838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50839 }
50840 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50841 {
50842 arg2 = &temp2;
50843 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50844 }
50845 {
50846 PyThreadState* __tstate = wxPyBeginAllowThreads();
50847 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50848 wxPyEndAllowThreads(__tstate);
50849 if (PyErr_Occurred()) SWIG_fail;
50850 }
50851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50852 return resultobj;
50853 fail:
50854 return NULL;
50855 }
50856
50857
50858 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50859 PyObject *resultobj = 0;
50860 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50861 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50862 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50863 bool result;
50864 void *argp1 = 0 ;
50865 int res1 = 0 ;
50866 void *argp2 = 0 ;
50867 int res2 = 0 ;
50868 void *argp3 = 0 ;
50869 int res3 = 0 ;
50870 PyObject * obj0 = 0 ;
50871 PyObject * obj1 = 0 ;
50872 PyObject * obj2 = 0 ;
50873 char * kwnames[] = {
50874 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50875 };
50876
50877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50879 if (!SWIG_IsOK(res1)) {
50880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50881 }
50882 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50883 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50884 if (!SWIG_IsOK(res2)) {
50885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50886 }
50887 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50888 if (obj2) {
50889 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50890 if (!SWIG_IsOK(res3)) {
50891 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50892 }
50893 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50894 }
50895 {
50896 PyThreadState* __tstate = wxPyBeginAllowThreads();
50897 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50898 wxPyEndAllowThreads(__tstate);
50899 if (PyErr_Occurred()) SWIG_fail;
50900 }
50901 {
50902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50903 }
50904 return resultobj;
50905 fail:
50906 return NULL;
50907 }
50908
50909
50910 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50911 PyObject *resultobj = 0;
50912 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50913 wxGBPosition *arg2 = 0 ;
50914 wxGBSpan *arg3 = 0 ;
50915 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50916 bool result;
50917 void *argp1 = 0 ;
50918 int res1 = 0 ;
50919 wxGBPosition temp2 ;
50920 wxGBSpan temp3 ;
50921 void *argp4 = 0 ;
50922 int res4 = 0 ;
50923 PyObject * obj0 = 0 ;
50924 PyObject * obj1 = 0 ;
50925 PyObject * obj2 = 0 ;
50926 PyObject * obj3 = 0 ;
50927 char * kwnames[] = {
50928 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50929 };
50930
50931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50933 if (!SWIG_IsOK(res1)) {
50934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50935 }
50936 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50937 {
50938 arg2 = &temp2;
50939 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50940 }
50941 {
50942 arg3 = &temp3;
50943 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50944 }
50945 if (obj3) {
50946 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50947 if (!SWIG_IsOK(res4)) {
50948 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50949 }
50950 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50951 }
50952 {
50953 PyThreadState* __tstate = wxPyBeginAllowThreads();
50954 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50955 wxPyEndAllowThreads(__tstate);
50956 if (PyErr_Occurred()) SWIG_fail;
50957 }
50958 {
50959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50960 }
50961 return resultobj;
50962 fail:
50963 return NULL;
50964 }
50965
50966
50967 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50968 PyObject *obj;
50969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50970 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
50971 return SWIG_Py_Void();
50972 }
50973
50974 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50975 return SWIG_Python_InitShadowInstance(args);
50976 }
50977
50978 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50979 PyObject *resultobj = 0;
50980 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50981 wxRelationship arg2 ;
50982 wxWindow *arg3 = (wxWindow *) 0 ;
50983 wxEdge arg4 ;
50984 int arg5 = (int) 0 ;
50985 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
50986 void *argp1 = 0 ;
50987 int res1 = 0 ;
50988 int val2 ;
50989 int ecode2 = 0 ;
50990 void *argp3 = 0 ;
50991 int res3 = 0 ;
50992 int val4 ;
50993 int ecode4 = 0 ;
50994 int val5 ;
50995 int ecode5 = 0 ;
50996 int val6 ;
50997 int ecode6 = 0 ;
50998 PyObject * obj0 = 0 ;
50999 PyObject * obj1 = 0 ;
51000 PyObject * obj2 = 0 ;
51001 PyObject * obj3 = 0 ;
51002 PyObject * obj4 = 0 ;
51003 PyObject * obj5 = 0 ;
51004 char * kwnames[] = {
51005 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51006 };
51007
51008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51010 if (!SWIG_IsOK(res1)) {
51011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51012 }
51013 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51014 ecode2 = SWIG_AsVal_int(obj1, &val2);
51015 if (!SWIG_IsOK(ecode2)) {
51016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51017 }
51018 arg2 = static_cast< wxRelationship >(val2);
51019 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51020 if (!SWIG_IsOK(res3)) {
51021 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51022 }
51023 arg3 = reinterpret_cast< wxWindow * >(argp3);
51024 ecode4 = SWIG_AsVal_int(obj3, &val4);
51025 if (!SWIG_IsOK(ecode4)) {
51026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51027 }
51028 arg4 = static_cast< wxEdge >(val4);
51029 if (obj4) {
51030 ecode5 = SWIG_AsVal_int(obj4, &val5);
51031 if (!SWIG_IsOK(ecode5)) {
51032 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51033 }
51034 arg5 = static_cast< int >(val5);
51035 }
51036 if (obj5) {
51037 ecode6 = SWIG_AsVal_int(obj5, &val6);
51038 if (!SWIG_IsOK(ecode6)) {
51039 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51040 }
51041 arg6 = static_cast< int >(val6);
51042 }
51043 {
51044 PyThreadState* __tstate = wxPyBeginAllowThreads();
51045 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51046 wxPyEndAllowThreads(__tstate);
51047 if (PyErr_Occurred()) SWIG_fail;
51048 }
51049 resultobj = SWIG_Py_Void();
51050 return resultobj;
51051 fail:
51052 return NULL;
51053 }
51054
51055
51056 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51057 PyObject *resultobj = 0;
51058 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51059 wxWindow *arg2 = (wxWindow *) 0 ;
51060 int arg3 = (int) 0 ;
51061 void *argp1 = 0 ;
51062 int res1 = 0 ;
51063 void *argp2 = 0 ;
51064 int res2 = 0 ;
51065 int val3 ;
51066 int ecode3 = 0 ;
51067 PyObject * obj0 = 0 ;
51068 PyObject * obj1 = 0 ;
51069 PyObject * obj2 = 0 ;
51070 char * kwnames[] = {
51071 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51072 };
51073
51074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51076 if (!SWIG_IsOK(res1)) {
51077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51078 }
51079 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51080 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51081 if (!SWIG_IsOK(res2)) {
51082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51083 }
51084 arg2 = reinterpret_cast< wxWindow * >(argp2);
51085 if (obj2) {
51086 ecode3 = SWIG_AsVal_int(obj2, &val3);
51087 if (!SWIG_IsOK(ecode3)) {
51088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51089 }
51090 arg3 = static_cast< int >(val3);
51091 }
51092 {
51093 PyThreadState* __tstate = wxPyBeginAllowThreads();
51094 (arg1)->LeftOf(arg2,arg3);
51095 wxPyEndAllowThreads(__tstate);
51096 if (PyErr_Occurred()) SWIG_fail;
51097 }
51098 resultobj = SWIG_Py_Void();
51099 return resultobj;
51100 fail:
51101 return NULL;
51102 }
51103
51104
51105 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51106 PyObject *resultobj = 0;
51107 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51108 wxWindow *arg2 = (wxWindow *) 0 ;
51109 int arg3 = (int) 0 ;
51110 void *argp1 = 0 ;
51111 int res1 = 0 ;
51112 void *argp2 = 0 ;
51113 int res2 = 0 ;
51114 int val3 ;
51115 int ecode3 = 0 ;
51116 PyObject * obj0 = 0 ;
51117 PyObject * obj1 = 0 ;
51118 PyObject * obj2 = 0 ;
51119 char * kwnames[] = {
51120 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51121 };
51122
51123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51125 if (!SWIG_IsOK(res1)) {
51126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51127 }
51128 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51130 if (!SWIG_IsOK(res2)) {
51131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51132 }
51133 arg2 = reinterpret_cast< wxWindow * >(argp2);
51134 if (obj2) {
51135 ecode3 = SWIG_AsVal_int(obj2, &val3);
51136 if (!SWIG_IsOK(ecode3)) {
51137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51138 }
51139 arg3 = static_cast< int >(val3);
51140 }
51141 {
51142 PyThreadState* __tstate = wxPyBeginAllowThreads();
51143 (arg1)->RightOf(arg2,arg3);
51144 wxPyEndAllowThreads(__tstate);
51145 if (PyErr_Occurred()) SWIG_fail;
51146 }
51147 resultobj = SWIG_Py_Void();
51148 return resultobj;
51149 fail:
51150 return NULL;
51151 }
51152
51153
51154 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51155 PyObject *resultobj = 0;
51156 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51157 wxWindow *arg2 = (wxWindow *) 0 ;
51158 int arg3 = (int) 0 ;
51159 void *argp1 = 0 ;
51160 int res1 = 0 ;
51161 void *argp2 = 0 ;
51162 int res2 = 0 ;
51163 int val3 ;
51164 int ecode3 = 0 ;
51165 PyObject * obj0 = 0 ;
51166 PyObject * obj1 = 0 ;
51167 PyObject * obj2 = 0 ;
51168 char * kwnames[] = {
51169 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51170 };
51171
51172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51174 if (!SWIG_IsOK(res1)) {
51175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51176 }
51177 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51179 if (!SWIG_IsOK(res2)) {
51180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51181 }
51182 arg2 = reinterpret_cast< wxWindow * >(argp2);
51183 if (obj2) {
51184 ecode3 = SWIG_AsVal_int(obj2, &val3);
51185 if (!SWIG_IsOK(ecode3)) {
51186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51187 }
51188 arg3 = static_cast< int >(val3);
51189 }
51190 {
51191 PyThreadState* __tstate = wxPyBeginAllowThreads();
51192 (arg1)->Above(arg2,arg3);
51193 wxPyEndAllowThreads(__tstate);
51194 if (PyErr_Occurred()) SWIG_fail;
51195 }
51196 resultobj = SWIG_Py_Void();
51197 return resultobj;
51198 fail:
51199 return NULL;
51200 }
51201
51202
51203 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51204 PyObject *resultobj = 0;
51205 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51206 wxWindow *arg2 = (wxWindow *) 0 ;
51207 int arg3 = (int) 0 ;
51208 void *argp1 = 0 ;
51209 int res1 = 0 ;
51210 void *argp2 = 0 ;
51211 int res2 = 0 ;
51212 int val3 ;
51213 int ecode3 = 0 ;
51214 PyObject * obj0 = 0 ;
51215 PyObject * obj1 = 0 ;
51216 PyObject * obj2 = 0 ;
51217 char * kwnames[] = {
51218 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51219 };
51220
51221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51223 if (!SWIG_IsOK(res1)) {
51224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51225 }
51226 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51227 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51228 if (!SWIG_IsOK(res2)) {
51229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51230 }
51231 arg2 = reinterpret_cast< wxWindow * >(argp2);
51232 if (obj2) {
51233 ecode3 = SWIG_AsVal_int(obj2, &val3);
51234 if (!SWIG_IsOK(ecode3)) {
51235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51236 }
51237 arg3 = static_cast< int >(val3);
51238 }
51239 {
51240 PyThreadState* __tstate = wxPyBeginAllowThreads();
51241 (arg1)->Below(arg2,arg3);
51242 wxPyEndAllowThreads(__tstate);
51243 if (PyErr_Occurred()) SWIG_fail;
51244 }
51245 resultobj = SWIG_Py_Void();
51246 return resultobj;
51247 fail:
51248 return NULL;
51249 }
51250
51251
51252 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51253 PyObject *resultobj = 0;
51254 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51255 wxWindow *arg2 = (wxWindow *) 0 ;
51256 wxEdge arg3 ;
51257 int arg4 = (int) 0 ;
51258 void *argp1 = 0 ;
51259 int res1 = 0 ;
51260 void *argp2 = 0 ;
51261 int res2 = 0 ;
51262 int val3 ;
51263 int ecode3 = 0 ;
51264 int val4 ;
51265 int ecode4 = 0 ;
51266 PyObject * obj0 = 0 ;
51267 PyObject * obj1 = 0 ;
51268 PyObject * obj2 = 0 ;
51269 PyObject * obj3 = 0 ;
51270 char * kwnames[] = {
51271 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51272 };
51273
51274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51276 if (!SWIG_IsOK(res1)) {
51277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51278 }
51279 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51281 if (!SWIG_IsOK(res2)) {
51282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51283 }
51284 arg2 = reinterpret_cast< wxWindow * >(argp2);
51285 ecode3 = SWIG_AsVal_int(obj2, &val3);
51286 if (!SWIG_IsOK(ecode3)) {
51287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51288 }
51289 arg3 = static_cast< wxEdge >(val3);
51290 if (obj3) {
51291 ecode4 = SWIG_AsVal_int(obj3, &val4);
51292 if (!SWIG_IsOK(ecode4)) {
51293 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51294 }
51295 arg4 = static_cast< int >(val4);
51296 }
51297 {
51298 PyThreadState* __tstate = wxPyBeginAllowThreads();
51299 (arg1)->SameAs(arg2,arg3,arg4);
51300 wxPyEndAllowThreads(__tstate);
51301 if (PyErr_Occurred()) SWIG_fail;
51302 }
51303 resultobj = SWIG_Py_Void();
51304 return resultobj;
51305 fail:
51306 return NULL;
51307 }
51308
51309
51310 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51311 PyObject *resultobj = 0;
51312 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51313 wxWindow *arg2 = (wxWindow *) 0 ;
51314 wxEdge arg3 ;
51315 int arg4 ;
51316 void *argp1 = 0 ;
51317 int res1 = 0 ;
51318 void *argp2 = 0 ;
51319 int res2 = 0 ;
51320 int val3 ;
51321 int ecode3 = 0 ;
51322 int val4 ;
51323 int ecode4 = 0 ;
51324 PyObject * obj0 = 0 ;
51325 PyObject * obj1 = 0 ;
51326 PyObject * obj2 = 0 ;
51327 PyObject * obj3 = 0 ;
51328 char * kwnames[] = {
51329 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51330 };
51331
51332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51334 if (!SWIG_IsOK(res1)) {
51335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51336 }
51337 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51339 if (!SWIG_IsOK(res2)) {
51340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51341 }
51342 arg2 = reinterpret_cast< wxWindow * >(argp2);
51343 ecode3 = SWIG_AsVal_int(obj2, &val3);
51344 if (!SWIG_IsOK(ecode3)) {
51345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51346 }
51347 arg3 = static_cast< wxEdge >(val3);
51348 ecode4 = SWIG_AsVal_int(obj3, &val4);
51349 if (!SWIG_IsOK(ecode4)) {
51350 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51351 }
51352 arg4 = static_cast< int >(val4);
51353 {
51354 PyThreadState* __tstate = wxPyBeginAllowThreads();
51355 (arg1)->PercentOf(arg2,arg3,arg4);
51356 wxPyEndAllowThreads(__tstate);
51357 if (PyErr_Occurred()) SWIG_fail;
51358 }
51359 resultobj = SWIG_Py_Void();
51360 return resultobj;
51361 fail:
51362 return NULL;
51363 }
51364
51365
51366 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51367 PyObject *resultobj = 0;
51368 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51369 int arg2 ;
51370 void *argp1 = 0 ;
51371 int res1 = 0 ;
51372 int val2 ;
51373 int ecode2 = 0 ;
51374 PyObject * obj0 = 0 ;
51375 PyObject * obj1 = 0 ;
51376 char * kwnames[] = {
51377 (char *) "self",(char *) "val", NULL
51378 };
51379
51380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51382 if (!SWIG_IsOK(res1)) {
51383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51384 }
51385 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51386 ecode2 = SWIG_AsVal_int(obj1, &val2);
51387 if (!SWIG_IsOK(ecode2)) {
51388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51389 }
51390 arg2 = static_cast< int >(val2);
51391 {
51392 PyThreadState* __tstate = wxPyBeginAllowThreads();
51393 (arg1)->Absolute(arg2);
51394 wxPyEndAllowThreads(__tstate);
51395 if (PyErr_Occurred()) SWIG_fail;
51396 }
51397 resultobj = SWIG_Py_Void();
51398 return resultobj;
51399 fail:
51400 return NULL;
51401 }
51402
51403
51404 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51405 PyObject *resultobj = 0;
51406 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51407 void *argp1 = 0 ;
51408 int res1 = 0 ;
51409 PyObject *swig_obj[1] ;
51410
51411 if (!args) SWIG_fail;
51412 swig_obj[0] = args;
51413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51414 if (!SWIG_IsOK(res1)) {
51415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51416 }
51417 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51418 {
51419 PyThreadState* __tstate = wxPyBeginAllowThreads();
51420 (arg1)->Unconstrained();
51421 wxPyEndAllowThreads(__tstate);
51422 if (PyErr_Occurred()) SWIG_fail;
51423 }
51424 resultobj = SWIG_Py_Void();
51425 return resultobj;
51426 fail:
51427 return NULL;
51428 }
51429
51430
51431 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51432 PyObject *resultobj = 0;
51433 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51434 void *argp1 = 0 ;
51435 int res1 = 0 ;
51436 PyObject *swig_obj[1] ;
51437
51438 if (!args) SWIG_fail;
51439 swig_obj[0] = args;
51440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51441 if (!SWIG_IsOK(res1)) {
51442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51443 }
51444 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51445 {
51446 PyThreadState* __tstate = wxPyBeginAllowThreads();
51447 (arg1)->AsIs();
51448 wxPyEndAllowThreads(__tstate);
51449 if (PyErr_Occurred()) SWIG_fail;
51450 }
51451 resultobj = SWIG_Py_Void();
51452 return resultobj;
51453 fail:
51454 return NULL;
51455 }
51456
51457
51458 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51459 PyObject *resultobj = 0;
51460 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51461 wxWindow *result = 0 ;
51462 void *argp1 = 0 ;
51463 int res1 = 0 ;
51464 PyObject *swig_obj[1] ;
51465
51466 if (!args) SWIG_fail;
51467 swig_obj[0] = args;
51468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51469 if (!SWIG_IsOK(res1)) {
51470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51471 }
51472 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51473 {
51474 PyThreadState* __tstate = wxPyBeginAllowThreads();
51475 result = (wxWindow *)(arg1)->GetOtherWindow();
51476 wxPyEndAllowThreads(__tstate);
51477 if (PyErr_Occurred()) SWIG_fail;
51478 }
51479 {
51480 resultobj = wxPyMake_wxObject(result, 0);
51481 }
51482 return resultobj;
51483 fail:
51484 return NULL;
51485 }
51486
51487
51488 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51489 PyObject *resultobj = 0;
51490 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51491 wxEdge result;
51492 void *argp1 = 0 ;
51493 int res1 = 0 ;
51494 PyObject *swig_obj[1] ;
51495
51496 if (!args) SWIG_fail;
51497 swig_obj[0] = args;
51498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51499 if (!SWIG_IsOK(res1)) {
51500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51501 }
51502 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51503 {
51504 PyThreadState* __tstate = wxPyBeginAllowThreads();
51505 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51506 wxPyEndAllowThreads(__tstate);
51507 if (PyErr_Occurred()) SWIG_fail;
51508 }
51509 resultobj = SWIG_From_int(static_cast< int >(result));
51510 return resultobj;
51511 fail:
51512 return NULL;
51513 }
51514
51515
51516 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51517 PyObject *resultobj = 0;
51518 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51519 wxEdge arg2 ;
51520 void *argp1 = 0 ;
51521 int res1 = 0 ;
51522 int val2 ;
51523 int ecode2 = 0 ;
51524 PyObject * obj0 = 0 ;
51525 PyObject * obj1 = 0 ;
51526 char * kwnames[] = {
51527 (char *) "self",(char *) "which", NULL
51528 };
51529
51530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51532 if (!SWIG_IsOK(res1)) {
51533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51534 }
51535 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51536 ecode2 = SWIG_AsVal_int(obj1, &val2);
51537 if (!SWIG_IsOK(ecode2)) {
51538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51539 }
51540 arg2 = static_cast< wxEdge >(val2);
51541 {
51542 PyThreadState* __tstate = wxPyBeginAllowThreads();
51543 (arg1)->SetEdge(arg2);
51544 wxPyEndAllowThreads(__tstate);
51545 if (PyErr_Occurred()) SWIG_fail;
51546 }
51547 resultobj = SWIG_Py_Void();
51548 return resultobj;
51549 fail:
51550 return NULL;
51551 }
51552
51553
51554 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51555 PyObject *resultobj = 0;
51556 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51557 int arg2 ;
51558 void *argp1 = 0 ;
51559 int res1 = 0 ;
51560 int val2 ;
51561 int ecode2 = 0 ;
51562 PyObject * obj0 = 0 ;
51563 PyObject * obj1 = 0 ;
51564 char * kwnames[] = {
51565 (char *) "self",(char *) "v", NULL
51566 };
51567
51568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51570 if (!SWIG_IsOK(res1)) {
51571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51572 }
51573 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51574 ecode2 = SWIG_AsVal_int(obj1, &val2);
51575 if (!SWIG_IsOK(ecode2)) {
51576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51577 }
51578 arg2 = static_cast< int >(val2);
51579 {
51580 PyThreadState* __tstate = wxPyBeginAllowThreads();
51581 (arg1)->SetValue(arg2);
51582 wxPyEndAllowThreads(__tstate);
51583 if (PyErr_Occurred()) SWIG_fail;
51584 }
51585 resultobj = SWIG_Py_Void();
51586 return resultobj;
51587 fail:
51588 return NULL;
51589 }
51590
51591
51592 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51593 PyObject *resultobj = 0;
51594 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51595 int result;
51596 void *argp1 = 0 ;
51597 int res1 = 0 ;
51598 PyObject *swig_obj[1] ;
51599
51600 if (!args) SWIG_fail;
51601 swig_obj[0] = args;
51602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51603 if (!SWIG_IsOK(res1)) {
51604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51605 }
51606 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51607 {
51608 PyThreadState* __tstate = wxPyBeginAllowThreads();
51609 result = (int)(arg1)->GetMargin();
51610 wxPyEndAllowThreads(__tstate);
51611 if (PyErr_Occurred()) SWIG_fail;
51612 }
51613 resultobj = SWIG_From_int(static_cast< int >(result));
51614 return resultobj;
51615 fail:
51616 return NULL;
51617 }
51618
51619
51620 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51621 PyObject *resultobj = 0;
51622 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51623 int arg2 ;
51624 void *argp1 = 0 ;
51625 int res1 = 0 ;
51626 int val2 ;
51627 int ecode2 = 0 ;
51628 PyObject * obj0 = 0 ;
51629 PyObject * obj1 = 0 ;
51630 char * kwnames[] = {
51631 (char *) "self",(char *) "m", NULL
51632 };
51633
51634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51636 if (!SWIG_IsOK(res1)) {
51637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51638 }
51639 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51640 ecode2 = SWIG_AsVal_int(obj1, &val2);
51641 if (!SWIG_IsOK(ecode2)) {
51642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51643 }
51644 arg2 = static_cast< int >(val2);
51645 {
51646 PyThreadState* __tstate = wxPyBeginAllowThreads();
51647 (arg1)->SetMargin(arg2);
51648 wxPyEndAllowThreads(__tstate);
51649 if (PyErr_Occurred()) SWIG_fail;
51650 }
51651 resultobj = SWIG_Py_Void();
51652 return resultobj;
51653 fail:
51654 return NULL;
51655 }
51656
51657
51658 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51659 PyObject *resultobj = 0;
51660 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51661 int result;
51662 void *argp1 = 0 ;
51663 int res1 = 0 ;
51664 PyObject *swig_obj[1] ;
51665
51666 if (!args) SWIG_fail;
51667 swig_obj[0] = args;
51668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51669 if (!SWIG_IsOK(res1)) {
51670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51671 }
51672 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51673 {
51674 PyThreadState* __tstate = wxPyBeginAllowThreads();
51675 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51676 wxPyEndAllowThreads(__tstate);
51677 if (PyErr_Occurred()) SWIG_fail;
51678 }
51679 resultobj = SWIG_From_int(static_cast< int >(result));
51680 return resultobj;
51681 fail:
51682 return NULL;
51683 }
51684
51685
51686 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51687 PyObject *resultobj = 0;
51688 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51689 int result;
51690 void *argp1 = 0 ;
51691 int res1 = 0 ;
51692 PyObject *swig_obj[1] ;
51693
51694 if (!args) SWIG_fail;
51695 swig_obj[0] = args;
51696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51697 if (!SWIG_IsOK(res1)) {
51698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51699 }
51700 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51701 {
51702 PyThreadState* __tstate = wxPyBeginAllowThreads();
51703 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51704 wxPyEndAllowThreads(__tstate);
51705 if (PyErr_Occurred()) SWIG_fail;
51706 }
51707 resultobj = SWIG_From_int(static_cast< int >(result));
51708 return resultobj;
51709 fail:
51710 return NULL;
51711 }
51712
51713
51714 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51715 PyObject *resultobj = 0;
51716 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51717 int result;
51718 void *argp1 = 0 ;
51719 int res1 = 0 ;
51720 PyObject *swig_obj[1] ;
51721
51722 if (!args) SWIG_fail;
51723 swig_obj[0] = args;
51724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51725 if (!SWIG_IsOK(res1)) {
51726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51727 }
51728 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51729 {
51730 PyThreadState* __tstate = wxPyBeginAllowThreads();
51731 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51732 wxPyEndAllowThreads(__tstate);
51733 if (PyErr_Occurred()) SWIG_fail;
51734 }
51735 resultobj = SWIG_From_int(static_cast< int >(result));
51736 return resultobj;
51737 fail:
51738 return NULL;
51739 }
51740
51741
51742 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51743 PyObject *resultobj = 0;
51744 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51745 bool result;
51746 void *argp1 = 0 ;
51747 int res1 = 0 ;
51748 PyObject *swig_obj[1] ;
51749
51750 if (!args) SWIG_fail;
51751 swig_obj[0] = args;
51752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51753 if (!SWIG_IsOK(res1)) {
51754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51755 }
51756 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51757 {
51758 PyThreadState* __tstate = wxPyBeginAllowThreads();
51759 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51760 wxPyEndAllowThreads(__tstate);
51761 if (PyErr_Occurred()) SWIG_fail;
51762 }
51763 {
51764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51765 }
51766 return resultobj;
51767 fail:
51768 return NULL;
51769 }
51770
51771
51772 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51773 PyObject *resultobj = 0;
51774 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51775 bool arg2 ;
51776 void *argp1 = 0 ;
51777 int res1 = 0 ;
51778 bool val2 ;
51779 int ecode2 = 0 ;
51780 PyObject * obj0 = 0 ;
51781 PyObject * obj1 = 0 ;
51782 char * kwnames[] = {
51783 (char *) "self",(char *) "d", NULL
51784 };
51785
51786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51788 if (!SWIG_IsOK(res1)) {
51789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51790 }
51791 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51792 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51793 if (!SWIG_IsOK(ecode2)) {
51794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51795 }
51796 arg2 = static_cast< bool >(val2);
51797 {
51798 PyThreadState* __tstate = wxPyBeginAllowThreads();
51799 (arg1)->SetDone(arg2);
51800 wxPyEndAllowThreads(__tstate);
51801 if (PyErr_Occurred()) SWIG_fail;
51802 }
51803 resultobj = SWIG_Py_Void();
51804 return resultobj;
51805 fail:
51806 return NULL;
51807 }
51808
51809
51810 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51811 PyObject *resultobj = 0;
51812 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51813 wxRelationship result;
51814 void *argp1 = 0 ;
51815 int res1 = 0 ;
51816 PyObject *swig_obj[1] ;
51817
51818 if (!args) SWIG_fail;
51819 swig_obj[0] = args;
51820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51821 if (!SWIG_IsOK(res1)) {
51822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51823 }
51824 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51825 {
51826 PyThreadState* __tstate = wxPyBeginAllowThreads();
51827 result = (wxRelationship)(arg1)->GetRelationship();
51828 wxPyEndAllowThreads(__tstate);
51829 if (PyErr_Occurred()) SWIG_fail;
51830 }
51831 resultobj = SWIG_From_int(static_cast< int >(result));
51832 return resultobj;
51833 fail:
51834 return NULL;
51835 }
51836
51837
51838 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51839 PyObject *resultobj = 0;
51840 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51841 wxRelationship arg2 ;
51842 void *argp1 = 0 ;
51843 int res1 = 0 ;
51844 int val2 ;
51845 int ecode2 = 0 ;
51846 PyObject * obj0 = 0 ;
51847 PyObject * obj1 = 0 ;
51848 char * kwnames[] = {
51849 (char *) "self",(char *) "r", NULL
51850 };
51851
51852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51854 if (!SWIG_IsOK(res1)) {
51855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51856 }
51857 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51858 ecode2 = SWIG_AsVal_int(obj1, &val2);
51859 if (!SWIG_IsOK(ecode2)) {
51860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51861 }
51862 arg2 = static_cast< wxRelationship >(val2);
51863 {
51864 PyThreadState* __tstate = wxPyBeginAllowThreads();
51865 (arg1)->SetRelationship(arg2);
51866 wxPyEndAllowThreads(__tstate);
51867 if (PyErr_Occurred()) SWIG_fail;
51868 }
51869 resultobj = SWIG_Py_Void();
51870 return resultobj;
51871 fail:
51872 return NULL;
51873 }
51874
51875
51876 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51877 PyObject *resultobj = 0;
51878 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51879 wxWindow *arg2 = (wxWindow *) 0 ;
51880 bool result;
51881 void *argp1 = 0 ;
51882 int res1 = 0 ;
51883 void *argp2 = 0 ;
51884 int res2 = 0 ;
51885 PyObject * obj0 = 0 ;
51886 PyObject * obj1 = 0 ;
51887 char * kwnames[] = {
51888 (char *) "self",(char *) "otherW", NULL
51889 };
51890
51891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51893 if (!SWIG_IsOK(res1)) {
51894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51895 }
51896 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51897 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51898 if (!SWIG_IsOK(res2)) {
51899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51900 }
51901 arg2 = reinterpret_cast< wxWindow * >(argp2);
51902 {
51903 PyThreadState* __tstate = wxPyBeginAllowThreads();
51904 result = (bool)(arg1)->ResetIfWin(arg2);
51905 wxPyEndAllowThreads(__tstate);
51906 if (PyErr_Occurred()) SWIG_fail;
51907 }
51908 {
51909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51910 }
51911 return resultobj;
51912 fail:
51913 return NULL;
51914 }
51915
51916
51917 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51918 PyObject *resultobj = 0;
51919 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51920 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51921 wxWindow *arg3 = (wxWindow *) 0 ;
51922 bool result;
51923 void *argp1 = 0 ;
51924 int res1 = 0 ;
51925 void *argp2 = 0 ;
51926 int res2 = 0 ;
51927 void *argp3 = 0 ;
51928 int res3 = 0 ;
51929 PyObject * obj0 = 0 ;
51930 PyObject * obj1 = 0 ;
51931 PyObject * obj2 = 0 ;
51932 char * kwnames[] = {
51933 (char *) "self",(char *) "constraints",(char *) "win", NULL
51934 };
51935
51936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51938 if (!SWIG_IsOK(res1)) {
51939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51940 }
51941 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51942 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51943 if (!SWIG_IsOK(res2)) {
51944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51945 }
51946 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51947 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51948 if (!SWIG_IsOK(res3)) {
51949 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51950 }
51951 arg3 = reinterpret_cast< wxWindow * >(argp3);
51952 {
51953 PyThreadState* __tstate = wxPyBeginAllowThreads();
51954 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51955 wxPyEndAllowThreads(__tstate);
51956 if (PyErr_Occurred()) SWIG_fail;
51957 }
51958 {
51959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51960 }
51961 return resultobj;
51962 fail:
51963 return NULL;
51964 }
51965
51966
51967 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51968 PyObject *resultobj = 0;
51969 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51970 wxEdge arg2 ;
51971 wxWindow *arg3 = (wxWindow *) 0 ;
51972 wxWindow *arg4 = (wxWindow *) 0 ;
51973 int result;
51974 void *argp1 = 0 ;
51975 int res1 = 0 ;
51976 int val2 ;
51977 int ecode2 = 0 ;
51978 void *argp3 = 0 ;
51979 int res3 = 0 ;
51980 void *argp4 = 0 ;
51981 int res4 = 0 ;
51982 PyObject * obj0 = 0 ;
51983 PyObject * obj1 = 0 ;
51984 PyObject * obj2 = 0 ;
51985 PyObject * obj3 = 0 ;
51986 char * kwnames[] = {
51987 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
51988 };
51989
51990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51992 if (!SWIG_IsOK(res1)) {
51993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51994 }
51995 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51996 ecode2 = SWIG_AsVal_int(obj1, &val2);
51997 if (!SWIG_IsOK(ecode2)) {
51998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51999 }
52000 arg2 = static_cast< wxEdge >(val2);
52001 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52002 if (!SWIG_IsOK(res3)) {
52003 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52004 }
52005 arg3 = reinterpret_cast< wxWindow * >(argp3);
52006 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52007 if (!SWIG_IsOK(res4)) {
52008 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52009 }
52010 arg4 = reinterpret_cast< wxWindow * >(argp4);
52011 {
52012 PyThreadState* __tstate = wxPyBeginAllowThreads();
52013 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52014 wxPyEndAllowThreads(__tstate);
52015 if (PyErr_Occurred()) SWIG_fail;
52016 }
52017 resultobj = SWIG_From_int(static_cast< int >(result));
52018 return resultobj;
52019 fail:
52020 return NULL;
52021 }
52022
52023
52024 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52025 PyObject *obj;
52026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52027 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52028 return SWIG_Py_Void();
52029 }
52030
52031 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52032 PyObject *resultobj = 0;
52033 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52034 wxIndividualLayoutConstraint *result = 0 ;
52035 void *argp1 = 0 ;
52036 int res1 = 0 ;
52037 PyObject *swig_obj[1] ;
52038
52039 if (!args) SWIG_fail;
52040 swig_obj[0] = args;
52041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52042 if (!SWIG_IsOK(res1)) {
52043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52044 }
52045 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52046 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52048 return resultobj;
52049 fail:
52050 return NULL;
52051 }
52052
52053
52054 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52055 PyObject *resultobj = 0;
52056 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52057 wxIndividualLayoutConstraint *result = 0 ;
52058 void *argp1 = 0 ;
52059 int res1 = 0 ;
52060 PyObject *swig_obj[1] ;
52061
52062 if (!args) SWIG_fail;
52063 swig_obj[0] = args;
52064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52065 if (!SWIG_IsOK(res1)) {
52066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52067 }
52068 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52069 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52071 return resultobj;
52072 fail:
52073 return NULL;
52074 }
52075
52076
52077 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52078 PyObject *resultobj = 0;
52079 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52080 wxIndividualLayoutConstraint *result = 0 ;
52081 void *argp1 = 0 ;
52082 int res1 = 0 ;
52083 PyObject *swig_obj[1] ;
52084
52085 if (!args) SWIG_fail;
52086 swig_obj[0] = args;
52087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52088 if (!SWIG_IsOK(res1)) {
52089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52090 }
52091 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52092 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52094 return resultobj;
52095 fail:
52096 return NULL;
52097 }
52098
52099
52100 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52101 PyObject *resultobj = 0;
52102 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52103 wxIndividualLayoutConstraint *result = 0 ;
52104 void *argp1 = 0 ;
52105 int res1 = 0 ;
52106 PyObject *swig_obj[1] ;
52107
52108 if (!args) SWIG_fail;
52109 swig_obj[0] = args;
52110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52111 if (!SWIG_IsOK(res1)) {
52112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52113 }
52114 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52115 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52117 return resultobj;
52118 fail:
52119 return NULL;
52120 }
52121
52122
52123 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52124 PyObject *resultobj = 0;
52125 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52126 wxIndividualLayoutConstraint *result = 0 ;
52127 void *argp1 = 0 ;
52128 int res1 = 0 ;
52129 PyObject *swig_obj[1] ;
52130
52131 if (!args) SWIG_fail;
52132 swig_obj[0] = args;
52133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52134 if (!SWIG_IsOK(res1)) {
52135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52136 }
52137 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52138 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52140 return resultobj;
52141 fail:
52142 return NULL;
52143 }
52144
52145
52146 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52147 PyObject *resultobj = 0;
52148 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52149 wxIndividualLayoutConstraint *result = 0 ;
52150 void *argp1 = 0 ;
52151 int res1 = 0 ;
52152 PyObject *swig_obj[1] ;
52153
52154 if (!args) SWIG_fail;
52155 swig_obj[0] = args;
52156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52157 if (!SWIG_IsOK(res1)) {
52158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52159 }
52160 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52161 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52163 return resultobj;
52164 fail:
52165 return NULL;
52166 }
52167
52168
52169 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52170 PyObject *resultobj = 0;
52171 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52172 wxIndividualLayoutConstraint *result = 0 ;
52173 void *argp1 = 0 ;
52174 int res1 = 0 ;
52175 PyObject *swig_obj[1] ;
52176
52177 if (!args) SWIG_fail;
52178 swig_obj[0] = args;
52179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52180 if (!SWIG_IsOK(res1)) {
52181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52182 }
52183 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52184 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52186 return resultobj;
52187 fail:
52188 return NULL;
52189 }
52190
52191
52192 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52193 PyObject *resultobj = 0;
52194 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52195 wxIndividualLayoutConstraint *result = 0 ;
52196 void *argp1 = 0 ;
52197 int res1 = 0 ;
52198 PyObject *swig_obj[1] ;
52199
52200 if (!args) SWIG_fail;
52201 swig_obj[0] = args;
52202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52203 if (!SWIG_IsOK(res1)) {
52204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52205 }
52206 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52207 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52209 return resultobj;
52210 fail:
52211 return NULL;
52212 }
52213
52214
52215 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52216 PyObject *resultobj = 0;
52217 wxLayoutConstraints *result = 0 ;
52218
52219 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52220 {
52221 PyThreadState* __tstate = wxPyBeginAllowThreads();
52222 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52223 wxPyEndAllowThreads(__tstate);
52224 if (PyErr_Occurred()) SWIG_fail;
52225 }
52226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52227 return resultobj;
52228 fail:
52229 return NULL;
52230 }
52231
52232
52233 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52234 PyObject *resultobj = 0;
52235 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52236 void *argp1 = 0 ;
52237 int res1 = 0 ;
52238 PyObject *swig_obj[1] ;
52239
52240 if (!args) SWIG_fail;
52241 swig_obj[0] = args;
52242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52243 if (!SWIG_IsOK(res1)) {
52244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52245 }
52246 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52247 {
52248 PyThreadState* __tstate = wxPyBeginAllowThreads();
52249 delete arg1;
52250
52251 wxPyEndAllowThreads(__tstate);
52252 if (PyErr_Occurred()) SWIG_fail;
52253 }
52254 resultobj = SWIG_Py_Void();
52255 return resultobj;
52256 fail:
52257 return NULL;
52258 }
52259
52260
52261 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52262 PyObject *resultobj = 0;
52263 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52264 wxWindow *arg2 = (wxWindow *) 0 ;
52265 int *arg3 = (int *) 0 ;
52266 bool result;
52267 void *argp1 = 0 ;
52268 int res1 = 0 ;
52269 void *argp2 = 0 ;
52270 int res2 = 0 ;
52271 int temp3 ;
52272 int res3 = SWIG_TMPOBJ ;
52273 PyObject * obj0 = 0 ;
52274 PyObject * obj1 = 0 ;
52275 char * kwnames[] = {
52276 (char *) "self",(char *) "win", NULL
52277 };
52278
52279 arg3 = &temp3;
52280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52282 if (!SWIG_IsOK(res1)) {
52283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52284 }
52285 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52287 if (!SWIG_IsOK(res2)) {
52288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52289 }
52290 arg2 = reinterpret_cast< wxWindow * >(argp2);
52291 {
52292 PyThreadState* __tstate = wxPyBeginAllowThreads();
52293 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52294 wxPyEndAllowThreads(__tstate);
52295 if (PyErr_Occurred()) SWIG_fail;
52296 }
52297 {
52298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52299 }
52300 if (SWIG_IsTmpObj(res3)) {
52301 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52302 } else {
52303 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52304 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52305 }
52306 return resultobj;
52307 fail:
52308 return NULL;
52309 }
52310
52311
52312 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52313 PyObject *resultobj = 0;
52314 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52315 bool result;
52316 void *argp1 = 0 ;
52317 int res1 = 0 ;
52318 PyObject *swig_obj[1] ;
52319
52320 if (!args) SWIG_fail;
52321 swig_obj[0] = args;
52322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52323 if (!SWIG_IsOK(res1)) {
52324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52325 }
52326 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52327 {
52328 PyThreadState* __tstate = wxPyBeginAllowThreads();
52329 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52330 wxPyEndAllowThreads(__tstate);
52331 if (PyErr_Occurred()) SWIG_fail;
52332 }
52333 {
52334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52335 }
52336 return resultobj;
52337 fail:
52338 return NULL;
52339 }
52340
52341
52342 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52343 PyObject *obj;
52344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52345 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52346 return SWIG_Py_Void();
52347 }
52348
52349 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52350 return SWIG_Python_InitShadowInstance(args);
52351 }
52352
52353 static PyMethodDef SwigMethods[] = {
52354 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52355 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52356 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52357 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52358 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52359 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52360 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52361 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52362 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52363 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52364 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52365 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52366 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52367 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52368 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52369 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52370 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52371 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52372 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52373 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52374 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52375 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52376 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52377 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52378 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52379 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52380 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52381 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52382 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52383 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52384 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52385 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52386 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52387 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52388 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52389 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52390 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52391 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52392 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52393 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52394 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52395 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52396 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52397 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52398 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52399 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52400 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52401 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52402 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52403 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52404 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52405 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52406 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52407 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52408 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52409 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52410 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52411 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52412 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52413 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52414 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52415 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52416 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52417 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52418 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52419 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52420 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52421 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52422 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52423 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52424 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52425 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52426 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52427 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52428 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52429 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52430 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52431 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52432 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52433 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52434 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52435 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52436 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52437 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52438 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52439 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52440 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52441 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52443 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52445 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52446 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52447 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52448 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52449 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52450 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52451 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52453 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52454 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52455 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52456 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52457 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52458 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52459 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52460 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52461 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52462 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52463 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52464 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52465 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52466 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52467 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52468 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52469 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52470 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52471 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52472 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52473 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52474 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52475 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52476 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52477 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52478 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52480 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52482 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52483 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52487 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52488 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52489 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52490 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52491 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52492 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52493 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52494 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52495 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52496 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52497 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52498 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52499 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52500 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52501 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52502 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52503 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52504 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52506 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52507 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52508 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52509 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52510 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52511 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52512 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52513 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52514 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52515 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52516 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52518 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52519 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52521 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52522 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52523 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52524 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52525 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52526 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52527 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52528 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52529 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52530 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52531 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52534 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52536 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52538 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52539 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52540 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52542 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52543 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52544 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52545 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52547 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52548 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52550 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52551 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52552 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52553 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52554 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52555 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52556 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52557 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52558 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52560 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52561 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52562 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52566 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52567 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52568 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52572 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52574 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52576 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52577 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52578 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52579 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52580 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52581 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52582 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52583 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52587 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52589 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52590 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52591 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52592 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52593 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52594 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52600 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52601 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52603 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52604 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52605 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52606 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52607 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52608 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52609 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52610 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52612 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52613 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52614 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52615 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52616 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52617 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52618 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52619 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52621 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52630 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52631 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52632 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52633 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52634 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52640 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52642 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52643 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52645 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52658 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52659 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52660 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52661 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52664 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52666 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52668 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52669 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52670 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52672 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52675 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52676 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52677 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52678 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52680 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52695 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52696 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52697 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52698 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52702 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52704 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52705 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52706 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52707 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52708 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52709 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52710 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52711 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52712 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52713 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52714 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52715 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52716 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52717 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52718 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52719 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52720 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52721 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52722 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52723 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52724 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52725 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52726 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52727 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52728 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52729 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52730 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52731 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52732 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52733 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52734 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52735 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52736 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52737 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52738 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52740 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52741 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52742 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52743 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52746 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52750 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52754 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52755 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52756 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52757 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52759 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52760 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52762 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52764 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52766 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52768 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52769 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52770 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52772 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52773 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52775 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52776 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52777 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52778 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52779 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52780 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52781 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52783 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52785 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52786 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52787 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52789 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52791 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52792 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52794 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52795 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52796 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52798 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52799 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52800 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52801 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52802 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52804 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52805 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52808 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52809 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52811 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52812 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52815 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52816 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52818 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52824 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52825 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52826 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52827 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52828 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52829 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52830 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52831 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52832 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52833 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52834 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52835 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52836 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52837 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52838 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52839 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52840 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52841 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52842 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52843 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52844 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52845 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52846 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52847 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52849 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52850 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52851 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52852 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52853 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52854 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52855 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52856 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52857 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52858 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52859 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52860 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52861 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52862 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52863 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52864 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52865 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52866 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52867 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52868 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52869 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52870 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52871 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52872 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52873 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52874 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52875 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52876 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52877 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52878 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52879 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52880 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52882 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52883 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52885 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52886 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52887 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52888 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52890 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52891 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52892 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52893 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52894 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52895 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52896 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52897 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52898 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52899 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52900 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52901 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52902 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52903 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52904 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52905 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52906 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52907 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52908 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52909 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52910 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52911 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52912 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52913 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52914 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52915 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52916 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52917 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52918 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52919 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52920 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52921 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52922 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52923 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52924 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52925 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52926 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52928 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52929 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52932 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52933 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52934 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52935 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52936 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52937 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52939 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52940 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52943 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52944 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52946 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52947 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52949 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52950 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52952 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52953 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52954 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52956 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52958 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52959 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
52961 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
52962 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
52963 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
52965 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
52966 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
52967 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
52969 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
52970 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
52972 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
52973 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
52974 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
52975 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
52976 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
52979 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
52981 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
52983 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
52984 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
52985 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
52988 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
52989 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
52990 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
52992 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
52993 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
52994 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
52996 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
52997 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
52998 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
52999 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53000 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53001 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53003 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53004 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53005 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53006 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53007 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53008 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53009 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53010 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53016 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53018 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53020 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53021 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53022 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53023 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53024 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53025 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53027 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53028 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53029 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53030 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53031 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53032 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53035 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53036 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53037 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53040 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53041 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53042 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53043 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53044 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53046 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53048 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53051 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53053 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53054 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53056 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53057 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53058 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53060 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53061 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53062 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53064 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53066 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53067 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53068 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53070 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53072 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53074 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53075 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53077 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53079 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53080 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53081 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53083 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53085 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53086 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53087 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53089 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53091 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53092 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53093 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53094 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53096 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53098 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53100 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53102 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53103 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53105 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53106 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53107 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53108 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53109 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53110 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53111 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53112 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53114 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53116 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53118 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53120 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53122 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53124 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53125 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53126 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53127 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53128 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53129 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53135 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53136 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53137 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53138 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53139 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53140 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53141 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53143 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53145 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53146 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53148 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53149 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53150 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53151 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53153 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53154 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53155 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53156 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53158 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53159 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53161 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53162 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53163 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53165 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53167 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53168 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53169 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53170 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53171 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53173 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53174 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53175 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53176 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53178 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53179 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53180 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53181 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53182 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53183 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53184 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53185 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53186 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53187 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53189 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53192 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53193 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53194 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53196 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53198 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53200 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53202 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53203 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53213 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53214 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53218 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53219 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53220 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53221 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53222 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53223 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53224 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53225 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53226 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53227 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53228 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53229 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53230 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53231 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53232 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53234 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53235 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53238 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53239 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53244 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53245 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53248 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53249 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53250 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53251 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53254 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53255 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53256 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53258 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53260 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53261 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53262 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53264 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53266 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53268 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53271 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53272 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53273 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53274 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53275 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53276 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53277 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53283 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53284 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53285 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53286 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53292 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53298 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53299 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53300 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53301 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53302 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53304 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53314 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53315 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53316 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53317 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53320 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53321 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53322 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53323 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53325 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53326 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53330 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53336 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53337 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53338 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53339 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53341 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53342 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53344 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53347 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53349 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53350 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53351 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53360 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53364 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53366 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53376 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53377 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53378 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53379 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53382 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53385 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53387 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53390 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53392 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53393 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53396 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53398 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53399 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53400 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53401 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53402 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53407 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53408 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53409 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53411 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53412 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53413 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53415 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53417 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53418 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53419 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53421 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53422 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53425 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53432 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53439 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53447 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53450 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53451 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53464 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53466 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53468 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53469 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53471 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53473 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53474 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53476 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53477 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53478 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53482 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53501 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53502 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53504 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53506 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53507 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53508 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53510 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53511 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53514 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53515 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53517 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53518 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53520 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53523 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53524 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53526 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53528 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53530 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53531 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53533 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53534 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53537 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53539 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53541 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53543 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53546 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53548 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53549 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53550 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53552 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53553 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53554 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53556 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53559 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53561 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53562 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53566 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53570 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53571 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53573 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53577 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53579 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53581 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53582 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53583 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53584 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53588 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53589 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53590 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53591 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53593 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53594 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53599 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53600 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53601 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53602 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53603 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53605 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53607 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53609 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53610 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53612 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53614 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53617 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53618 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53619 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53621 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53622 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53623 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53637 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53638 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53639 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53640 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53641 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53642 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53648 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53649 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53653 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53654 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53656 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53657 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53659 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53661 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53662 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53664 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53665 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53666 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53672 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53673 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53674 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53675 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53676 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53677 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53684 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53686 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53687 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53688 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53689 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53690 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53691 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53693 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53697 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53698 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53699 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53700 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53701 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53702 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53703 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53705 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53706 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53707 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53713 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53714 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53715 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53717 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53718 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53719 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53725 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53726 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53727 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53728 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53729 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53733 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53734 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53739 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53740 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53742 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53743 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53748 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53750 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53751 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53752 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53753 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53754 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53759 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53760 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53769 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53770 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53771 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53772 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53775 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53777 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53778 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53779 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53780 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53782 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53787 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53788 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53789 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53790 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53791 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53792 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53793 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53794 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53795 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53796 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53797 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53799 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53800 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53801 { NULL, NULL, 0, NULL }
53802 };
53803
53804
53805 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53806
53807 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53808 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53809 }
53810 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53811 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53812 }
53813 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53814 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53815 }
53816 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53817 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53818 }
53819 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53820 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53821 }
53822 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53823 return (void *)((wxSizer *) ((wxGridSizer *) x));
53824 }
53825 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53826 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53827 }
53828 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53829 return (void *)((wxSizer *) ((wxPySizer *) x));
53830 }
53831 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53832 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53833 }
53834 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53835 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53836 }
53837 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53838 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53839 }
53840 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53841 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53842 }
53843 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53844 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53845 }
53846 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53847 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53848 }
53849 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53850 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53851 }
53852 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53853 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53854 }
53855 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53856 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53857 }
53858 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53859 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53860 }
53861 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53862 return (void *)((wxEvent *) ((wxPyEvent *) x));
53863 }
53864 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53865 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53866 }
53867 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53868 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53869 }
53870 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53871 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53872 }
53873 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53874 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53875 }
53876 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53877 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53878 }
53879 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53880 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53881 }
53882 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53883 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53884 }
53885 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53886 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53887 }
53888 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53889 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53890 }
53891 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53892 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53893 }
53894 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53895 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53896 }
53897 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53898 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53899 }
53900 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53901 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53902 }
53903 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53904 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53905 }
53906 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53907 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53908 }
53909 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53910 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53911 }
53912 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53913 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53914 }
53915 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53916 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53917 }
53918 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53919 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53920 }
53921 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53922 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53923 }
53924 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53925 return (void *)((wxEvent *) ((wxShowEvent *) x));
53926 }
53927 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53928 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53929 }
53930 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53931 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53932 }
53933 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53934 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53935 }
53936 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53937 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53938 }
53939 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53940 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53941 }
53942 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53943 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53944 }
53945 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53946 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53947 }
53948 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53949 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53950 }
53951 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53952 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53953 }
53954 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53955 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53956 }
53957 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53958 return (void *)((wxControl *) ((wxControlWithItems *) x));
53959 }
53960 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
53961 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
53962 }
53963 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
53964 return (void *)((wxEvtHandler *) ((wxWindow *) x));
53965 }
53966 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
53967 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
53968 }
53969 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
53970 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
53971 }
53972 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
53973 return (void *)((wxEvtHandler *) ((wxValidator *) x));
53974 }
53975 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
53976 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
53977 }
53978 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
53979 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
53980 }
53981 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
53982 return (void *)((wxEvtHandler *) ((wxMenu *) x));
53983 }
53984 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
53985 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
53986 }
53987 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
53988 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
53989 }
53990 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
53991 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
53992 }
53993 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
53994 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
53995 }
53996 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
53997 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
53998 }
53999 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54000 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54001 }
54002 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54003 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54004 }
54005 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54006 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54007 }
54008 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54009 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54010 }
54011 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54012 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54013 }
54014 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54015 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54016 }
54017 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54018 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54019 }
54020 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54021 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54022 }
54023 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54024 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54025 }
54026 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54027 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54028 }
54029 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54030 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54031 }
54032 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54033 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54034 }
54035 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54036 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54037 }
54038 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54039 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54040 }
54041 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54042 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54043 }
54044 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54045 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54046 }
54047 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54048 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54049 }
54050 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54051 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54052 }
54053 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54054 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54055 }
54056 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54057 return (void *)((wxObject *) ((wxSizerItem *) x));
54058 }
54059 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54060 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54061 }
54062 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54063 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54064 }
54065 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54066 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54067 }
54068 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54069 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54070 }
54071 static void *_p_wxSizerTo_p_wxObject(void *x) {
54072 return (void *)((wxObject *) ((wxSizer *) x));
54073 }
54074 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54075 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54076 }
54077 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54078 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54079 }
54080 static void *_p_wxEventTo_p_wxObject(void *x) {
54081 return (void *)((wxObject *) ((wxEvent *) x));
54082 }
54083 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54084 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54085 }
54086 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54087 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54088 }
54089 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54090 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54091 }
54092 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54093 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54094 }
54095 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54096 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54097 }
54098 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54099 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54100 }
54101 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54102 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54103 }
54104 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54105 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54106 }
54107 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54108 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54109 }
54110 static void *_p_wxControlTo_p_wxObject(void *x) {
54111 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54112 }
54113 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54114 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54115 }
54116 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54117 return (void *)((wxObject *) ((wxFSFile *) x));
54118 }
54119 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54120 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54121 }
54122 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54123 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54124 }
54125 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54126 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54127 }
54128 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54129 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54130 }
54131 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54132 return (void *)((wxObject *) ((wxMenuItem *) x));
54133 }
54134 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54135 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54136 }
54137 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54138 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54139 }
54140 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54141 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54142 }
54143 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54144 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54145 }
54146 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54147 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54148 }
54149 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54150 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54151 }
54152 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54153 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54154 }
54155 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54156 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54157 }
54158 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54159 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54160 }
54161 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54162 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54163 }
54164 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54165 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54166 }
54167 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54168 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54169 }
54170 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54171 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54172 }
54173 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54174 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54175 }
54176 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54177 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54178 }
54179 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54180 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54181 }
54182 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54183 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54184 }
54185 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54186 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54187 }
54188 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54189 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54190 }
54191 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54192 return (void *)((wxObject *) ((wxImageHandler *) x));
54193 }
54194 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54195 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54196 }
54197 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54198 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54199 }
54200 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54201 return (void *)((wxObject *) ((wxEvtHandler *) x));
54202 }
54203 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54204 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54205 }
54206 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54207 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54208 }
54209 static void *_p_wxImageTo_p_wxObject(void *x) {
54210 return (void *)((wxObject *) ((wxImage *) x));
54211 }
54212 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54213 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54214 }
54215 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54216 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54217 }
54218 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54219 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54220 }
54221 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54222 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54223 }
54224 static void *_p_wxWindowTo_p_wxObject(void *x) {
54225 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54226 }
54227 static void *_p_wxMenuTo_p_wxObject(void *x) {
54228 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54229 }
54230 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54231 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54232 }
54233 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54234 return (void *)((wxObject *) ((wxFileSystem *) x));
54235 }
54236 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54237 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54238 }
54239 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54240 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54241 }
54242 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54243 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54244 }
54245 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54246 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54247 }
54248 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54249 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54250 }
54251 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54252 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54253 }
54254 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54255 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54256 }
54257 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54258 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54259 }
54260 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54261 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54262 }
54263 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54264 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54265 }
54266 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54267 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54268 }
54269 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54270 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54271 }
54272 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54273 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54274 }
54275 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54276 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54277 }
54278 static void *_p_wxControlTo_p_wxWindow(void *x) {
54279 return (void *)((wxWindow *) ((wxControl *) x));
54280 }
54281 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54282 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54283 }
54284 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54285 return (void *)((wxWindow *) ((wxMenuBar *) x));
54286 }
54287 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54288 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54289 }
54290 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54291 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54292 }
54293 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54294 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54295 }
54296 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54297 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54298 }
54299 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54300 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54301 }
54302 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54303 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54304 }
54305 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54306 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54307 }
54308 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54309 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54310 }
54311 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54312 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54313 }
54314 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54315 return (void *)((wxValidator *) ((wxPyValidator *) x));
54316 }
54317 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54318 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54319 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};
54320 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54321 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54322 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54323 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54324 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54325 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54326 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54327 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54328 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54329 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54330 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54331 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54332 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54333 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54334 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54335 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54336 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54337 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54338 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54339 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54340 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54341 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54342 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54343 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54344 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54345 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54346 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54347 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54348 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54349 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54350 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54351 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54352 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54353 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54354 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54355 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54356 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54357 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54358 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54359 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54360 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54361 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54362 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54363 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54364 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54365 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54366 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54367 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54368 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54369 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54370 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54371 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54372 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54373 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54374 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54375 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54376 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54377 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54378 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54379 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54380 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54381 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54382 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54383 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54384 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54385 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54386 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54387 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54388 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54389 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54390 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54391 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54392 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54393 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54394 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54395 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54396 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54397 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54398 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54399 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54400 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54401 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54402 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54403 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54404 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54405 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54406 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54407 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54408 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54409 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54410 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54411 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54412 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54413 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54414 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54415 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54416 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54417 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54418 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54419 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54420 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54421 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54422 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54423 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54424 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54425 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54426 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54427 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54428 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54429 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54430 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54431 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54432 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54433 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54434 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54435 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54436 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54437 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54438 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54439 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54444 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54445 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54446
54447 static swig_type_info *swig_type_initial[] = {
54448 &_swigt__p_buffer,
54449 &_swigt__p_char,
54450 &_swigt__p_form_ops_t,
54451 &_swigt__p_int,
54452 &_swigt__p_long,
54453 &_swigt__p_unsigned_char,
54454 &_swigt__p_unsigned_int,
54455 &_swigt__p_unsigned_long,
54456 &_swigt__p_wxANIHandler,
54457 &_swigt__p_wxAcceleratorEntry,
54458 &_swigt__p_wxAcceleratorTable,
54459 &_swigt__p_wxActivateEvent,
54460 &_swigt__p_wxAppTraits,
54461 &_swigt__p_wxArrayString,
54462 &_swigt__p_wxBMPHandler,
54463 &_swigt__p_wxBitmap,
54464 &_swigt__p_wxBoxSizer,
54465 &_swigt__p_wxButton,
54466 &_swigt__p_wxCURHandler,
54467 &_swigt__p_wxCaret,
54468 &_swigt__p_wxChildFocusEvent,
54469 &_swigt__p_wxCloseEvent,
54470 &_swigt__p_wxColour,
54471 &_swigt__p_wxCommandEvent,
54472 &_swigt__p_wxContextMenuEvent,
54473 &_swigt__p_wxControl,
54474 &_swigt__p_wxControlWithItems,
54475 &_swigt__p_wxCursor,
54476 &_swigt__p_wxDC,
54477 &_swigt__p_wxDateEvent,
54478 &_swigt__p_wxDateTime,
54479 &_swigt__p_wxDisplayChangedEvent,
54480 &_swigt__p_wxDropFilesEvent,
54481 &_swigt__p_wxDuplexMode,
54482 &_swigt__p_wxEraseEvent,
54483 &_swigt__p_wxEvent,
54484 &_swigt__p_wxEventLoop,
54485 &_swigt__p_wxEventLoopActivator,
54486 &_swigt__p_wxEvtHandler,
54487 &_swigt__p_wxFSFile,
54488 &_swigt__p_wxFileSystem,
54489 &_swigt__p_wxFileSystemHandler,
54490 &_swigt__p_wxFlexGridSizer,
54491 &_swigt__p_wxFocusEvent,
54492 &_swigt__p_wxFont,
54493 &_swigt__p_wxFrame,
54494 &_swigt__p_wxGBPosition,
54495 &_swigt__p_wxGBSizerItem,
54496 &_swigt__p_wxGBSpan,
54497 &_swigt__p_wxGIFHandler,
54498 &_swigt__p_wxGridBagSizer,
54499 &_swigt__p_wxGridSizer,
54500 &_swigt__p_wxICOHandler,
54501 &_swigt__p_wxIconizeEvent,
54502 &_swigt__p_wxIdleEvent,
54503 &_swigt__p_wxImage,
54504 &_swigt__p_wxImageHandler,
54505 &_swigt__p_wxImageHistogram,
54506 &_swigt__p_wxImage_HSVValue,
54507 &_swigt__p_wxImage_RGBValue,
54508 &_swigt__p_wxIndividualLayoutConstraint,
54509 &_swigt__p_wxInitDialogEvent,
54510 &_swigt__p_wxInputStream,
54511 &_swigt__p_wxInternetFSHandler,
54512 &_swigt__p_wxItemContainer,
54513 &_swigt__p_wxJPEGHandler,
54514 &_swigt__p_wxKeyEvent,
54515 &_swigt__p_wxLayoutConstraints,
54516 &_swigt__p_wxMaximizeEvent,
54517 &_swigt__p_wxMemoryFSHandler,
54518 &_swigt__p_wxMenu,
54519 &_swigt__p_wxMenuBar,
54520 &_swigt__p_wxMenuBarBase,
54521 &_swigt__p_wxMenuEvent,
54522 &_swigt__p_wxMenuItem,
54523 &_swigt__p_wxMouseCaptureChangedEvent,
54524 &_swigt__p_wxMouseEvent,
54525 &_swigt__p_wxMoveEvent,
54526 &_swigt__p_wxNavigationKeyEvent,
54527 &_swigt__p_wxNcPaintEvent,
54528 &_swigt__p_wxNotifyEvent,
54529 &_swigt__p_wxObject,
54530 &_swigt__p_wxOutputStream,
54531 &_swigt__p_wxPCXHandler,
54532 &_swigt__p_wxPNGHandler,
54533 &_swigt__p_wxPNMHandler,
54534 &_swigt__p_wxPaintEvent,
54535 &_swigt__p_wxPaletteChangedEvent,
54536 &_swigt__p_wxPaperSize,
54537 &_swigt__p_wxPoint,
54538 &_swigt__p_wxPoint2D,
54539 &_swigt__p_wxPropagateOnce,
54540 &_swigt__p_wxPropagationDisabler,
54541 &_swigt__p_wxPyApp,
54542 &_swigt__p_wxPyCommandEvent,
54543 &_swigt__p_wxPyDropTarget,
54544 &_swigt__p_wxPyEvent,
54545 &_swigt__p_wxPyFileSystemHandler,
54546 &_swigt__p_wxPyImageHandler,
54547 &_swigt__p_wxPyInputStream,
54548 &_swigt__p_wxPySizer,
54549 &_swigt__p_wxPyValidator,
54550 &_swigt__p_wxQuantize,
54551 &_swigt__p_wxQueryNewPaletteEvent,
54552 &_swigt__p_wxRealPoint,
54553 &_swigt__p_wxRect,
54554 &_swigt__p_wxRegion,
54555 &_swigt__p_wxScrollEvent,
54556 &_swigt__p_wxScrollWinEvent,
54557 &_swigt__p_wxSetCursorEvent,
54558 &_swigt__p_wxShowEvent,
54559 &_swigt__p_wxSize,
54560 &_swigt__p_wxSizeEvent,
54561 &_swigt__p_wxSizer,
54562 &_swigt__p_wxSizerItem,
54563 &_swigt__p_wxStaticBox,
54564 &_swigt__p_wxStaticBoxSizer,
54565 &_swigt__p_wxStdDialogButtonSizer,
54566 &_swigt__p_wxSysColourChangedEvent,
54567 &_swigt__p_wxTIFFHandler,
54568 &_swigt__p_wxToolTip,
54569 &_swigt__p_wxUpdateUIEvent,
54570 &_swigt__p_wxValidator,
54571 &_swigt__p_wxVisualAttributes,
54572 &_swigt__p_wxWindow,
54573 &_swigt__p_wxWindowCreateEvent,
54574 &_swigt__p_wxWindowDestroyEvent,
54575 &_swigt__p_wxXPMHandler,
54576 &_swigt__p_wxZipFSHandler,
54577 };
54578
54579 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54580 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54581 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54582 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54583 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54584 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54585 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54586 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54587 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54588 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54589 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54590 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54591 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54592 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54593 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}};
54594 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54595 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}};
54596 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54597 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}};
54598 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54599 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54600 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54601 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54602 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54603 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54604 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}};
54605 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54606 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54607 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54608 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54609 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54610 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54611 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54612 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54613 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54614 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54615 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54616 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54617 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}};
54618 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54619 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54620 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}};
54621 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}};
54622 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54623 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54624 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54625 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54626 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54627 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54628 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54629 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54630 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}};
54631 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}};
54632 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54633 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54634 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54635 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}};
54636 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54637 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54638 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54639 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54640 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54641 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54642 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54643 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}};
54644 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54645 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54646 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54647 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54648 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54649 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54650 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54651 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54652 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54653 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54654 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54655 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54656 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54657 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54658 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54659 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54660 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54661 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54662 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54663 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54664 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54665 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54666 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54667 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54668 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54669 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54670 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54671 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54672 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54673 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54674 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54675 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54676 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54677 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54678 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54679 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54680 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54681 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54682 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54683 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54684 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54685 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54686 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54687 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54688 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54689 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54690 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54691 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54692 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}};
54693 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}};
54694 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54695 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54696 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54697 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54698 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54699 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54700 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54701 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}};
54702 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54703 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}};
54704 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54706 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54707 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54708
54709 static swig_cast_info *swig_cast_initial[] = {
54710 _swigc__p_buffer,
54711 _swigc__p_char,
54712 _swigc__p_form_ops_t,
54713 _swigc__p_int,
54714 _swigc__p_long,
54715 _swigc__p_unsigned_char,
54716 _swigc__p_unsigned_int,
54717 _swigc__p_unsigned_long,
54718 _swigc__p_wxANIHandler,
54719 _swigc__p_wxAcceleratorEntry,
54720 _swigc__p_wxAcceleratorTable,
54721 _swigc__p_wxActivateEvent,
54722 _swigc__p_wxAppTraits,
54723 _swigc__p_wxArrayString,
54724 _swigc__p_wxBMPHandler,
54725 _swigc__p_wxBitmap,
54726 _swigc__p_wxBoxSizer,
54727 _swigc__p_wxButton,
54728 _swigc__p_wxCURHandler,
54729 _swigc__p_wxCaret,
54730 _swigc__p_wxChildFocusEvent,
54731 _swigc__p_wxCloseEvent,
54732 _swigc__p_wxColour,
54733 _swigc__p_wxCommandEvent,
54734 _swigc__p_wxContextMenuEvent,
54735 _swigc__p_wxControl,
54736 _swigc__p_wxControlWithItems,
54737 _swigc__p_wxCursor,
54738 _swigc__p_wxDC,
54739 _swigc__p_wxDateEvent,
54740 _swigc__p_wxDateTime,
54741 _swigc__p_wxDisplayChangedEvent,
54742 _swigc__p_wxDropFilesEvent,
54743 _swigc__p_wxDuplexMode,
54744 _swigc__p_wxEraseEvent,
54745 _swigc__p_wxEvent,
54746 _swigc__p_wxEventLoop,
54747 _swigc__p_wxEventLoopActivator,
54748 _swigc__p_wxEvtHandler,
54749 _swigc__p_wxFSFile,
54750 _swigc__p_wxFileSystem,
54751 _swigc__p_wxFileSystemHandler,
54752 _swigc__p_wxFlexGridSizer,
54753 _swigc__p_wxFocusEvent,
54754 _swigc__p_wxFont,
54755 _swigc__p_wxFrame,
54756 _swigc__p_wxGBPosition,
54757 _swigc__p_wxGBSizerItem,
54758 _swigc__p_wxGBSpan,
54759 _swigc__p_wxGIFHandler,
54760 _swigc__p_wxGridBagSizer,
54761 _swigc__p_wxGridSizer,
54762 _swigc__p_wxICOHandler,
54763 _swigc__p_wxIconizeEvent,
54764 _swigc__p_wxIdleEvent,
54765 _swigc__p_wxImage,
54766 _swigc__p_wxImageHandler,
54767 _swigc__p_wxImageHistogram,
54768 _swigc__p_wxImage_HSVValue,
54769 _swigc__p_wxImage_RGBValue,
54770 _swigc__p_wxIndividualLayoutConstraint,
54771 _swigc__p_wxInitDialogEvent,
54772 _swigc__p_wxInputStream,
54773 _swigc__p_wxInternetFSHandler,
54774 _swigc__p_wxItemContainer,
54775 _swigc__p_wxJPEGHandler,
54776 _swigc__p_wxKeyEvent,
54777 _swigc__p_wxLayoutConstraints,
54778 _swigc__p_wxMaximizeEvent,
54779 _swigc__p_wxMemoryFSHandler,
54780 _swigc__p_wxMenu,
54781 _swigc__p_wxMenuBar,
54782 _swigc__p_wxMenuBarBase,
54783 _swigc__p_wxMenuEvent,
54784 _swigc__p_wxMenuItem,
54785 _swigc__p_wxMouseCaptureChangedEvent,
54786 _swigc__p_wxMouseEvent,
54787 _swigc__p_wxMoveEvent,
54788 _swigc__p_wxNavigationKeyEvent,
54789 _swigc__p_wxNcPaintEvent,
54790 _swigc__p_wxNotifyEvent,
54791 _swigc__p_wxObject,
54792 _swigc__p_wxOutputStream,
54793 _swigc__p_wxPCXHandler,
54794 _swigc__p_wxPNGHandler,
54795 _swigc__p_wxPNMHandler,
54796 _swigc__p_wxPaintEvent,
54797 _swigc__p_wxPaletteChangedEvent,
54798 _swigc__p_wxPaperSize,
54799 _swigc__p_wxPoint,
54800 _swigc__p_wxPoint2D,
54801 _swigc__p_wxPropagateOnce,
54802 _swigc__p_wxPropagationDisabler,
54803 _swigc__p_wxPyApp,
54804 _swigc__p_wxPyCommandEvent,
54805 _swigc__p_wxPyDropTarget,
54806 _swigc__p_wxPyEvent,
54807 _swigc__p_wxPyFileSystemHandler,
54808 _swigc__p_wxPyImageHandler,
54809 _swigc__p_wxPyInputStream,
54810 _swigc__p_wxPySizer,
54811 _swigc__p_wxPyValidator,
54812 _swigc__p_wxQuantize,
54813 _swigc__p_wxQueryNewPaletteEvent,
54814 _swigc__p_wxRealPoint,
54815 _swigc__p_wxRect,
54816 _swigc__p_wxRegion,
54817 _swigc__p_wxScrollEvent,
54818 _swigc__p_wxScrollWinEvent,
54819 _swigc__p_wxSetCursorEvent,
54820 _swigc__p_wxShowEvent,
54821 _swigc__p_wxSize,
54822 _swigc__p_wxSizeEvent,
54823 _swigc__p_wxSizer,
54824 _swigc__p_wxSizerItem,
54825 _swigc__p_wxStaticBox,
54826 _swigc__p_wxStaticBoxSizer,
54827 _swigc__p_wxStdDialogButtonSizer,
54828 _swigc__p_wxSysColourChangedEvent,
54829 _swigc__p_wxTIFFHandler,
54830 _swigc__p_wxToolTip,
54831 _swigc__p_wxUpdateUIEvent,
54832 _swigc__p_wxValidator,
54833 _swigc__p_wxVisualAttributes,
54834 _swigc__p_wxWindow,
54835 _swigc__p_wxWindowCreateEvent,
54836 _swigc__p_wxWindowDestroyEvent,
54837 _swigc__p_wxXPMHandler,
54838 _swigc__p_wxZipFSHandler,
54839 };
54840
54841
54842 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54843
54844 static swig_const_info swig_const_table[] = {
54845 {0, 0, 0, 0.0, 0, 0}};
54846
54847 #ifdef __cplusplus
54848 }
54849 #endif
54850 /* -----------------------------------------------------------------------------
54851 * Type initialization:
54852 * This problem is tough by the requirement that no dynamic
54853 * memory is used. Also, since swig_type_info structures store pointers to
54854 * swig_cast_info structures and swig_cast_info structures store pointers back
54855 * to swig_type_info structures, we need some lookup code at initialization.
54856 * The idea is that swig generates all the structures that are needed.
54857 * The runtime then collects these partially filled structures.
54858 * The SWIG_InitializeModule function takes these initial arrays out of
54859 * swig_module, and does all the lookup, filling in the swig_module.types
54860 * array with the correct data and linking the correct swig_cast_info
54861 * structures together.
54862 *
54863 * The generated swig_type_info structures are assigned staticly to an initial
54864 * array. We just loop though that array, and handle each type individually.
54865 * First we lookup if this type has been already loaded, and if so, use the
54866 * loaded structure instead of the generated one. Then we have to fill in the
54867 * cast linked list. The cast data is initially stored in something like a
54868 * two-dimensional array. Each row corresponds to a type (there are the same
54869 * number of rows as there are in the swig_type_initial array). Each entry in
54870 * a column is one of the swig_cast_info structures for that type.
54871 * The cast_initial array is actually an array of arrays, because each row has
54872 * a variable number of columns. So to actually build the cast linked list,
54873 * we find the array of casts associated with the type, and loop through it
54874 * adding the casts to the list. The one last trick we need to do is making
54875 * sure the type pointer in the swig_cast_info struct is correct.
54876 *
54877 * First off, we lookup the cast->type name to see if it is already loaded.
54878 * There are three cases to handle:
54879 * 1) If the cast->type has already been loaded AND the type we are adding
54880 * casting info to has not been loaded (it is in this module), THEN we
54881 * replace the cast->type pointer with the type pointer that has already
54882 * been loaded.
54883 * 2) If BOTH types (the one we are adding casting info to, and the
54884 * cast->type) are loaded, THEN the cast info has already been loaded by
54885 * the previous module so we just ignore it.
54886 * 3) Finally, if cast->type has not already been loaded, then we add that
54887 * swig_cast_info to the linked list (because the cast->type) pointer will
54888 * be correct.
54889 * ----------------------------------------------------------------------------- */
54890
54891 #ifdef __cplusplus
54892 extern "C" {
54893 #if 0
54894 } /* c-mode */
54895 #endif
54896 #endif
54897
54898 #if 0
54899 #define SWIGRUNTIME_DEBUG
54900 #endif
54901
54902 SWIGRUNTIME void
54903 SWIG_InitializeModule(void *clientdata) {
54904 size_t i;
54905 swig_module_info *module_head;
54906 static int init_run = 0;
54907
54908 clientdata = clientdata;
54909
54910 if (init_run) return;
54911 init_run = 1;
54912
54913 /* Initialize the swig_module */
54914 swig_module.type_initial = swig_type_initial;
54915 swig_module.cast_initial = swig_cast_initial;
54916
54917 /* Try and load any already created modules */
54918 module_head = SWIG_GetModule(clientdata);
54919 if (module_head) {
54920 swig_module.next = module_head->next;
54921 module_head->next = &swig_module;
54922 } else {
54923 /* This is the first module loaded */
54924 swig_module.next = &swig_module;
54925 SWIG_SetModule(clientdata, &swig_module);
54926 }
54927
54928 /* Now work on filling in swig_module.types */
54929 #ifdef SWIGRUNTIME_DEBUG
54930 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54931 #endif
54932 for (i = 0; i < swig_module.size; ++i) {
54933 swig_type_info *type = 0;
54934 swig_type_info *ret;
54935 swig_cast_info *cast;
54936
54937 #ifdef SWIGRUNTIME_DEBUG
54938 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54939 #endif
54940
54941 /* if there is another module already loaded */
54942 if (swig_module.next != &swig_module) {
54943 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54944 }
54945 if (type) {
54946 /* Overwrite clientdata field */
54947 #ifdef SWIGRUNTIME_DEBUG
54948 printf("SWIG_InitializeModule: found type %s\n", type->name);
54949 #endif
54950 if (swig_module.type_initial[i]->clientdata) {
54951 type->clientdata = swig_module.type_initial[i]->clientdata;
54952 #ifdef SWIGRUNTIME_DEBUG
54953 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54954 #endif
54955 }
54956 } else {
54957 type = swig_module.type_initial[i];
54958 }
54959
54960 /* Insert casting types */
54961 cast = swig_module.cast_initial[i];
54962 while (cast->type) {
54963 /* Don't need to add information already in the list */
54964 ret = 0;
54965 #ifdef SWIGRUNTIME_DEBUG
54966 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
54967 #endif
54968 if (swig_module.next != &swig_module) {
54969 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
54970 #ifdef SWIGRUNTIME_DEBUG
54971 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
54972 #endif
54973 }
54974 if (ret) {
54975 if (type == swig_module.type_initial[i]) {
54976 #ifdef SWIGRUNTIME_DEBUG
54977 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
54978 #endif
54979 cast->type = ret;
54980 ret = 0;
54981 } else {
54982 /* Check for casting already in the list */
54983 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
54984 #ifdef SWIGRUNTIME_DEBUG
54985 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
54986 #endif
54987 if (!ocast) ret = 0;
54988 }
54989 }
54990
54991 if (!ret) {
54992 #ifdef SWIGRUNTIME_DEBUG
54993 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
54994 #endif
54995 if (type->cast) {
54996 type->cast->prev = cast;
54997 cast->next = type->cast;
54998 }
54999 type->cast = cast;
55000 }
55001 cast++;
55002 }
55003 /* Set entry in modules->types array equal to the type */
55004 swig_module.types[i] = type;
55005 }
55006 swig_module.types[i] = 0;
55007
55008 #ifdef SWIGRUNTIME_DEBUG
55009 printf("**** SWIG_InitializeModule: Cast List ******\n");
55010 for (i = 0; i < swig_module.size; ++i) {
55011 int j = 0;
55012 swig_cast_info *cast = swig_module.cast_initial[i];
55013 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55014 while (cast->type) {
55015 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55016 cast++;
55017 ++j;
55018 }
55019 printf("---- Total casts: %d\n",j);
55020 }
55021 printf("**** SWIG_InitializeModule: Cast List ******\n");
55022 #endif
55023 }
55024
55025 /* This function will propagate the clientdata field of type to
55026 * any new swig_type_info structures that have been added into the list
55027 * of equivalent types. It is like calling
55028 * SWIG_TypeClientData(type, clientdata) a second time.
55029 */
55030 SWIGRUNTIME void
55031 SWIG_PropagateClientData(void) {
55032 size_t i;
55033 swig_cast_info *equiv;
55034 static int init_run = 0;
55035
55036 if (init_run) return;
55037 init_run = 1;
55038
55039 for (i = 0; i < swig_module.size; i++) {
55040 if (swig_module.types[i]->clientdata) {
55041 equiv = swig_module.types[i]->cast;
55042 while (equiv) {
55043 if (!equiv->converter) {
55044 if (equiv->type && !equiv->type->clientdata)
55045 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55046 }
55047 equiv = equiv->next;
55048 }
55049 }
55050 }
55051 }
55052
55053 #ifdef __cplusplus
55054 #if 0
55055 {
55056 /* c-mode */
55057 #endif
55058 }
55059 #endif
55060
55061
55062
55063 #ifdef __cplusplus
55064 extern "C" {
55065 #endif
55066
55067 /* Python-specific SWIG API */
55068 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55069 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55070 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55071
55072 /* -----------------------------------------------------------------------------
55073 * global variable support code.
55074 * ----------------------------------------------------------------------------- */
55075
55076 typedef struct swig_globalvar {
55077 char *name; /* Name of global variable */
55078 PyObject *(*get_attr)(void); /* Return the current value */
55079 int (*set_attr)(PyObject *); /* Set the value */
55080 struct swig_globalvar *next;
55081 } swig_globalvar;
55082
55083 typedef struct swig_varlinkobject {
55084 PyObject_HEAD
55085 swig_globalvar *vars;
55086 } swig_varlinkobject;
55087
55088 SWIGINTERN PyObject *
55089 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55090 return PyString_FromString("<Swig global variables>");
55091 }
55092
55093 SWIGINTERN PyObject *
55094 swig_varlink_str(swig_varlinkobject *v) {
55095 PyObject *str = PyString_FromString("(");
55096 swig_globalvar *var;
55097 for (var = v->vars; var; var=var->next) {
55098 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55099 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55100 }
55101 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55102 return str;
55103 }
55104
55105 SWIGINTERN int
55106 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55107 PyObject *str = swig_varlink_str(v);
55108 fprintf(fp,"Swig global variables ");
55109 fprintf(fp,"%s\n", PyString_AsString(str));
55110 Py_DECREF(str);
55111 return 0;
55112 }
55113
55114 SWIGINTERN void
55115 swig_varlink_dealloc(swig_varlinkobject *v) {
55116 swig_globalvar *var = v->vars;
55117 while (var) {
55118 swig_globalvar *n = var->next;
55119 free(var->name);
55120 free(var);
55121 var = n;
55122 }
55123 }
55124
55125 SWIGINTERN PyObject *
55126 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55127 PyObject *res = NULL;
55128 swig_globalvar *var = v->vars;
55129 while (var) {
55130 if (strcmp(var->name,n) == 0) {
55131 res = (*var->get_attr)();
55132 break;
55133 }
55134 var = var->next;
55135 }
55136 if (res == NULL && !PyErr_Occurred()) {
55137 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55138 }
55139 return res;
55140 }
55141
55142 SWIGINTERN int
55143 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55144 int res = 1;
55145 swig_globalvar *var = v->vars;
55146 while (var) {
55147 if (strcmp(var->name,n) == 0) {
55148 res = (*var->set_attr)(p);
55149 break;
55150 }
55151 var = var->next;
55152 }
55153 if (res == 1 && !PyErr_Occurred()) {
55154 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55155 }
55156 return res;
55157 }
55158
55159 SWIGINTERN PyTypeObject*
55160 swig_varlink_type(void) {
55161 static char varlink__doc__[] = "Swig var link object";
55162 static PyTypeObject varlink_type;
55163 static int type_init = 0;
55164 if (!type_init) {
55165 const PyTypeObject tmp
55166 = {
55167 PyObject_HEAD_INIT(NULL)
55168 0, /* Number of items in variable part (ob_size) */
55169 (char *)"swigvarlink", /* Type name (tp_name) */
55170 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55171 0, /* Itemsize (tp_itemsize) */
55172 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55173 (printfunc) swig_varlink_print, /* Print (tp_print) */
55174 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55175 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55176 0, /* tp_compare */
55177 (reprfunc) swig_varlink_repr, /* tp_repr */
55178 0, /* tp_as_number */
55179 0, /* tp_as_sequence */
55180 0, /* tp_as_mapping */
55181 0, /* tp_hash */
55182 0, /* tp_call */
55183 (reprfunc)swig_varlink_str, /* tp_str */
55184 0, /* tp_getattro */
55185 0, /* tp_setattro */
55186 0, /* tp_as_buffer */
55187 0, /* tp_flags */
55188 varlink__doc__, /* tp_doc */
55189 0, /* tp_traverse */
55190 0, /* tp_clear */
55191 0, /* tp_richcompare */
55192 0, /* tp_weaklistoffset */
55193 #if PY_VERSION_HEX >= 0x02020000
55194 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55195 #endif
55196 #if PY_VERSION_HEX >= 0x02030000
55197 0, /* tp_del */
55198 #endif
55199 #ifdef COUNT_ALLOCS
55200 0,0,0,0 /* tp_alloc -> tp_next */
55201 #endif
55202 };
55203 varlink_type = tmp;
55204 varlink_type.ob_type = &PyType_Type;
55205 type_init = 1;
55206 }
55207 return &varlink_type;
55208 }
55209
55210 /* Create a variable linking object for use later */
55211 SWIGINTERN PyObject *
55212 SWIG_Python_newvarlink(void) {
55213 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55214 if (result) {
55215 result->vars = 0;
55216 }
55217 return ((PyObject*) result);
55218 }
55219
55220 SWIGINTERN void
55221 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55222 swig_varlinkobject *v = (swig_varlinkobject *) p;
55223 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55224 if (gv) {
55225 size_t size = strlen(name)+1;
55226 gv->name = (char *)malloc(size);
55227 if (gv->name) {
55228 strncpy(gv->name,name,size);
55229 gv->get_attr = get_attr;
55230 gv->set_attr = set_attr;
55231 gv->next = v->vars;
55232 }
55233 }
55234 v->vars = gv;
55235 }
55236
55237 SWIGINTERN PyObject *
55238 SWIG_globals() {
55239 static PyObject *_SWIG_globals = 0;
55240 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55241 return _SWIG_globals;
55242 }
55243
55244 /* -----------------------------------------------------------------------------
55245 * constants/methods manipulation
55246 * ----------------------------------------------------------------------------- */
55247
55248 /* Install Constants */
55249 SWIGINTERN void
55250 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55251 PyObject *obj = 0;
55252 size_t i;
55253 for (i = 0; constants[i].type; ++i) {
55254 switch(constants[i].type) {
55255 case SWIG_PY_POINTER:
55256 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55257 break;
55258 case SWIG_PY_BINARY:
55259 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55260 break;
55261 default:
55262 obj = 0;
55263 break;
55264 }
55265 if (obj) {
55266 PyDict_SetItemString(d, constants[i].name, obj);
55267 Py_DECREF(obj);
55268 }
55269 }
55270 }
55271
55272 /* -----------------------------------------------------------------------------*/
55273 /* Fix SwigMethods to carry the callback ptrs when needed */
55274 /* -----------------------------------------------------------------------------*/
55275
55276 SWIGINTERN void
55277 SWIG_Python_FixMethods(PyMethodDef *methods,
55278 swig_const_info *const_table,
55279 swig_type_info **types,
55280 swig_type_info **types_initial) {
55281 size_t i;
55282 for (i = 0; methods[i].ml_name; ++i) {
55283 char *c = methods[i].ml_doc;
55284 if (c && (c = strstr(c, "swig_ptr: "))) {
55285 int j;
55286 swig_const_info *ci = 0;
55287 char *name = c + 10;
55288 for (j = 0; const_table[j].type; ++j) {
55289 if (strncmp(const_table[j].name, name,
55290 strlen(const_table[j].name)) == 0) {
55291 ci = &(const_table[j]);
55292 break;
55293 }
55294 }
55295 if (ci) {
55296 size_t shift = (ci->ptype) - types;
55297 swig_type_info *ty = types_initial[shift];
55298 size_t ldoc = (c - methods[i].ml_doc);
55299 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55300 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55301 if (ndoc) {
55302 char *buff = ndoc;
55303 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55304 if (ptr) {
55305 strncpy(buff, methods[i].ml_doc, ldoc);
55306 buff += ldoc;
55307 strncpy(buff, "swig_ptr: ", 10);
55308 buff += 10;
55309 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55310 methods[i].ml_doc = ndoc;
55311 }
55312 }
55313 }
55314 }
55315 }
55316 }
55317
55318 #ifdef __cplusplus
55319 }
55320 #endif
55321
55322 /* -----------------------------------------------------------------------------*
55323 * Partial Init method
55324 * -----------------------------------------------------------------------------*/
55325
55326 #ifdef __cplusplus
55327 extern "C"
55328 #endif
55329 SWIGEXPORT void SWIG_init(void) {
55330 PyObject *m, *d;
55331
55332 /* Fix SwigMethods to carry the callback ptrs when needed */
55333 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55334
55335 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55336 d = PyModule_GetDict(m);
55337
55338 SWIG_InitializeModule(0);
55339 SWIG_InstallConstants(d,swig_const_table);
55340
55341
55342
55343 #ifndef wxPyUSE_EXPORT
55344 // Make our API structure a CObject so other modules can import it
55345 // from this module.
55346 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55347 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55348 Py_XDECREF(cobj);
55349 #endif
55350
55351 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55352 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55353 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55354 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55355 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55356 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55357 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55358 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55359 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55360 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55361 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55362 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55363 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55364 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55365 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55366 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55367 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55368 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55369 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55370 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55371 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55372 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55373 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55374 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55375 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55376 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55377 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55378 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55379 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55380 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55381 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55382 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55383 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55384 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55385 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55386 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55387 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55388 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55389 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55390 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55391 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55392 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55393 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55394 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55395 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55396 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55397 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55398 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55399 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55400 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55401 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55402 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55403 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55404 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55405 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55406 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55407 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55408 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55409 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55410 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55411 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55412 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55413 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55414 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55415 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55416 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55417 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55418 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55419 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55420 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55421 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55422 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55423 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55424 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55425 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55426 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55427 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55428 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55429 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55430 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55431 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55432 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55433 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55434 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55435 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55436 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55437 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55438 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55439 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55440 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55441 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55442 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55443 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55444 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55445 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55446 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55447 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55448 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55449 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55450 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55451 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55452 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55453 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55454 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55455 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55456 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55457 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55458 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55459 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55460 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55461 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55462 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55463 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55464 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55465 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55466 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55467 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55468 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55469 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55470 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55471 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55472 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55473 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55474 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55475 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55476 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55477 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55478 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55479 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55480 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55481 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55482 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55483 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55484 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55485 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55486 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55487 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55488 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55489 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55490 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55491 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55492 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55493 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55494 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55495 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55496 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55497 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55498 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55499 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55500 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55501 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55502 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55503 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55504 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55505 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55506 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55507 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55508 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55509 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55510 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55511 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55512 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55513 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55514 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55515 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55516 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55517 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55518 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55519 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55520 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55521 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55522 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55523 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55524 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55525 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55526 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55527 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55528 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55529 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55530 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55531 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55532 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55533 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55534 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55535 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55536 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55537 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55538 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55539 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55540 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55541 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55542 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55543 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55544 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55545 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55546 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55547 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55548 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55549 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55550 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55551 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55552 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55553 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55554 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55555 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55556 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55557 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55558 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55559 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55560 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55561 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55562 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55563 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55564 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55565 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55566 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55567 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55568 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55569 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55570 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55571 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55572 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55573 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55574 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55575 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55576 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55577 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55578 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55579 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55580 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55581 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55582 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55583 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55584 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55585 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55586 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55587 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55588 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55589 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55590 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55591 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55592 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55593 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55594 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55595 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55596 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55597 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55598 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55599 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55600 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55601 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55602 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55603 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55604 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55605 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55606 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55607 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55608 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55609 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55610 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55611 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55612 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55613 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55614 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55615 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55616 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55617 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55618 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55619 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55620 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55621 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55622 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55623 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55624 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55625 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55626 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55627 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55628 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55629 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55630 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55631 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55632 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55633 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55634 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55635 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55636 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55637 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55638 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55639 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55640 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55641 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55642 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55643 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55644 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55645 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55646 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55647 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55648 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55649 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55650 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55651 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55652 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55653 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55654 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55655 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55656 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55657 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55658 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55659 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55660 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55661 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55662 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55663 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55664 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55665 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55666 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55667 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55668 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55669 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55670 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55671 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55672 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55673 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55674 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55675 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55676 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55677 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55678 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55679 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55680 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55681 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55682 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55683 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55684 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55685 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55686 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55687 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55688 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55689 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55690 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55691 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55692 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55693 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55694 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55695 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55696 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55697 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55698 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55699 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55700 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55701 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55702 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55703 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55704 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55705 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55706 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55707 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55708 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55709 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55710 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55711 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55712 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55713 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55714 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55715 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55716 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55717 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55718 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55719 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55720 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55721 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55722 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55723 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55724 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55725 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55726 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55727 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55728 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55729 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55730 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55731 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55732 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55733 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55734 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55735 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55736 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55737 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55738 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55739 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55740 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55741 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55742 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55743 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55744 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55745 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55746 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55747 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55748 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55749 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55750 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55751 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55752 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55753 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55754 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55755 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55756 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55757 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55758 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55759 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55760 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55761 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55762 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55763 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55764 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55765 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55766 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55767 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55768 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55769 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55770 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55771 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55772 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55773 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55774 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55775 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55776 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55777 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55778 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55779 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55780 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55781 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55782 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55783 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55784 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55785 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55786 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55787 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55788 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55789 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55790 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55791 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55792 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55793 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55794 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55795 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55796 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55797 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55798 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55799 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55800 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55801 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55802 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55803 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55804 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55805 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55806 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55807 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55808 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55809 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55810 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55811 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55812 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55813 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55814 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55815 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55816 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55817 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55818 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55819 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55820 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55821 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55822 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55823 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55824 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55825 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55826 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55827 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55828 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55829 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55830 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55831 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55832 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55833 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55834 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55835 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55836 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55837 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55838 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55839 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55840 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55841 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55842 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55843 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55844 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55845 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55846 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55847 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55848 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55849 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55850 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55851 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55852 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55853 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55854 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55855 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55856 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55857 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55858 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55859 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55860 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55861 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55862 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55863 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55864 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55865 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55866 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55867 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55868 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55869 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55870 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55871 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55872 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55873 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55874 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55875 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55876 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55877 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55878 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55879 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55880 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55881 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55882 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55883 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55884 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55885 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55886 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55887 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55888 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55889 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55890 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55891 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55892 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55893 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55894 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55895 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55896 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55897 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55898 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55899 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55900 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55901 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55902 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55903 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55904 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55905 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55906 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55907 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55908 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55909 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55910 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55911 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55912 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55913 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55914 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55915 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55916 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55917 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55918 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55919 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55920 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55921 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55922 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55923 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55924 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55925 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55926 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55927 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55928 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55929 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55930 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55931 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55932 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55933 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55934 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55935 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55936 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55937 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55938 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55939 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55940 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55941 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55942 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55943 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55944 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55945 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55946 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55947 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55948 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55949 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55950 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55951 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55952 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55953 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55954 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55955 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55956 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55957 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
55958 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
55959 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
55960 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
55961 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
55962 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
55963 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
55964 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
55965 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
55966 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
55967 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
55968 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
55969 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
55970 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
55971 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
55972 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
55973 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
55974 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
55975 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
55976 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
55977 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
55978 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
55979 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
55980 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
55981 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
55982 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
55983 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
55984 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
55985 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
55986 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
55987 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
55988 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
55989 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
55990 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
55991 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
55992 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
55993 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
55994 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
55995 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
55996 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
55997 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
55998 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
55999 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56000 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56001 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56002 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56003 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56004 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56005 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56006 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56007 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56008 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56009 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56010 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56011 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56012 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56013 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56014 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56015 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56016 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56017 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56018 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56019 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56020
56021 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56022
56023
56024 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56025
56026 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56027 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56028 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56029 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56030 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56031 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56032 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56033 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56034 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56035 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56036 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56037 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56038 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56039 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56040 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56041 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56042 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56043 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56044 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56045 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56046 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56047 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56048 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56049 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56050 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56051 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56052 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56053 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56054 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56055 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56056 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56057 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56058 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56059 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56060 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56061 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56062 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56063 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56064 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56065 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56066 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56067 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56068 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56069 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56070 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56071 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56072 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56073 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56074 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56075 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56076 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56077 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56078 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56079 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56080 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56081 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56082 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56083 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56084 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56085 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56086 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56087 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56088 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56089 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56090 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56091 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56092 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56093 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56094 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56095 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56096 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56097 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56098 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56099 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56100 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56101 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56102 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56103 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56104 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56105 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56106 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56107 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56108 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56109 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56110 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56111 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56112 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56113 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56114 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56115 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56116 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56117 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56118 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56119 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56120 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56121 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56122 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56123 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56124 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56125 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56126 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56127 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56128 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56129 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56130 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56131 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56132 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56133 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56134 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56135 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56136 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56137 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56138 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56139 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56140 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56141 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56142 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56143 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56144 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56145 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56146 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56147 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56148 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56149 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56150 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56151 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56152 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56153 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56154 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56155 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56156 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56157 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56158 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56159 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56160 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56161 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56162 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56163 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56164 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56165 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56166 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56167 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56168 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56169 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56170 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56171 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56172 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56173 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56174 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56175 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56176 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56177 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56178 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56179 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56180 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56181 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56182 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56183 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56184 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56185 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56186 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56187 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56188 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56189 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56190 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56191 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56192 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56193 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56194 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56195 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56196 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56197 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56198 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56199 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56200 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56201 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56202 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56203 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56204 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56205 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56206 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56207 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56208 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56209 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56210 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56211 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56212 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56213 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56214 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56215 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56216 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56217 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56218 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56219 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56220 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56221 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56222 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56223 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56224 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56225 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56226 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56227 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56228 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56229 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56230
56231 // Initialize threading, some globals and such
56232 __wxPyPreStart(d);
56233
56234
56235 // Although these are defined in __version__ they need to be here too so
56236 // that an assert can be done to ensure that the wxPython and the wxWindows
56237 // versions match.
56238 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56239 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56240 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56241
56242 }
56243
wxWidgets (Impactor)