]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_DisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3844 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3845 #if wxUSE_HOTKEY
3846 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3847 #else
3848 return false;
3849 #endif
3850 }
3851 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3852
3853
3854
3855 return false;
3856
3857 }
3858 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3859 return wxPyGetWinHandle(self);
3860 }
3861 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3862 self->AssociateHandle((WXWidget)handle);
3863 }
3864 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3865
3866 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3867 return wxWindow::FindWindowById(id, parent);
3868 }
3869
3870 wxWindow* wxFindWindowByName( const wxString& name,
3871 const wxWindow *parent = NULL ) {
3872 return wxWindow::FindWindowByName(name, parent);
3873 }
3874
3875 wxWindow* wxFindWindowByLabel( const wxString& label,
3876 const wxWindow *parent = NULL ) {
3877 return wxWindow::FindWindowByLabel(label, parent);
3878 }
3879
3880
3881 #ifdef __WXMSW__
3882 #include <wx/msw/private.h> // to get wxGetWindowId
3883 #endif
3884
3885
3886 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3887 #ifdef __WXMSW__
3888 WXHWND hWnd = (WXHWND)_hWnd;
3889 long id = wxGetWindowId(hWnd);
3890 wxWindow* win = new wxWindow;
3891 if (parent)
3892 parent->AddChild(win);
3893 win->SetEventHandler(win);
3894 win->SetHWND(hWnd);
3895 win->SetId(id);
3896 win->SubclassWin(hWnd);
3897 win->AdoptAttributesFromHWND();
3898 win->SetupColours();
3899 return win;
3900 #else
3901 wxPyRaiseNotImplemented();
3902 return NULL;
3903 #endif
3904 }
3905
3906
3907 PyObject* GetTopLevelWindows() {
3908 return wxPy_ConvertList(&wxTopLevelWindows);
3909 }
3910
3911
3912 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3915
3916 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3917
3918
3919 SWIGINTERNINLINE int
3920 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3921 {
3922 unsigned long v;
3923 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3924 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3925 return res;
3926 }
3927
3928 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3929 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3930 wxMenuItemList& list = self->GetMenuItems();
3931 return wxPy_ConvertList(&list);
3932 }
3933 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3934 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3935 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3936 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3937 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3938 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3939 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3940 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3941 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3942 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3943 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3944 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3945 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3946 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3947 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3948 static const wxString wxPyControlNameStr(wxControlNameStr);
3949 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3950 if (clientData) {
3951 wxPyClientData* data = new wxPyClientData(clientData);
3952 return self->Append(item, data);
3953 } else
3954 return self->Append(item);
3955 }
3956 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3957 if (clientData) {
3958 wxPyClientData* data = new wxPyClientData(clientData);
3959 return self->Insert(item, pos, data);
3960 } else
3961 return self->Insert(item, pos);
3962 }
3963 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3964 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3965 if (data) {
3966 Py_INCREF(data->m_obj);
3967 return data->m_obj;
3968 } else {
3969 Py_INCREF(Py_None);
3970 return Py_None;
3971 }
3972 }
3973 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3974 wxPyClientData* data = new wxPyClientData(clientData);
3975 self->SetClientObject(n, data);
3976 }
3977
3978
3979 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3980 wxPyUserData* data = NULL;
3981 if ( userData ) {
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 data = new wxPyUserData(userData);
3984 wxPyEndBlockThreads(blocked);
3985 }
3986 return new wxSizerItem(window, proportion, flag, border, data);
3987 }
3988 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3989 wxPyUserData* data = NULL;
3990 if ( userData ) {
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 data = new wxPyUserData(userData);
3993 wxPyEndBlockThreads(blocked);
3994 }
3995 return new wxSizerItem(width, height, proportion, flag, border, data);
3996 }
3997 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3998 wxPyUserData* data = NULL;
3999 if ( userData ) {
4000 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4001 data = new wxPyUserData(userData);
4002 wxPyEndBlockThreads(blocked);
4003 }
4004 return new wxSizerItem(sizer, proportion, flag, border, data);
4005 }
4006
4007 SWIGINTERNINLINE PyObject *
4008 SWIG_From_float (float value)
4009 {
4010 return SWIG_From_double (value);
4011 }
4012
4013 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4014 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4015 if (data) {
4016 Py_INCREF(data->m_obj);
4017 return data->m_obj;
4018 } else {
4019 Py_INCREF(Py_None);
4020 return Py_None;
4021 }
4022 }
4023 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4024 wxPyUserData* data = NULL;
4025 if ( userData ) {
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 data = new wxPyUserData(userData);
4028 wxPyEndBlockThreads(blocked);
4029 }
4030 self->SetUserData(data);
4031 }
4032
4033 // Figure out the type of the sizer item
4034
4035 struct wxPySizerItemInfo {
4036 wxPySizerItemInfo()
4037 : window(NULL), sizer(NULL), gotSize(false),
4038 size(wxDefaultSize), gotPos(false), pos(-1)
4039 {}
4040
4041 wxWindow* window;
4042 wxSizer* sizer;
4043 bool gotSize;
4044 wxSize size;
4045 bool gotPos;
4046 int pos;
4047 };
4048
4049 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4050
4051 wxPySizerItemInfo info;
4052 wxSize size;
4053 wxSize* sizePtr = &size;
4054
4055 // Find out what the type of the item is
4056 // try wxWindow
4057 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4058 PyErr_Clear();
4059 info.window = NULL;
4060
4061 // try wxSizer
4062 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4063 PyErr_Clear();
4064 info.sizer = NULL;
4065
4066 // try wxSize or (w,h)
4067 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4068 info.size = *sizePtr;
4069 info.gotSize = true;
4070 }
4071
4072 // or a single int
4073 if (checkIdx && PyInt_Check(item)) {
4074 info.pos = PyInt_AsLong(item);
4075 info.gotPos = true;
4076 }
4077 }
4078 }
4079
4080 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4081 // no expected type, figure out what kind of error message to generate
4082 if ( !checkSize && !checkIdx )
4083 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4084 else if ( checkSize && !checkIdx )
4085 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4086 else if ( !checkSize && checkIdx)
4087 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4088 else
4089 // can this one happen?
4090 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4091 }
4092
4093 return info;
4094 }
4095
4096 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4097 if (!self->GetClientObject())
4098 self->SetClientObject(new wxPyOORClientData(_self));
4099 }
4100 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4101
4102 wxPyUserData* data = NULL;
4103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4104 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4105 if ( userData && (info.window || info.sizer || info.gotSize) )
4106 data = new wxPyUserData(userData);
4107 if ( info.sizer )
4108 PyObject_SetAttrString(item,"thisown",Py_False);
4109 wxPyEndBlockThreads(blocked);
4110
4111 // Now call the real Add method if a valid item type was found
4112 if ( info.window )
4113 return self->Add(info.window, proportion, flag, border, data);
4114 else if ( info.sizer )
4115 return self->Add(info.sizer, proportion, flag, border, data);
4116 else if (info.gotSize)
4117 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4118 proportion, flag, border, data);
4119 else
4120 return NULL;
4121 }
4122 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4123
4124 wxPyUserData* data = NULL;
4125 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4126 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4127 if ( userData && (info.window || info.sizer || info.gotSize) )
4128 data = new wxPyUserData(userData);
4129 if ( info.sizer )
4130 PyObject_SetAttrString(item,"thisown",Py_False);
4131 wxPyEndBlockThreads(blocked);
4132
4133 // Now call the real Insert method if a valid item type was found
4134 if ( info.window )
4135 return self->Insert(before, info.window, proportion, flag, border, data);
4136 else if ( info.sizer )
4137 return self->Insert(before, info.sizer, proportion, flag, border, data);
4138 else if (info.gotSize)
4139 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4140 proportion, flag, border, data);
4141 else
4142 return NULL;
4143 }
4144 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4145
4146 wxPyUserData* data = NULL;
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4149 if ( userData && (info.window || info.sizer || info.gotSize) )
4150 data = new wxPyUserData(userData);
4151 if ( info.sizer )
4152 PyObject_SetAttrString(item,"thisown",Py_False);
4153 wxPyEndBlockThreads(blocked);
4154
4155 // Now call the real Prepend method if a valid item type was found
4156 if ( info.window )
4157 return self->Prepend(info.window, proportion, flag, border, data);
4158 else if ( info.sizer )
4159 return self->Prepend(info.sizer, proportion, flag, border, data);
4160 else if (info.gotSize)
4161 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4162 proportion, flag, border, data);
4163 else
4164 return NULL;
4165 }
4166 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4168 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4169 wxPyEndBlockThreads(blocked);
4170 if ( info.window )
4171 return self->Remove(info.window);
4172 else if ( info.sizer )
4173 return self->Remove(info.sizer);
4174 else if ( info.gotPos )
4175 return self->Remove(info.pos);
4176 else
4177 return false;
4178 }
4179 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4182 wxPyEndBlockThreads(blocked);
4183 if ( info.window )
4184 return self->Detach(info.window);
4185 else if ( info.sizer )
4186 return self->Detach(info.sizer);
4187 else if ( info.gotPos )
4188 return self->Detach(info.pos);
4189 else
4190 return false;
4191 }
4192 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4194 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4195 wxPyEndBlockThreads(blocked);
4196 if ( info.window )
4197 return self->GetItem(info.window);
4198 else if ( info.sizer )
4199 return self->GetItem(info.sizer);
4200 else if ( info.gotPos )
4201 return self->GetItem(info.pos);
4202 else
4203 return NULL;
4204 }
4205 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 self->SetItemMinSize(info.window, size);
4211 else if ( info.sizer )
4212 self->SetItemMinSize(info.sizer, size);
4213 else if ( info.gotPos )
4214 self->SetItemMinSize(info.pos, size);
4215 }
4216 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4217 wxSizerItemList& list = self->GetChildren();
4218 return wxPy_ConvertList(&list);
4219 }
4220 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->Show(info.window, show, recursive);
4226 else if ( info.sizer )
4227 return self->Show(info.sizer, show, recursive);
4228 else if ( info.gotPos )
4229 return self->Show(info.pos, show);
4230 else
4231 return false;
4232 }
4233 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4235 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4236 wxPyEndBlockThreads(blocked);
4237 if ( info.window )
4238 return self->IsShown(info.window);
4239 else if ( info.sizer )
4240 return self->IsShown(info.sizer);
4241 else if ( info.gotPos )
4242 return self->IsShown(info.pos);
4243 else
4244 return false;
4245 }
4246
4247 // See pyclasses.h
4248 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4249 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4250 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4251
4252
4253
4254
4255 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4256 {
4257 if (source == Py_None) {
4258 **obj = wxGBPosition(-1,-1);
4259 return true;
4260 }
4261 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4262 }
4263
4264 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4265 {
4266 if (source == Py_None) {
4267 **obj = wxGBSpan(-1,-1);
4268 return true;
4269 }
4270 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4271 }
4272
4273
4274 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4275 wxGBPosition temp, *obj = &temp;
4276 if ( other == Py_None ) return false;
4277 if ( ! wxGBPosition_helper(other, &obj) ) {
4278 PyErr_Clear();
4279 return false;
4280 }
4281 return self->operator==(*obj);
4282 }
4283 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4284 wxGBPosition temp, *obj = &temp;
4285 if ( other == Py_None ) return true;
4286 if ( ! wxGBPosition_helper(other, &obj)) {
4287 PyErr_Clear();
4288 return true;
4289 }
4290 return self->operator!=(*obj);
4291 }
4292 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4293 self->SetRow(row);
4294 self->SetCol(col);
4295 }
4296 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4297 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4298 PyObject* tup = PyTuple_New(2);
4299 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4300 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4301 wxPyEndBlockThreads(blocked);
4302 return tup;
4303 }
4304 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4305 wxGBSpan temp, *obj = &temp;
4306 if ( other == Py_None ) return false;
4307 if ( ! wxGBSpan_helper(other, &obj) ) {
4308 PyErr_Clear();
4309 return false;
4310 }
4311 return self->operator==(*obj);
4312 }
4313 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4314 wxGBSpan temp, *obj = &temp;
4315 if ( other == Py_None ) return true;
4316 if ( ! wxGBSpan_helper(other, &obj)) {
4317 PyErr_Clear();
4318 return true;
4319 }
4320 return self->operator!=(*obj);
4321 }
4322 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4323 self->SetRowspan(rowspan);
4324 self->SetColspan(colspan);
4325 }
4326 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 PyObject* tup = PyTuple_New(2);
4329 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4330 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4331 wxPyEndBlockThreads(blocked);
4332 return tup;
4333 }
4334 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4335 wxPyUserData* data = NULL;
4336 if ( userData ) {
4337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4338 data = new wxPyUserData(userData);
4339 wxPyEndBlockThreads(blocked);
4340 }
4341 return new wxGBSizerItem(window, pos, span, flag, border, data);
4342 }
4343 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4344 wxPyUserData* data = NULL;
4345 if ( userData ) {
4346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4347 data = new wxPyUserData(userData);
4348 wxPyEndBlockThreads(blocked);
4349 }
4350 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4351 }
4352 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4353 wxPyUserData* data = NULL;
4354 if ( userData ) {
4355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4356 data = new wxPyUserData(userData);
4357 wxPyEndBlockThreads(blocked);
4358 }
4359 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4360 }
4361 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4362 int row, col;
4363 self->GetEndPos(row, col);
4364 return wxGBPosition(row, col);
4365 }
4366 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4367
4368 wxPyUserData* data = NULL;
4369 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4370 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4371 if ( userData && (info.window || info.sizer || info.gotSize) )
4372 data = new wxPyUserData(userData);
4373 if ( info.sizer )
4374 PyObject_SetAttrString(item,"thisown",Py_False);
4375 wxPyEndBlockThreads(blocked);
4376
4377 // Now call the real Add method if a valid item type was found
4378 if ( info.window )
4379 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4380 else if ( info.sizer )
4381 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4382 else if (info.gotSize)
4383 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4384 pos, span, flag, border, data);
4385 return NULL;
4386 }
4387
4388
4389 #ifdef __cplusplus
4390 extern "C" {
4391 #endif
4392 SWIGINTERN int EmptyString_set(PyObject *) {
4393 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4394 return 1;
4395 }
4396
4397
4398 SWIGINTERN PyObject *EmptyString_get(void) {
4399 PyObject *pyobj = 0;
4400
4401 {
4402 #if wxUSE_UNICODE
4403 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4404 #else
4405 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4406 #endif
4407 }
4408 return pyobj;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 PyObject *resultobj = 0;
4414 wxObject *arg1 = (wxObject *) 0 ;
4415 wxString result;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject *swig_obj[1] ;
4419
4420 if (!args) SWIG_fail;
4421 swig_obj[0] = args;
4422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4425 }
4426 arg1 = reinterpret_cast< wxObject * >(argp1);
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 result = wxObject_GetClassName(arg1);
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 {
4434 #if wxUSE_UNICODE
4435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4436 #else
4437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4438 #endif
4439 }
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447 PyObject *resultobj = 0;
4448 wxObject *arg1 = (wxObject *) 0 ;
4449 void *argp1 = 0 ;
4450 int res1 = 0 ;
4451 PyObject *swig_obj[1] ;
4452
4453 if (!args) SWIG_fail;
4454 swig_obj[0] = args;
4455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4456 if (!SWIG_IsOK(res1)) {
4457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4458 }
4459 arg1 = reinterpret_cast< wxObject * >(argp1);
4460 {
4461 PyThreadState* __tstate = wxPyBeginAllowThreads();
4462 wxObject_Destroy(arg1);
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 resultobj = SWIG_Py_Void();
4467 return resultobj;
4468 fail:
4469 return NULL;
4470 }
4471
4472
4473 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4474 PyObject *obj;
4475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4476 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4477 return SWIG_Py_Void();
4478 }
4479
4480 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *resultobj = 0;
4482 wxSize *arg1 = (wxSize *) 0 ;
4483 int arg2 ;
4484 void *argp1 = 0 ;
4485 int res1 = 0 ;
4486 int val2 ;
4487 int ecode2 = 0 ;
4488 PyObject *swig_obj[2] ;
4489
4490 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4492 if (!SWIG_IsOK(res1)) {
4493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4494 }
4495 arg1 = reinterpret_cast< wxSize * >(argp1);
4496 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4497 if (!SWIG_IsOK(ecode2)) {
4498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4499 }
4500 arg2 = static_cast< int >(val2);
4501 if (arg1) (arg1)->x = arg2;
4502
4503 resultobj = SWIG_Py_Void();
4504 return resultobj;
4505 fail:
4506 return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4511 PyObject *resultobj = 0;
4512 wxSize *arg1 = (wxSize *) 0 ;
4513 int result;
4514 void *argp1 = 0 ;
4515 int res1 = 0 ;
4516 PyObject *swig_obj[1] ;
4517
4518 if (!args) SWIG_fail;
4519 swig_obj[0] = args;
4520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4521 if (!SWIG_IsOK(res1)) {
4522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4523 }
4524 arg1 = reinterpret_cast< wxSize * >(argp1);
4525 result = (int) ((arg1)->x);
4526 resultobj = SWIG_From_int(static_cast< int >(result));
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4534 PyObject *resultobj = 0;
4535 wxSize *arg1 = (wxSize *) 0 ;
4536 int arg2 ;
4537 void *argp1 = 0 ;
4538 int res1 = 0 ;
4539 int val2 ;
4540 int ecode2 = 0 ;
4541 PyObject *swig_obj[2] ;
4542
4543 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4545 if (!SWIG_IsOK(res1)) {
4546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4547 }
4548 arg1 = reinterpret_cast< wxSize * >(argp1);
4549 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4550 if (!SWIG_IsOK(ecode2)) {
4551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4552 }
4553 arg2 = static_cast< int >(val2);
4554 if (arg1) (arg1)->y = arg2;
4555
4556 resultobj = SWIG_Py_Void();
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4564 PyObject *resultobj = 0;
4565 wxSize *arg1 = (wxSize *) 0 ;
4566 int result;
4567 void *argp1 = 0 ;
4568 int res1 = 0 ;
4569 PyObject *swig_obj[1] ;
4570
4571 if (!args) SWIG_fail;
4572 swig_obj[0] = args;
4573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4574 if (!SWIG_IsOK(res1)) {
4575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4576 }
4577 arg1 = reinterpret_cast< wxSize * >(argp1);
4578 result = (int) ((arg1)->y);
4579 resultobj = SWIG_From_int(static_cast< int >(result));
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj = 0;
4588 int arg1 = (int) 0 ;
4589 int arg2 = (int) 0 ;
4590 wxSize *result = 0 ;
4591 int val1 ;
4592 int ecode1 = 0 ;
4593 int val2 ;
4594 int ecode2 = 0 ;
4595 PyObject * obj0 = 0 ;
4596 PyObject * obj1 = 0 ;
4597 char * kwnames[] = {
4598 (char *) "w",(char *) "h", NULL
4599 };
4600
4601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4602 if (obj0) {
4603 ecode1 = SWIG_AsVal_int(obj0, &val1);
4604 if (!SWIG_IsOK(ecode1)) {
4605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4606 }
4607 arg1 = static_cast< int >(val1);
4608 }
4609 if (obj1) {
4610 ecode2 = SWIG_AsVal_int(obj1, &val2);
4611 if (!SWIG_IsOK(ecode2)) {
4612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4613 }
4614 arg2 = static_cast< int >(val2);
4615 }
4616 {
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 result = (wxSize *)new wxSize(arg1,arg2);
4619 wxPyEndAllowThreads(__tstate);
4620 if (PyErr_Occurred()) SWIG_fail;
4621 }
4622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4623 return resultobj;
4624 fail:
4625 return NULL;
4626 }
4627
4628
4629 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4630 PyObject *resultobj = 0;
4631 wxSize *arg1 = (wxSize *) 0 ;
4632 void *argp1 = 0 ;
4633 int res1 = 0 ;
4634 PyObject *swig_obj[1] ;
4635
4636 if (!args) SWIG_fail;
4637 swig_obj[0] = args;
4638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4641 }
4642 arg1 = reinterpret_cast< wxSize * >(argp1);
4643 {
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 delete arg1;
4646
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 wxSize *arg1 = (wxSize *) 0 ;
4660 PyObject *arg2 = (PyObject *) 0 ;
4661 bool result;
4662 void *argp1 = 0 ;
4663 int res1 = 0 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "self",(char *) "other", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4672 if (!SWIG_IsOK(res1)) {
4673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4674 }
4675 arg1 = reinterpret_cast< wxSize * >(argp1);
4676 arg2 = obj1;
4677 {
4678 result = (bool)wxSize___eq__(arg1,arg2);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 {
4682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4683 }
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4691 PyObject *resultobj = 0;
4692 wxSize *arg1 = (wxSize *) 0 ;
4693 PyObject *arg2 = (PyObject *) 0 ;
4694 bool result;
4695 void *argp1 = 0 ;
4696 int res1 = 0 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char * kwnames[] = {
4700 (char *) "self",(char *) "other", NULL
4701 };
4702
4703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4705 if (!SWIG_IsOK(res1)) {
4706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4707 }
4708 arg1 = reinterpret_cast< wxSize * >(argp1);
4709 arg2 = obj1;
4710 {
4711 result = (bool)wxSize___ne__(arg1,arg2);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 {
4715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4716 }
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj = 0;
4725 wxSize *arg1 = (wxSize *) 0 ;
4726 wxSize *arg2 = 0 ;
4727 wxSize result;
4728 void *argp1 = 0 ;
4729 int res1 = 0 ;
4730 wxSize temp2 ;
4731 PyObject * obj0 = 0 ;
4732 PyObject * obj1 = 0 ;
4733 char * kwnames[] = {
4734 (char *) "self",(char *) "sz", NULL
4735 };
4736
4737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4739 if (!SWIG_IsOK(res1)) {
4740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4741 }
4742 arg1 = reinterpret_cast< wxSize * >(argp1);
4743 {
4744 arg2 = &temp2;
4745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4746 }
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (arg1)->operator +((wxSize const &)*arg2);
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj = 0;
4762 wxSize *arg1 = (wxSize *) 0 ;
4763 wxSize *arg2 = 0 ;
4764 wxSize result;
4765 void *argp1 = 0 ;
4766 int res1 = 0 ;
4767 wxSize temp2 ;
4768 PyObject * obj0 = 0 ;
4769 PyObject * obj1 = 0 ;
4770 char * kwnames[] = {
4771 (char *) "self",(char *) "sz", NULL
4772 };
4773
4774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4776 if (!SWIG_IsOK(res1)) {
4777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4778 }
4779 arg1 = reinterpret_cast< wxSize * >(argp1);
4780 {
4781 arg2 = &temp2;
4782 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4783 }
4784 {
4785 PyThreadState* __tstate = wxPyBeginAllowThreads();
4786 result = (arg1)->operator -((wxSize const &)*arg2);
4787 wxPyEndAllowThreads(__tstate);
4788 if (PyErr_Occurred()) SWIG_fail;
4789 }
4790 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4791 return resultobj;
4792 fail:
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj = 0;
4799 wxSize *arg1 = (wxSize *) 0 ;
4800 wxSize *arg2 = 0 ;
4801 void *argp1 = 0 ;
4802 int res1 = 0 ;
4803 wxSize temp2 ;
4804 PyObject * obj0 = 0 ;
4805 PyObject * obj1 = 0 ;
4806 char * kwnames[] = {
4807 (char *) "self",(char *) "sz", NULL
4808 };
4809
4810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4812 if (!SWIG_IsOK(res1)) {
4813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4814 }
4815 arg1 = reinterpret_cast< wxSize * >(argp1);
4816 {
4817 arg2 = &temp2;
4818 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4819 }
4820 {
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 (arg1)->IncTo((wxSize const &)*arg2);
4823 wxPyEndAllowThreads(__tstate);
4824 if (PyErr_Occurred()) SWIG_fail;
4825 }
4826 resultobj = SWIG_Py_Void();
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4834 PyObject *resultobj = 0;
4835 wxSize *arg1 = (wxSize *) 0 ;
4836 wxSize *arg2 = 0 ;
4837 void *argp1 = 0 ;
4838 int res1 = 0 ;
4839 wxSize temp2 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char * kwnames[] = {
4843 (char *) "self",(char *) "sz", NULL
4844 };
4845
4846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4848 if (!SWIG_IsOK(res1)) {
4849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4850 }
4851 arg1 = reinterpret_cast< wxSize * >(argp1);
4852 {
4853 arg2 = &temp2;
4854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4855 }
4856 {
4857 PyThreadState* __tstate = wxPyBeginAllowThreads();
4858 (arg1)->DecTo((wxSize const &)*arg2);
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 resultobj = SWIG_Py_Void();
4863 return resultobj;
4864 fail:
4865 return NULL;
4866 }
4867
4868
4869 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj = 0;
4871 wxSize *arg1 = (wxSize *) 0 ;
4872 float arg2 ;
4873 float arg3 ;
4874 void *argp1 = 0 ;
4875 int res1 = 0 ;
4876 float val2 ;
4877 int ecode2 = 0 ;
4878 float val3 ;
4879 int ecode3 = 0 ;
4880 PyObject * obj0 = 0 ;
4881 PyObject * obj1 = 0 ;
4882 PyObject * obj2 = 0 ;
4883 char * kwnames[] = {
4884 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4885 };
4886
4887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4889 if (!SWIG_IsOK(res1)) {
4890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4891 }
4892 arg1 = reinterpret_cast< wxSize * >(argp1);
4893 ecode2 = SWIG_AsVal_float(obj1, &val2);
4894 if (!SWIG_IsOK(ecode2)) {
4895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4896 }
4897 arg2 = static_cast< float >(val2);
4898 ecode3 = SWIG_AsVal_float(obj2, &val3);
4899 if (!SWIG_IsOK(ecode3)) {
4900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4901 }
4902 arg3 = static_cast< float >(val3);
4903 {
4904 PyThreadState* __tstate = wxPyBeginAllowThreads();
4905 (arg1)->Scale(arg2,arg3);
4906 wxPyEndAllowThreads(__tstate);
4907 if (PyErr_Occurred()) SWIG_fail;
4908 }
4909 resultobj = SWIG_Py_Void();
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj = 0;
4918 wxSize *arg1 = (wxSize *) 0 ;
4919 int arg2 ;
4920 int arg3 ;
4921 void *argp1 = 0 ;
4922 int res1 = 0 ;
4923 int val2 ;
4924 int ecode2 = 0 ;
4925 int val3 ;
4926 int ecode3 = 0 ;
4927 PyObject * obj0 = 0 ;
4928 PyObject * obj1 = 0 ;
4929 PyObject * obj2 = 0 ;
4930 char * kwnames[] = {
4931 (char *) "self",(char *) "w",(char *) "h", NULL
4932 };
4933
4934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4936 if (!SWIG_IsOK(res1)) {
4937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4938 }
4939 arg1 = reinterpret_cast< wxSize * >(argp1);
4940 ecode2 = SWIG_AsVal_int(obj1, &val2);
4941 if (!SWIG_IsOK(ecode2)) {
4942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4943 }
4944 arg2 = static_cast< int >(val2);
4945 ecode3 = SWIG_AsVal_int(obj2, &val3);
4946 if (!SWIG_IsOK(ecode3)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4948 }
4949 arg3 = static_cast< int >(val3);
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 (arg1)->Set(arg2,arg3);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_Py_Void();
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4964 PyObject *resultobj = 0;
4965 wxSize *arg1 = (wxSize *) 0 ;
4966 int arg2 ;
4967 void *argp1 = 0 ;
4968 int res1 = 0 ;
4969 int val2 ;
4970 int ecode2 = 0 ;
4971 PyObject * obj0 = 0 ;
4972 PyObject * obj1 = 0 ;
4973 char * kwnames[] = {
4974 (char *) "self",(char *) "w", NULL
4975 };
4976
4977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4979 if (!SWIG_IsOK(res1)) {
4980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4981 }
4982 arg1 = reinterpret_cast< wxSize * >(argp1);
4983 ecode2 = SWIG_AsVal_int(obj1, &val2);
4984 if (!SWIG_IsOK(ecode2)) {
4985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4986 }
4987 arg2 = static_cast< int >(val2);
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 (arg1)->SetWidth(arg2);
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 resultobj = SWIG_Py_Void();
4995 return resultobj;
4996 fail:
4997 return NULL;
4998 }
4999
5000
5001 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5002 PyObject *resultobj = 0;
5003 wxSize *arg1 = (wxSize *) 0 ;
5004 int arg2 ;
5005 void *argp1 = 0 ;
5006 int res1 = 0 ;
5007 int val2 ;
5008 int ecode2 = 0 ;
5009 PyObject * obj0 = 0 ;
5010 PyObject * obj1 = 0 ;
5011 char * kwnames[] = {
5012 (char *) "self",(char *) "h", NULL
5013 };
5014
5015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5017 if (!SWIG_IsOK(res1)) {
5018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5019 }
5020 arg1 = reinterpret_cast< wxSize * >(argp1);
5021 ecode2 = SWIG_AsVal_int(obj1, &val2);
5022 if (!SWIG_IsOK(ecode2)) {
5023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5024 }
5025 arg2 = static_cast< int >(val2);
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 (arg1)->SetHeight(arg2);
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 resultobj = SWIG_Py_Void();
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5040 PyObject *resultobj = 0;
5041 wxSize *arg1 = (wxSize *) 0 ;
5042 int result;
5043 void *argp1 = 0 ;
5044 int res1 = 0 ;
5045 PyObject *swig_obj[1] ;
5046
5047 if (!args) SWIG_fail;
5048 swig_obj[0] = args;
5049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5050 if (!SWIG_IsOK(res1)) {
5051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5052 }
5053 arg1 = reinterpret_cast< wxSize * >(argp1);
5054 {
5055 PyThreadState* __tstate = wxPyBeginAllowThreads();
5056 result = (int)((wxSize const *)arg1)->GetWidth();
5057 wxPyEndAllowThreads(__tstate);
5058 if (PyErr_Occurred()) SWIG_fail;
5059 }
5060 resultobj = SWIG_From_int(static_cast< int >(result));
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5068 PyObject *resultobj = 0;
5069 wxSize *arg1 = (wxSize *) 0 ;
5070 int result;
5071 void *argp1 = 0 ;
5072 int res1 = 0 ;
5073 PyObject *swig_obj[1] ;
5074
5075 if (!args) SWIG_fail;
5076 swig_obj[0] = args;
5077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5078 if (!SWIG_IsOK(res1)) {
5079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5080 }
5081 arg1 = reinterpret_cast< wxSize * >(argp1);
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 result = (int)((wxSize const *)arg1)->GetHeight();
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 resultobj = SWIG_From_int(static_cast< int >(result));
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5096 PyObject *resultobj = 0;
5097 wxSize *arg1 = (wxSize *) 0 ;
5098 bool result;
5099 void *argp1 = 0 ;
5100 int res1 = 0 ;
5101 PyObject *swig_obj[1] ;
5102
5103 if (!args) SWIG_fail;
5104 swig_obj[0] = args;
5105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5106 if (!SWIG_IsOK(res1)) {
5107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5108 }
5109 arg1 = reinterpret_cast< wxSize * >(argp1);
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5118 }
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj = 0;
5127 wxSize *arg1 = (wxSize *) 0 ;
5128 wxSize *arg2 = 0 ;
5129 void *argp1 = 0 ;
5130 int res1 = 0 ;
5131 wxSize temp2 ;
5132 PyObject * obj0 = 0 ;
5133 PyObject * obj1 = 0 ;
5134 char * kwnames[] = {
5135 (char *) "self",(char *) "size", NULL
5136 };
5137
5138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5140 if (!SWIG_IsOK(res1)) {
5141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5142 }
5143 arg1 = reinterpret_cast< wxSize * >(argp1);
5144 {
5145 arg2 = &temp2;
5146 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5147 }
5148 {
5149 PyThreadState* __tstate = wxPyBeginAllowThreads();
5150 (arg1)->SetDefaults((wxSize const &)*arg2);
5151 wxPyEndAllowThreads(__tstate);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_Py_Void();
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162 PyObject *resultobj = 0;
5163 wxSize *arg1 = (wxSize *) 0 ;
5164 PyObject *result = 0 ;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 PyObject *swig_obj[1] ;
5168
5169 if (!args) SWIG_fail;
5170 swig_obj[0] = args;
5171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5172 if (!SWIG_IsOK(res1)) {
5173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5174 }
5175 arg1 = reinterpret_cast< wxSize * >(argp1);
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 result = (PyObject *)wxSize_Get(arg1);
5179 wxPyEndAllowThreads(__tstate);
5180 if (PyErr_Occurred()) SWIG_fail;
5181 }
5182 resultobj = result;
5183 return resultobj;
5184 fail:
5185 return NULL;
5186 }
5187
5188
5189 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5190 PyObject *obj;
5191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5192 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5193 return SWIG_Py_Void();
5194 }
5195
5196 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5197 return SWIG_Python_InitShadowInstance(args);
5198 }
5199
5200 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5201 PyObject *resultobj = 0;
5202 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5203 double arg2 ;
5204 void *argp1 = 0 ;
5205 int res1 = 0 ;
5206 double val2 ;
5207 int ecode2 = 0 ;
5208 PyObject *swig_obj[2] ;
5209
5210 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5212 if (!SWIG_IsOK(res1)) {
5213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5214 }
5215 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5216 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5217 if (!SWIG_IsOK(ecode2)) {
5218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5219 }
5220 arg2 = static_cast< double >(val2);
5221 if (arg1) (arg1)->x = arg2;
5222
5223 resultobj = SWIG_Py_Void();
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5231 PyObject *resultobj = 0;
5232 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5233 double result;
5234 void *argp1 = 0 ;
5235 int res1 = 0 ;
5236 PyObject *swig_obj[1] ;
5237
5238 if (!args) SWIG_fail;
5239 swig_obj[0] = args;
5240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5241 if (!SWIG_IsOK(res1)) {
5242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5243 }
5244 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5245 result = (double) ((arg1)->x);
5246 resultobj = SWIG_From_double(static_cast< double >(result));
5247 return resultobj;
5248 fail:
5249 return NULL;
5250 }
5251
5252
5253 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5254 PyObject *resultobj = 0;
5255 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5256 double arg2 ;
5257 void *argp1 = 0 ;
5258 int res1 = 0 ;
5259 double val2 ;
5260 int ecode2 = 0 ;
5261 PyObject *swig_obj[2] ;
5262
5263 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5265 if (!SWIG_IsOK(res1)) {
5266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5267 }
5268 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5269 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5270 if (!SWIG_IsOK(ecode2)) {
5271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5272 }
5273 arg2 = static_cast< double >(val2);
5274 if (arg1) (arg1)->y = arg2;
5275
5276 resultobj = SWIG_Py_Void();
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5284 PyObject *resultobj = 0;
5285 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5286 double result;
5287 void *argp1 = 0 ;
5288 int res1 = 0 ;
5289 PyObject *swig_obj[1] ;
5290
5291 if (!args) SWIG_fail;
5292 swig_obj[0] = args;
5293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5294 if (!SWIG_IsOK(res1)) {
5295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5296 }
5297 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5298 result = (double) ((arg1)->y);
5299 resultobj = SWIG_From_double(static_cast< double >(result));
5300 return resultobj;
5301 fail:
5302 return NULL;
5303 }
5304
5305
5306 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5307 PyObject *resultobj = 0;
5308 double arg1 = (double) 0.0 ;
5309 double arg2 = (double) 0.0 ;
5310 wxRealPoint *result = 0 ;
5311 double val1 ;
5312 int ecode1 = 0 ;
5313 double val2 ;
5314 int ecode2 = 0 ;
5315 PyObject * obj0 = 0 ;
5316 PyObject * obj1 = 0 ;
5317 char * kwnames[] = {
5318 (char *) "x",(char *) "y", NULL
5319 };
5320
5321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5322 if (obj0) {
5323 ecode1 = SWIG_AsVal_double(obj0, &val1);
5324 if (!SWIG_IsOK(ecode1)) {
5325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5326 }
5327 arg1 = static_cast< double >(val1);
5328 }
5329 if (obj1) {
5330 ecode2 = SWIG_AsVal_double(obj1, &val2);
5331 if (!SWIG_IsOK(ecode2)) {
5332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5333 }
5334 arg2 = static_cast< double >(val2);
5335 }
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 void *argp1 = 0 ;
5353 int res1 = 0 ;
5354 PyObject *swig_obj[1] ;
5355
5356 if (!args) SWIG_fail;
5357 swig_obj[0] = args;
5358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5359 if (!SWIG_IsOK(res1)) {
5360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5361 }
5362 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5363 {
5364 PyThreadState* __tstate = wxPyBeginAllowThreads();
5365 delete arg1;
5366
5367 wxPyEndAllowThreads(__tstate);
5368 if (PyErr_Occurred()) SWIG_fail;
5369 }
5370 resultobj = SWIG_Py_Void();
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
5377 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5378 PyObject *resultobj = 0;
5379 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5380 PyObject *arg2 = (PyObject *) 0 ;
5381 bool result;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 PyObject * obj0 = 0 ;
5385 PyObject * obj1 = 0 ;
5386 char * kwnames[] = {
5387 (char *) "self",(char *) "other", NULL
5388 };
5389
5390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5392 if (!SWIG_IsOK(res1)) {
5393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5394 }
5395 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5396 arg2 = obj1;
5397 {
5398 result = (bool)wxRealPoint___eq__(arg1,arg2);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 {
5402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5403 }
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj = 0;
5412 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5413 PyObject *arg2 = (PyObject *) 0 ;
5414 bool result;
5415 void *argp1 = 0 ;
5416 int res1 = 0 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char * kwnames[] = {
5420 (char *) "self",(char *) "other", NULL
5421 };
5422
5423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5425 if (!SWIG_IsOK(res1)) {
5426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5427 }
5428 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5429 arg2 = obj1;
5430 {
5431 result = (bool)wxRealPoint___ne__(arg1,arg2);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 {
5435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5436 }
5437 return resultobj;
5438 fail:
5439 return NULL;
5440 }
5441
5442
5443 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5444 PyObject *resultobj = 0;
5445 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5446 wxRealPoint *arg2 = 0 ;
5447 wxRealPoint result;
5448 void *argp1 = 0 ;
5449 int res1 = 0 ;
5450 wxRealPoint temp2 ;
5451 PyObject * obj0 = 0 ;
5452 PyObject * obj1 = 0 ;
5453 char * kwnames[] = {
5454 (char *) "self",(char *) "pt", NULL
5455 };
5456
5457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5459 if (!SWIG_IsOK(res1)) {
5460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5461 }
5462 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5463 {
5464 arg2 = &temp2;
5465 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5466 }
5467 {
5468 PyThreadState* __tstate = wxPyBeginAllowThreads();
5469 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj = 0;
5482 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5483 wxRealPoint *arg2 = 0 ;
5484 wxRealPoint result;
5485 void *argp1 = 0 ;
5486 int res1 = 0 ;
5487 wxRealPoint temp2 ;
5488 PyObject * obj0 = 0 ;
5489 PyObject * obj1 = 0 ;
5490 char * kwnames[] = {
5491 (char *) "self",(char *) "pt", NULL
5492 };
5493
5494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5496 if (!SWIG_IsOK(res1)) {
5497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5498 }
5499 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5500 {
5501 arg2 = &temp2;
5502 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5503 }
5504 {
5505 PyThreadState* __tstate = wxPyBeginAllowThreads();
5506 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5507 wxPyEndAllowThreads(__tstate);
5508 if (PyErr_Occurred()) SWIG_fail;
5509 }
5510 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj = 0;
5519 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5520 double arg2 ;
5521 double arg3 ;
5522 void *argp1 = 0 ;
5523 int res1 = 0 ;
5524 double val2 ;
5525 int ecode2 = 0 ;
5526 double val3 ;
5527 int ecode3 = 0 ;
5528 PyObject * obj0 = 0 ;
5529 PyObject * obj1 = 0 ;
5530 PyObject * obj2 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "self",(char *) "x",(char *) "y", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5541 ecode2 = SWIG_AsVal_double(obj1, &val2);
5542 if (!SWIG_IsOK(ecode2)) {
5543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5544 }
5545 arg2 = static_cast< double >(val2);
5546 ecode3 = SWIG_AsVal_double(obj2, &val3);
5547 if (!SWIG_IsOK(ecode3)) {
5548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5549 }
5550 arg3 = static_cast< double >(val3);
5551 {
5552 PyThreadState* __tstate = wxPyBeginAllowThreads();
5553 wxRealPoint_Set(arg1,arg2,arg3);
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 resultobj = SWIG_Py_Void();
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5565 PyObject *resultobj = 0;
5566 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5567 PyObject *result = 0 ;
5568 void *argp1 = 0 ;
5569 int res1 = 0 ;
5570 PyObject *swig_obj[1] ;
5571
5572 if (!args) SWIG_fail;
5573 swig_obj[0] = args;
5574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5575 if (!SWIG_IsOK(res1)) {
5576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5577 }
5578 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (PyObject *)wxRealPoint_Get(arg1);
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = result;
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *obj;
5594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5595 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5596 return SWIG_Py_Void();
5597 }
5598
5599 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5600 return SWIG_Python_InitShadowInstance(args);
5601 }
5602
5603 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5604 PyObject *resultobj = 0;
5605 wxPoint *arg1 = (wxPoint *) 0 ;
5606 int arg2 ;
5607 void *argp1 = 0 ;
5608 int res1 = 0 ;
5609 int val2 ;
5610 int ecode2 = 0 ;
5611 PyObject *swig_obj[2] ;
5612
5613 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5615 if (!SWIG_IsOK(res1)) {
5616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5617 }
5618 arg1 = reinterpret_cast< wxPoint * >(argp1);
5619 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5620 if (!SWIG_IsOK(ecode2)) {
5621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5622 }
5623 arg2 = static_cast< int >(val2);
5624 if (arg1) (arg1)->x = arg2;
5625
5626 resultobj = SWIG_Py_Void();
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5634 PyObject *resultobj = 0;
5635 wxPoint *arg1 = (wxPoint *) 0 ;
5636 int result;
5637 void *argp1 = 0 ;
5638 int res1 = 0 ;
5639 PyObject *swig_obj[1] ;
5640
5641 if (!args) SWIG_fail;
5642 swig_obj[0] = args;
5643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5644 if (!SWIG_IsOK(res1)) {
5645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5646 }
5647 arg1 = reinterpret_cast< wxPoint * >(argp1);
5648 result = (int) ((arg1)->x);
5649 resultobj = SWIG_From_int(static_cast< int >(result));
5650 return resultobj;
5651 fail:
5652 return NULL;
5653 }
5654
5655
5656 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5657 PyObject *resultobj = 0;
5658 wxPoint *arg1 = (wxPoint *) 0 ;
5659 int arg2 ;
5660 void *argp1 = 0 ;
5661 int res1 = 0 ;
5662 int val2 ;
5663 int ecode2 = 0 ;
5664 PyObject *swig_obj[2] ;
5665
5666 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5668 if (!SWIG_IsOK(res1)) {
5669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5670 }
5671 arg1 = reinterpret_cast< wxPoint * >(argp1);
5672 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5673 if (!SWIG_IsOK(ecode2)) {
5674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5675 }
5676 arg2 = static_cast< int >(val2);
5677 if (arg1) (arg1)->y = arg2;
5678
5679 resultobj = SWIG_Py_Void();
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5687 PyObject *resultobj = 0;
5688 wxPoint *arg1 = (wxPoint *) 0 ;
5689 int result;
5690 void *argp1 = 0 ;
5691 int res1 = 0 ;
5692 PyObject *swig_obj[1] ;
5693
5694 if (!args) SWIG_fail;
5695 swig_obj[0] = args;
5696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5697 if (!SWIG_IsOK(res1)) {
5698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5699 }
5700 arg1 = reinterpret_cast< wxPoint * >(argp1);
5701 result = (int) ((arg1)->y);
5702 resultobj = SWIG_From_int(static_cast< int >(result));
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj = 0;
5711 int arg1 = (int) 0 ;
5712 int arg2 = (int) 0 ;
5713 wxPoint *result = 0 ;
5714 int val1 ;
5715 int ecode1 = 0 ;
5716 int val2 ;
5717 int ecode2 = 0 ;
5718 PyObject * obj0 = 0 ;
5719 PyObject * obj1 = 0 ;
5720 char * kwnames[] = {
5721 (char *) "x",(char *) "y", NULL
5722 };
5723
5724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5725 if (obj0) {
5726 ecode1 = SWIG_AsVal_int(obj0, &val1);
5727 if (!SWIG_IsOK(ecode1)) {
5728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5729 }
5730 arg1 = static_cast< int >(val1);
5731 }
5732 if (obj1) {
5733 ecode2 = SWIG_AsVal_int(obj1, &val2);
5734 if (!SWIG_IsOK(ecode2)) {
5735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5736 }
5737 arg2 = static_cast< int >(val2);
5738 }
5739 {
5740 PyThreadState* __tstate = wxPyBeginAllowThreads();
5741 result = (wxPoint *)new wxPoint(arg1,arg2);
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 void *argp1 = 0 ;
5756 int res1 = 0 ;
5757 PyObject *swig_obj[1] ;
5758
5759 if (!args) SWIG_fail;
5760 swig_obj[0] = args;
5761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5762 if (!SWIG_IsOK(res1)) {
5763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5764 }
5765 arg1 = reinterpret_cast< wxPoint * >(argp1);
5766 {
5767 PyThreadState* __tstate = wxPyBeginAllowThreads();
5768 delete arg1;
5769
5770 wxPyEndAllowThreads(__tstate);
5771 if (PyErr_Occurred()) SWIG_fail;
5772 }
5773 resultobj = SWIG_Py_Void();
5774 return resultobj;
5775 fail:
5776 return NULL;
5777 }
5778
5779
5780 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5781 PyObject *resultobj = 0;
5782 wxPoint *arg1 = (wxPoint *) 0 ;
5783 PyObject *arg2 = (PyObject *) 0 ;
5784 bool result;
5785 void *argp1 = 0 ;
5786 int res1 = 0 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "self",(char *) "other", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5795 if (!SWIG_IsOK(res1)) {
5796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5797 }
5798 arg1 = reinterpret_cast< wxPoint * >(argp1);
5799 arg2 = obj1;
5800 {
5801 result = (bool)wxPoint___eq__(arg1,arg2);
5802 if (PyErr_Occurred()) SWIG_fail;
5803 }
5804 {
5805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5806 }
5807 return resultobj;
5808 fail:
5809 return NULL;
5810 }
5811
5812
5813 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5814 PyObject *resultobj = 0;
5815 wxPoint *arg1 = (wxPoint *) 0 ;
5816 PyObject *arg2 = (PyObject *) 0 ;
5817 bool result;
5818 void *argp1 = 0 ;
5819 int res1 = 0 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char * kwnames[] = {
5823 (char *) "self",(char *) "other", NULL
5824 };
5825
5826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5828 if (!SWIG_IsOK(res1)) {
5829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5830 }
5831 arg1 = reinterpret_cast< wxPoint * >(argp1);
5832 arg2 = obj1;
5833 {
5834 result = (bool)wxPoint___ne__(arg1,arg2);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5839 }
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 wxPoint *arg1 = (wxPoint *) 0 ;
5849 wxPoint *arg2 = 0 ;
5850 wxPoint result;
5851 void *argp1 = 0 ;
5852 int res1 = 0 ;
5853 wxPoint temp2 ;
5854 PyObject * obj0 = 0 ;
5855 PyObject * obj1 = 0 ;
5856 char * kwnames[] = {
5857 (char *) "self",(char *) "pt", NULL
5858 };
5859
5860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5862 if (!SWIG_IsOK(res1)) {
5863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5864 }
5865 arg1 = reinterpret_cast< wxPoint * >(argp1);
5866 {
5867 arg2 = &temp2;
5868 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5869 }
5870 {
5871 PyThreadState* __tstate = wxPyBeginAllowThreads();
5872 result = (arg1)->operator +((wxPoint const &)*arg2);
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj = 0;
5885 wxPoint *arg1 = (wxPoint *) 0 ;
5886 wxPoint *arg2 = 0 ;
5887 wxPoint result;
5888 void *argp1 = 0 ;
5889 int res1 = 0 ;
5890 wxPoint temp2 ;
5891 PyObject * obj0 = 0 ;
5892 PyObject * obj1 = 0 ;
5893 char * kwnames[] = {
5894 (char *) "self",(char *) "pt", NULL
5895 };
5896
5897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5899 if (!SWIG_IsOK(res1)) {
5900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5901 }
5902 arg1 = reinterpret_cast< wxPoint * >(argp1);
5903 {
5904 arg2 = &temp2;
5905 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5906 }
5907 {
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 result = (arg1)->operator -((wxPoint const &)*arg2);
5910 wxPyEndAllowThreads(__tstate);
5911 if (PyErr_Occurred()) SWIG_fail;
5912 }
5913 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj = 0;
5922 wxPoint *arg1 = (wxPoint *) 0 ;
5923 wxPoint *arg2 = 0 ;
5924 wxPoint *result = 0 ;
5925 void *argp1 = 0 ;
5926 int res1 = 0 ;
5927 wxPoint temp2 ;
5928 PyObject * obj0 = 0 ;
5929 PyObject * obj1 = 0 ;
5930 char * kwnames[] = {
5931 (char *) "self",(char *) "pt", NULL
5932 };
5933
5934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5936 if (!SWIG_IsOK(res1)) {
5937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5938 }
5939 arg1 = reinterpret_cast< wxPoint * >(argp1);
5940 {
5941 arg2 = &temp2;
5942 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5943 }
5944 {
5945 PyThreadState* __tstate = wxPyBeginAllowThreads();
5946 {
5947 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5948 result = (wxPoint *) &_result_ref;
5949 }
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5961 PyObject *resultobj = 0;
5962 wxPoint *arg1 = (wxPoint *) 0 ;
5963 wxPoint *arg2 = 0 ;
5964 wxPoint *result = 0 ;
5965 void *argp1 = 0 ;
5966 int res1 = 0 ;
5967 wxPoint temp2 ;
5968 PyObject * obj0 = 0 ;
5969 PyObject * obj1 = 0 ;
5970 char * kwnames[] = {
5971 (char *) "self",(char *) "pt", NULL
5972 };
5973
5974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5976 if (!SWIG_IsOK(res1)) {
5977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5978 }
5979 arg1 = reinterpret_cast< wxPoint * >(argp1);
5980 {
5981 arg2 = &temp2;
5982 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5983 }
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 {
5987 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5988 result = (wxPoint *) &_result_ref;
5989 }
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj = 0;
6002 wxPoint *arg1 = (wxPoint *) 0 ;
6003 long arg2 ;
6004 long arg3 ;
6005 void *argp1 = 0 ;
6006 int res1 = 0 ;
6007 long val2 ;
6008 int ecode2 = 0 ;
6009 long val3 ;
6010 int ecode3 = 0 ;
6011 PyObject * obj0 = 0 ;
6012 PyObject * obj1 = 0 ;
6013 PyObject * obj2 = 0 ;
6014 char * kwnames[] = {
6015 (char *) "self",(char *) "x",(char *) "y", NULL
6016 };
6017
6018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6020 if (!SWIG_IsOK(res1)) {
6021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6022 }
6023 arg1 = reinterpret_cast< wxPoint * >(argp1);
6024 ecode2 = SWIG_AsVal_long(obj1, &val2);
6025 if (!SWIG_IsOK(ecode2)) {
6026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6027 }
6028 arg2 = static_cast< long >(val2);
6029 ecode3 = SWIG_AsVal_long(obj2, &val3);
6030 if (!SWIG_IsOK(ecode3)) {
6031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6032 }
6033 arg3 = static_cast< long >(val3);
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 wxPoint_Set(arg1,arg2,arg3);
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 resultobj = SWIG_Py_Void();
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6048 PyObject *resultobj = 0;
6049 wxPoint *arg1 = (wxPoint *) 0 ;
6050 PyObject *result = 0 ;
6051 void *argp1 = 0 ;
6052 int res1 = 0 ;
6053 PyObject *swig_obj[1] ;
6054
6055 if (!args) SWIG_fail;
6056 swig_obj[0] = args;
6057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6058 if (!SWIG_IsOK(res1)) {
6059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6060 }
6061 arg1 = reinterpret_cast< wxPoint * >(argp1);
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (PyObject *)wxPoint_Get(arg1);
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 resultobj = result;
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6076 PyObject *obj;
6077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6078 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6079 return SWIG_Py_Void();
6080 }
6081
6082 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6083 return SWIG_Python_InitShadowInstance(args);
6084 }
6085
6086 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj = 0;
6088 int arg1 = (int) 0 ;
6089 int arg2 = (int) 0 ;
6090 int arg3 = (int) 0 ;
6091 int arg4 = (int) 0 ;
6092 wxRect *result = 0 ;
6093 int val1 ;
6094 int ecode1 = 0 ;
6095 int val2 ;
6096 int ecode2 = 0 ;
6097 int val3 ;
6098 int ecode3 = 0 ;
6099 int val4 ;
6100 int ecode4 = 0 ;
6101 PyObject * obj0 = 0 ;
6102 PyObject * obj1 = 0 ;
6103 PyObject * obj2 = 0 ;
6104 PyObject * obj3 = 0 ;
6105 char * kwnames[] = {
6106 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6107 };
6108
6109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6110 if (obj0) {
6111 ecode1 = SWIG_AsVal_int(obj0, &val1);
6112 if (!SWIG_IsOK(ecode1)) {
6113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6114 }
6115 arg1 = static_cast< int >(val1);
6116 }
6117 if (obj1) {
6118 ecode2 = SWIG_AsVal_int(obj1, &val2);
6119 if (!SWIG_IsOK(ecode2)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6121 }
6122 arg2 = static_cast< int >(val2);
6123 }
6124 if (obj2) {
6125 ecode3 = SWIG_AsVal_int(obj2, &val3);
6126 if (!SWIG_IsOK(ecode3)) {
6127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6128 }
6129 arg3 = static_cast< int >(val3);
6130 }
6131 if (obj3) {
6132 ecode4 = SWIG_AsVal_int(obj3, &val4);
6133 if (!SWIG_IsOK(ecode4)) {
6134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6135 }
6136 arg4 = static_cast< int >(val4);
6137 }
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj = 0;
6153 wxPoint *arg1 = 0 ;
6154 wxPoint *arg2 = 0 ;
6155 wxRect *result = 0 ;
6156 wxPoint temp1 ;
6157 wxPoint temp2 ;
6158 PyObject * obj0 = 0 ;
6159 PyObject * obj1 = 0 ;
6160 char * kwnames[] = {
6161 (char *) "topLeft",(char *) "bottomRight", NULL
6162 };
6163
6164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6165 {
6166 arg1 = &temp1;
6167 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6168 }
6169 {
6170 arg2 = &temp2;
6171 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6172 }
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6176 wxPyEndAllowThreads(__tstate);
6177 if (PyErr_Occurred()) SWIG_fail;
6178 }
6179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj = 0;
6188 wxPoint *arg1 = 0 ;
6189 wxSize *arg2 = 0 ;
6190 wxRect *result = 0 ;
6191 wxPoint temp1 ;
6192 wxSize temp2 ;
6193 PyObject * obj0 = 0 ;
6194 PyObject * obj1 = 0 ;
6195 char * kwnames[] = {
6196 (char *) "pos",(char *) "size", NULL
6197 };
6198
6199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6200 {
6201 arg1 = &temp1;
6202 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6203 }
6204 {
6205 arg2 = &temp2;
6206 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6207 }
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6211 wxPyEndAllowThreads(__tstate);
6212 if (PyErr_Occurred()) SWIG_fail;
6213 }
6214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6215 return resultobj;
6216 fail:
6217 return NULL;
6218 }
6219
6220
6221 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj = 0;
6223 wxSize *arg1 = 0 ;
6224 wxRect *result = 0 ;
6225 wxSize temp1 ;
6226 PyObject * obj0 = 0 ;
6227 char * kwnames[] = {
6228 (char *) "size", NULL
6229 };
6230
6231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6232 {
6233 arg1 = &temp1;
6234 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6235 }
6236 {
6237 PyThreadState* __tstate = wxPyBeginAllowThreads();
6238 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6239 wxPyEndAllowThreads(__tstate);
6240 if (PyErr_Occurred()) SWIG_fail;
6241 }
6242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6243 return resultobj;
6244 fail:
6245 return NULL;
6246 }
6247
6248
6249 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6250 PyObject *resultobj = 0;
6251 wxRect *arg1 = (wxRect *) 0 ;
6252 void *argp1 = 0 ;
6253 int res1 = 0 ;
6254 PyObject *swig_obj[1] ;
6255
6256 if (!args) SWIG_fail;
6257 swig_obj[0] = args;
6258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6259 if (!SWIG_IsOK(res1)) {
6260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6261 }
6262 arg1 = reinterpret_cast< wxRect * >(argp1);
6263 {
6264 PyThreadState* __tstate = wxPyBeginAllowThreads();
6265 delete arg1;
6266
6267 wxPyEndAllowThreads(__tstate);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 resultobj = SWIG_Py_Void();
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6278 PyObject *resultobj = 0;
6279 wxRect *arg1 = (wxRect *) 0 ;
6280 int result;
6281 void *argp1 = 0 ;
6282 int res1 = 0 ;
6283 PyObject *swig_obj[1] ;
6284
6285 if (!args) SWIG_fail;
6286 swig_obj[0] = args;
6287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6288 if (!SWIG_IsOK(res1)) {
6289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6290 }
6291 arg1 = reinterpret_cast< wxRect * >(argp1);
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 result = (int)((wxRect const *)arg1)->GetX();
6295 wxPyEndAllowThreads(__tstate);
6296 if (PyErr_Occurred()) SWIG_fail;
6297 }
6298 resultobj = SWIG_From_int(static_cast< int >(result));
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6306 PyObject *resultobj = 0;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int arg2 ;
6309 void *argp1 = 0 ;
6310 int res1 = 0 ;
6311 int val2 ;
6312 int ecode2 = 0 ;
6313 PyObject * obj0 = 0 ;
6314 PyObject * obj1 = 0 ;
6315 char * kwnames[] = {
6316 (char *) "self",(char *) "x", NULL
6317 };
6318
6319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6321 if (!SWIG_IsOK(res1)) {
6322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6323 }
6324 arg1 = reinterpret_cast< wxRect * >(argp1);
6325 ecode2 = SWIG_AsVal_int(obj1, &val2);
6326 if (!SWIG_IsOK(ecode2)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6328 }
6329 arg2 = static_cast< int >(val2);
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 (arg1)->SetX(arg2);
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_Py_Void();
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6344 PyObject *resultobj = 0;
6345 wxRect *arg1 = (wxRect *) 0 ;
6346 int result;
6347 void *argp1 = 0 ;
6348 int res1 = 0 ;
6349 PyObject *swig_obj[1] ;
6350
6351 if (!args) SWIG_fail;
6352 swig_obj[0] = args;
6353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6354 if (!SWIG_IsOK(res1)) {
6355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6356 }
6357 arg1 = reinterpret_cast< wxRect * >(argp1);
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 result = (int)(arg1)->GetY();
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_From_int(static_cast< int >(result));
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6372 PyObject *resultobj = 0;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 int arg2 ;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 int val2 ;
6378 int ecode2 = 0 ;
6379 PyObject * obj0 = 0 ;
6380 PyObject * obj1 = 0 ;
6381 char * kwnames[] = {
6382 (char *) "self",(char *) "y", NULL
6383 };
6384
6385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6387 if (!SWIG_IsOK(res1)) {
6388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6389 }
6390 arg1 = reinterpret_cast< wxRect * >(argp1);
6391 ecode2 = SWIG_AsVal_int(obj1, &val2);
6392 if (!SWIG_IsOK(ecode2)) {
6393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6394 }
6395 arg2 = static_cast< int >(val2);
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 (arg1)->SetY(arg2);
6399 wxPyEndAllowThreads(__tstate);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 resultobj = SWIG_Py_Void();
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6410 PyObject *resultobj = 0;
6411 wxRect *arg1 = (wxRect *) 0 ;
6412 int result;
6413 void *argp1 = 0 ;
6414 int res1 = 0 ;
6415 PyObject *swig_obj[1] ;
6416
6417 if (!args) SWIG_fail;
6418 swig_obj[0] = args;
6419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6420 if (!SWIG_IsOK(res1)) {
6421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6422 }
6423 arg1 = reinterpret_cast< wxRect * >(argp1);
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 result = (int)((wxRect const *)arg1)->GetWidth();
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_From_int(static_cast< int >(result));
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6438 PyObject *resultobj = 0;
6439 wxRect *arg1 = (wxRect *) 0 ;
6440 int arg2 ;
6441 void *argp1 = 0 ;
6442 int res1 = 0 ;
6443 int val2 ;
6444 int ecode2 = 0 ;
6445 PyObject * obj0 = 0 ;
6446 PyObject * obj1 = 0 ;
6447 char * kwnames[] = {
6448 (char *) "self",(char *) "w", NULL
6449 };
6450
6451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6453 if (!SWIG_IsOK(res1)) {
6454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6455 }
6456 arg1 = reinterpret_cast< wxRect * >(argp1);
6457 ecode2 = SWIG_AsVal_int(obj1, &val2);
6458 if (!SWIG_IsOK(ecode2)) {
6459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6460 }
6461 arg2 = static_cast< int >(val2);
6462 {
6463 PyThreadState* __tstate = wxPyBeginAllowThreads();
6464 (arg1)->SetWidth(arg2);
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_Py_Void();
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6476 PyObject *resultobj = 0;
6477 wxRect *arg1 = (wxRect *) 0 ;
6478 int result;
6479 void *argp1 = 0 ;
6480 int res1 = 0 ;
6481 PyObject *swig_obj[1] ;
6482
6483 if (!args) SWIG_fail;
6484 swig_obj[0] = args;
6485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6486 if (!SWIG_IsOK(res1)) {
6487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6488 }
6489 arg1 = reinterpret_cast< wxRect * >(argp1);
6490 {
6491 PyThreadState* __tstate = wxPyBeginAllowThreads();
6492 result = (int)((wxRect const *)arg1)->GetHeight();
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_From_int(static_cast< int >(result));
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj = 0;
6505 wxRect *arg1 = (wxRect *) 0 ;
6506 int arg2 ;
6507 void *argp1 = 0 ;
6508 int res1 = 0 ;
6509 int val2 ;
6510 int ecode2 = 0 ;
6511 PyObject * obj0 = 0 ;
6512 PyObject * obj1 = 0 ;
6513 char * kwnames[] = {
6514 (char *) "self",(char *) "h", NULL
6515 };
6516
6517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6519 if (!SWIG_IsOK(res1)) {
6520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6521 }
6522 arg1 = reinterpret_cast< wxRect * >(argp1);
6523 ecode2 = SWIG_AsVal_int(obj1, &val2);
6524 if (!SWIG_IsOK(ecode2)) {
6525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6526 }
6527 arg2 = static_cast< int >(val2);
6528 {
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 (arg1)->SetHeight(arg2);
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_Py_Void();
6535 return resultobj;
6536 fail:
6537 return NULL;
6538 }
6539
6540
6541 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6542 PyObject *resultobj = 0;
6543 wxRect *arg1 = (wxRect *) 0 ;
6544 wxPoint result;
6545 void *argp1 = 0 ;
6546 int res1 = 0 ;
6547 PyObject *swig_obj[1] ;
6548
6549 if (!args) SWIG_fail;
6550 swig_obj[0] = args;
6551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6552 if (!SWIG_IsOK(res1)) {
6553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6554 }
6555 arg1 = reinterpret_cast< wxRect * >(argp1);
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = ((wxRect const *)arg1)->GetPosition();
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj = 0;
6571 wxRect *arg1 = (wxRect *) 0 ;
6572 wxPoint *arg2 = 0 ;
6573 void *argp1 = 0 ;
6574 int res1 = 0 ;
6575 wxPoint temp2 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 char * kwnames[] = {
6579 (char *) "self",(char *) "p", NULL
6580 };
6581
6582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6586 }
6587 arg1 = reinterpret_cast< wxRect * >(argp1);
6588 {
6589 arg2 = &temp2;
6590 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6591 }
6592 {
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 (arg1)->SetPosition((wxPoint const &)*arg2);
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 resultobj = SWIG_Py_Void();
6599 return resultobj;
6600 fail:
6601 return NULL;
6602 }
6603
6604
6605 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6606 PyObject *resultobj = 0;
6607 wxRect *arg1 = (wxRect *) 0 ;
6608 wxSize result;
6609 void *argp1 = 0 ;
6610 int res1 = 0 ;
6611 PyObject *swig_obj[1] ;
6612
6613 if (!args) SWIG_fail;
6614 swig_obj[0] = args;
6615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 result = ((wxRect const *)arg1)->GetSize();
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj = 0;
6635 wxRect *arg1 = (wxRect *) 0 ;
6636 wxSize *arg2 = 0 ;
6637 void *argp1 = 0 ;
6638 int res1 = 0 ;
6639 wxSize temp2 ;
6640 PyObject * obj0 = 0 ;
6641 PyObject * obj1 = 0 ;
6642 char * kwnames[] = {
6643 (char *) "self",(char *) "s", NULL
6644 };
6645
6646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6650 }
6651 arg1 = reinterpret_cast< wxRect * >(argp1);
6652 {
6653 arg2 = &temp2;
6654 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6655 }
6656 {
6657 PyThreadState* __tstate = wxPyBeginAllowThreads();
6658 (arg1)->SetSize((wxSize const &)*arg2);
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 resultobj = SWIG_Py_Void();
6663 return resultobj;
6664 fail:
6665 return NULL;
6666 }
6667
6668
6669 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6670 PyObject *resultobj = 0;
6671 wxRect *arg1 = (wxRect *) 0 ;
6672 bool result;
6673 void *argp1 = 0 ;
6674 int res1 = 0 ;
6675 PyObject *swig_obj[1] ;
6676
6677 if (!args) SWIG_fail;
6678 swig_obj[0] = args;
6679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6680 if (!SWIG_IsOK(res1)) {
6681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6682 }
6683 arg1 = reinterpret_cast< wxRect * >(argp1);
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (bool)((wxRect const *)arg1)->IsEmpty();
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 {
6691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6692 }
6693 return resultobj;
6694 fail:
6695 return NULL;
6696 }
6697
6698
6699 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6700 PyObject *resultobj = 0;
6701 wxRect *arg1 = (wxRect *) 0 ;
6702 wxPoint result;
6703 void *argp1 = 0 ;
6704 int res1 = 0 ;
6705 PyObject *swig_obj[1] ;
6706
6707 if (!args) SWIG_fail;
6708 swig_obj[0] = args;
6709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6710 if (!SWIG_IsOK(res1)) {
6711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6712 }
6713 arg1 = reinterpret_cast< wxRect * >(argp1);
6714 {
6715 PyThreadState* __tstate = wxPyBeginAllowThreads();
6716 result = ((wxRect const *)arg1)->GetTopLeft();
6717 wxPyEndAllowThreads(__tstate);
6718 if (PyErr_Occurred()) SWIG_fail;
6719 }
6720 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6721 return resultobj;
6722 fail:
6723 return NULL;
6724 }
6725
6726
6727 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6728 PyObject *resultobj = 0;
6729 wxRect *arg1 = (wxRect *) 0 ;
6730 wxPoint *arg2 = 0 ;
6731 void *argp1 = 0 ;
6732 int res1 = 0 ;
6733 wxPoint temp2 ;
6734 PyObject * obj0 = 0 ;
6735 PyObject * obj1 = 0 ;
6736 char * kwnames[] = {
6737 (char *) "self",(char *) "p", NULL
6738 };
6739
6740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6742 if (!SWIG_IsOK(res1)) {
6743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6744 }
6745 arg1 = reinterpret_cast< wxRect * >(argp1);
6746 {
6747 arg2 = &temp2;
6748 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6749 }
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6753 wxPyEndAllowThreads(__tstate);
6754 if (PyErr_Occurred()) SWIG_fail;
6755 }
6756 resultobj = SWIG_Py_Void();
6757 return resultobj;
6758 fail:
6759 return NULL;
6760 }
6761
6762
6763 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6764 PyObject *resultobj = 0;
6765 wxRect *arg1 = (wxRect *) 0 ;
6766 wxPoint result;
6767 void *argp1 = 0 ;
6768 int res1 = 0 ;
6769 PyObject *swig_obj[1] ;
6770
6771 if (!args) SWIG_fail;
6772 swig_obj[0] = args;
6773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6774 if (!SWIG_IsOK(res1)) {
6775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6776 }
6777 arg1 = reinterpret_cast< wxRect * >(argp1);
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = ((wxRect const *)arg1)->GetBottomRight();
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj = 0;
6793 wxRect *arg1 = (wxRect *) 0 ;
6794 wxPoint *arg2 = 0 ;
6795 void *argp1 = 0 ;
6796 int res1 = 0 ;
6797 wxPoint temp2 ;
6798 PyObject * obj0 = 0 ;
6799 PyObject * obj1 = 0 ;
6800 char * kwnames[] = {
6801 (char *) "self",(char *) "p", NULL
6802 };
6803
6804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6806 if (!SWIG_IsOK(res1)) {
6807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6808 }
6809 arg1 = reinterpret_cast< wxRect * >(argp1);
6810 {
6811 arg2 = &temp2;
6812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6813 }
6814 {
6815 PyThreadState* __tstate = wxPyBeginAllowThreads();
6816 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6817 wxPyEndAllowThreads(__tstate);
6818 if (PyErr_Occurred()) SWIG_fail;
6819 }
6820 resultobj = SWIG_Py_Void();
6821 return resultobj;
6822 fail:
6823 return NULL;
6824 }
6825
6826
6827 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6828 PyObject *resultobj = 0;
6829 wxRect *arg1 = (wxRect *) 0 ;
6830 int result;
6831 void *argp1 = 0 ;
6832 int res1 = 0 ;
6833 PyObject *swig_obj[1] ;
6834
6835 if (!args) SWIG_fail;
6836 swig_obj[0] = args;
6837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6838 if (!SWIG_IsOK(res1)) {
6839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6840 }
6841 arg1 = reinterpret_cast< wxRect * >(argp1);
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = (int)((wxRect const *)arg1)->GetLeft();
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_From_int(static_cast< int >(result));
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6856 PyObject *resultobj = 0;
6857 wxRect *arg1 = (wxRect *) 0 ;
6858 int result;
6859 void *argp1 = 0 ;
6860 int res1 = 0 ;
6861 PyObject *swig_obj[1] ;
6862
6863 if (!args) SWIG_fail;
6864 swig_obj[0] = args;
6865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6866 if (!SWIG_IsOK(res1)) {
6867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6868 }
6869 arg1 = reinterpret_cast< wxRect * >(argp1);
6870 {
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 result = (int)((wxRect const *)arg1)->GetTop();
6873 wxPyEndAllowThreads(__tstate);
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 resultobj = SWIG_From_int(static_cast< int >(result));
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6884 PyObject *resultobj = 0;
6885 wxRect *arg1 = (wxRect *) 0 ;
6886 int result;
6887 void *argp1 = 0 ;
6888 int res1 = 0 ;
6889 PyObject *swig_obj[1] ;
6890
6891 if (!args) SWIG_fail;
6892 swig_obj[0] = args;
6893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6894 if (!SWIG_IsOK(res1)) {
6895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6896 }
6897 arg1 = reinterpret_cast< wxRect * >(argp1);
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 result = (int)((wxRect const *)arg1)->GetBottom();
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 resultobj = SWIG_From_int(static_cast< int >(result));
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6912 PyObject *resultobj = 0;
6913 wxRect *arg1 = (wxRect *) 0 ;
6914 int result;
6915 void *argp1 = 0 ;
6916 int res1 = 0 ;
6917 PyObject *swig_obj[1] ;
6918
6919 if (!args) SWIG_fail;
6920 swig_obj[0] = args;
6921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6922 if (!SWIG_IsOK(res1)) {
6923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6924 }
6925 arg1 = reinterpret_cast< wxRect * >(argp1);
6926 {
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 result = (int)((wxRect const *)arg1)->GetRight();
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 resultobj = SWIG_From_int(static_cast< int >(result));
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj = 0;
6941 wxRect *arg1 = (wxRect *) 0 ;
6942 int arg2 ;
6943 void *argp1 = 0 ;
6944 int res1 = 0 ;
6945 int val2 ;
6946 int ecode2 = 0 ;
6947 PyObject * obj0 = 0 ;
6948 PyObject * obj1 = 0 ;
6949 char * kwnames[] = {
6950 (char *) "self",(char *) "left", NULL
6951 };
6952
6953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6955 if (!SWIG_IsOK(res1)) {
6956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6957 }
6958 arg1 = reinterpret_cast< wxRect * >(argp1);
6959 ecode2 = SWIG_AsVal_int(obj1, &val2);
6960 if (!SWIG_IsOK(ecode2)) {
6961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6962 }
6963 arg2 = static_cast< int >(val2);
6964 {
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 (arg1)->SetLeft(arg2);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6978 PyObject *resultobj = 0;
6979 wxRect *arg1 = (wxRect *) 0 ;
6980 int arg2 ;
6981 void *argp1 = 0 ;
6982 int res1 = 0 ;
6983 int val2 ;
6984 int ecode2 = 0 ;
6985 PyObject * obj0 = 0 ;
6986 PyObject * obj1 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "self",(char *) "right", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6993 if (!SWIG_IsOK(res1)) {
6994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6995 }
6996 arg1 = reinterpret_cast< wxRect * >(argp1);
6997 ecode2 = SWIG_AsVal_int(obj1, &val2);
6998 if (!SWIG_IsOK(ecode2)) {
6999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7000 }
7001 arg2 = static_cast< int >(val2);
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 (arg1)->SetRight(arg2);
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_Py_Void();
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj = 0;
7017 wxRect *arg1 = (wxRect *) 0 ;
7018 int arg2 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 int val2 ;
7022 int ecode2 = 0 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 char * kwnames[] = {
7026 (char *) "self",(char *) "top", NULL
7027 };
7028
7029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7031 if (!SWIG_IsOK(res1)) {
7032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7033 }
7034 arg1 = reinterpret_cast< wxRect * >(argp1);
7035 ecode2 = SWIG_AsVal_int(obj1, &val2);
7036 if (!SWIG_IsOK(ecode2)) {
7037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7038 }
7039 arg2 = static_cast< int >(val2);
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 (arg1)->SetTop(arg2);
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 resultobj = SWIG_Py_Void();
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7054 PyObject *resultobj = 0;
7055 wxRect *arg1 = (wxRect *) 0 ;
7056 int arg2 ;
7057 void *argp1 = 0 ;
7058 int res1 = 0 ;
7059 int val2 ;
7060 int ecode2 = 0 ;
7061 PyObject * obj0 = 0 ;
7062 PyObject * obj1 = 0 ;
7063 char * kwnames[] = {
7064 (char *) "self",(char *) "bottom", NULL
7065 };
7066
7067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7069 if (!SWIG_IsOK(res1)) {
7070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7071 }
7072 arg1 = reinterpret_cast< wxRect * >(argp1);
7073 ecode2 = SWIG_AsVal_int(obj1, &val2);
7074 if (!SWIG_IsOK(ecode2)) {
7075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7076 }
7077 arg2 = static_cast< int >(val2);
7078 {
7079 PyThreadState* __tstate = wxPyBeginAllowThreads();
7080 (arg1)->SetBottom(arg2);
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 resultobj = SWIG_Py_Void();
7085 return resultobj;
7086 fail:
7087 return NULL;
7088 }
7089
7090
7091 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7092 PyObject *resultobj = 0;
7093 wxRect *arg1 = (wxRect *) 0 ;
7094 int arg2 ;
7095 int arg3 ;
7096 wxRect *result = 0 ;
7097 void *argp1 = 0 ;
7098 int res1 = 0 ;
7099 int val2 ;
7100 int ecode2 = 0 ;
7101 int val3 ;
7102 int ecode3 = 0 ;
7103 PyObject * obj0 = 0 ;
7104 PyObject * obj1 = 0 ;
7105 PyObject * obj2 = 0 ;
7106 char * kwnames[] = {
7107 (char *) "self",(char *) "dx",(char *) "dy", NULL
7108 };
7109
7110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7112 if (!SWIG_IsOK(res1)) {
7113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7114 }
7115 arg1 = reinterpret_cast< wxRect * >(argp1);
7116 ecode2 = SWIG_AsVal_int(obj1, &val2);
7117 if (!SWIG_IsOK(ecode2)) {
7118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7119 }
7120 arg2 = static_cast< int >(val2);
7121 ecode3 = SWIG_AsVal_int(obj2, &val3);
7122 if (!SWIG_IsOK(ecode3)) {
7123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7124 }
7125 arg3 = static_cast< int >(val3);
7126 {
7127 PyThreadState* __tstate = wxPyBeginAllowThreads();
7128 {
7129 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7130 result = (wxRect *) &_result_ref;
7131 }
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7136 return resultobj;
7137 fail:
7138 return NULL;
7139 }
7140
7141
7142 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7143 PyObject *resultobj = 0;
7144 wxRect *arg1 = (wxRect *) 0 ;
7145 int arg2 ;
7146 int arg3 ;
7147 wxRect *result = 0 ;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 int val2 ;
7151 int ecode2 = 0 ;
7152 int val3 ;
7153 int ecode3 = 0 ;
7154 PyObject * obj0 = 0 ;
7155 PyObject * obj1 = 0 ;
7156 PyObject * obj2 = 0 ;
7157 char * kwnames[] = {
7158 (char *) "self",(char *) "dx",(char *) "dy", NULL
7159 };
7160
7161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7163 if (!SWIG_IsOK(res1)) {
7164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7165 }
7166 arg1 = reinterpret_cast< wxRect * >(argp1);
7167 ecode2 = SWIG_AsVal_int(obj1, &val2);
7168 if (!SWIG_IsOK(ecode2)) {
7169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7170 }
7171 arg2 = static_cast< int >(val2);
7172 ecode3 = SWIG_AsVal_int(obj2, &val3);
7173 if (!SWIG_IsOK(ecode3)) {
7174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7175 }
7176 arg3 = static_cast< int >(val3);
7177 {
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 {
7180 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7181 result = (wxRect *) &_result_ref;
7182 }
7183 wxPyEndAllowThreads(__tstate);
7184 if (PyErr_Occurred()) SWIG_fail;
7185 }
7186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj = 0;
7195 wxRect *arg1 = (wxRect *) 0 ;
7196 int arg2 ;
7197 int arg3 ;
7198 void *argp1 = 0 ;
7199 int res1 = 0 ;
7200 int val2 ;
7201 int ecode2 = 0 ;
7202 int val3 ;
7203 int ecode3 = 0 ;
7204 PyObject * obj0 = 0 ;
7205 PyObject * obj1 = 0 ;
7206 PyObject * obj2 = 0 ;
7207 char * kwnames[] = {
7208 (char *) "self",(char *) "dx",(char *) "dy", NULL
7209 };
7210
7211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7213 if (!SWIG_IsOK(res1)) {
7214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7215 }
7216 arg1 = reinterpret_cast< wxRect * >(argp1);
7217 ecode2 = SWIG_AsVal_int(obj1, &val2);
7218 if (!SWIG_IsOK(ecode2)) {
7219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7220 }
7221 arg2 = static_cast< int >(val2);
7222 ecode3 = SWIG_AsVal_int(obj2, &val3);
7223 if (!SWIG_IsOK(ecode3)) {
7224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7225 }
7226 arg3 = static_cast< int >(val3);
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 (arg1)->Offset(arg2,arg3);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 resultobj = SWIG_Py_Void();
7234 return resultobj;
7235 fail:
7236 return NULL;
7237 }
7238
7239
7240 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7241 PyObject *resultobj = 0;
7242 wxRect *arg1 = (wxRect *) 0 ;
7243 wxPoint *arg2 = 0 ;
7244 void *argp1 = 0 ;
7245 int res1 = 0 ;
7246 wxPoint temp2 ;
7247 PyObject * obj0 = 0 ;
7248 PyObject * obj1 = 0 ;
7249 char * kwnames[] = {
7250 (char *) "self",(char *) "pt", NULL
7251 };
7252
7253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7255 if (!SWIG_IsOK(res1)) {
7256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7257 }
7258 arg1 = reinterpret_cast< wxRect * >(argp1);
7259 {
7260 arg2 = &temp2;
7261 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7262 }
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 (arg1)->Offset((wxPoint const &)*arg2);
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 resultobj = SWIG_Py_Void();
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj = 0;
7278 wxRect *arg1 = (wxRect *) 0 ;
7279 wxRect *arg2 = 0 ;
7280 wxRect result;
7281 void *argp1 = 0 ;
7282 int res1 = 0 ;
7283 wxRect temp2 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "self",(char *) "rect", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7292 if (!SWIG_IsOK(res1)) {
7293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7294 }
7295 arg1 = reinterpret_cast< wxRect * >(argp1);
7296 {
7297 arg2 = &temp2;
7298 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7299 }
7300 {
7301 PyThreadState* __tstate = wxPyBeginAllowThreads();
7302 result = (arg1)->Intersect((wxRect const &)*arg2);
7303 wxPyEndAllowThreads(__tstate);
7304 if (PyErr_Occurred()) SWIG_fail;
7305 }
7306 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj = 0;
7315 wxRect *arg1 = (wxRect *) 0 ;
7316 wxRect *arg2 = 0 ;
7317 wxRect result;
7318 void *argp1 = 0 ;
7319 int res1 = 0 ;
7320 wxRect temp2 ;
7321 PyObject * obj0 = 0 ;
7322 PyObject * obj1 = 0 ;
7323 char * kwnames[] = {
7324 (char *) "self",(char *) "rect", NULL
7325 };
7326
7327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7329 if (!SWIG_IsOK(res1)) {
7330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7331 }
7332 arg1 = reinterpret_cast< wxRect * >(argp1);
7333 {
7334 arg2 = &temp2;
7335 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7336 }
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 result = (arg1)->Union((wxRect const &)*arg2);
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj = 0;
7352 wxRect *arg1 = (wxRect *) 0 ;
7353 wxRect *arg2 = 0 ;
7354 wxRect result;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 wxRect temp2 ;
7358 PyObject * obj0 = 0 ;
7359 PyObject * obj1 = 0 ;
7360 char * kwnames[] = {
7361 (char *) "self",(char *) "rect", NULL
7362 };
7363
7364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7366 if (!SWIG_IsOK(res1)) {
7367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7368 }
7369 arg1 = reinterpret_cast< wxRect * >(argp1);
7370 {
7371 arg2 = &temp2;
7372 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7373 }
7374 {
7375 PyThreadState* __tstate = wxPyBeginAllowThreads();
7376 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj = 0;
7389 wxRect *arg1 = (wxRect *) 0 ;
7390 wxRect *arg2 = 0 ;
7391 wxRect *result = 0 ;
7392 void *argp1 = 0 ;
7393 int res1 = 0 ;
7394 wxRect temp2 ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 char * kwnames[] = {
7398 (char *) "self",(char *) "rect", NULL
7399 };
7400
7401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7403 if (!SWIG_IsOK(res1)) {
7404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7405 }
7406 arg1 = reinterpret_cast< wxRect * >(argp1);
7407 {
7408 arg2 = &temp2;
7409 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7410 }
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 {
7414 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7415 result = (wxRect *) &_result_ref;
7416 }
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj = 0;
7429 wxRect *arg1 = (wxRect *) 0 ;
7430 PyObject *arg2 = (PyObject *) 0 ;
7431 bool result;
7432 void *argp1 = 0 ;
7433 int res1 = 0 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char * kwnames[] = {
7437 (char *) "self",(char *) "other", NULL
7438 };
7439
7440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",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___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7444 }
7445 arg1 = reinterpret_cast< wxRect * >(argp1);
7446 arg2 = obj1;
7447 {
7448 result = (bool)wxRect___eq__(arg1,arg2);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj = 0;
7462 wxRect *arg1 = (wxRect *) 0 ;
7463 PyObject *arg2 = (PyObject *) 0 ;
7464 bool result;
7465 void *argp1 = 0 ;
7466 int res1 = 0 ;
7467 PyObject * obj0 = 0 ;
7468 PyObject * obj1 = 0 ;
7469 char * kwnames[] = {
7470 (char *) "self",(char *) "other", NULL
7471 };
7472
7473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7475 if (!SWIG_IsOK(res1)) {
7476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7477 }
7478 arg1 = reinterpret_cast< wxRect * >(argp1);
7479 arg2 = obj1;
7480 {
7481 result = (bool)wxRect___ne__(arg1,arg2);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 {
7485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj = 0;
7495 wxRect *arg1 = (wxRect *) 0 ;
7496 int arg2 ;
7497 int arg3 ;
7498 bool result;
7499 void *argp1 = 0 ;
7500 int res1 = 0 ;
7501 int val2 ;
7502 int ecode2 = 0 ;
7503 int val3 ;
7504 int ecode3 = 0 ;
7505 PyObject * obj0 = 0 ;
7506 PyObject * obj1 = 0 ;
7507 PyObject * obj2 = 0 ;
7508 char * kwnames[] = {
7509 (char *) "self",(char *) "x",(char *) "y", NULL
7510 };
7511
7512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7516 }
7517 arg1 = reinterpret_cast< wxRect * >(argp1);
7518 ecode2 = SWIG_AsVal_int(obj1, &val2);
7519 if (!SWIG_IsOK(ecode2)) {
7520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7521 }
7522 arg2 = static_cast< int >(val2);
7523 ecode3 = SWIG_AsVal_int(obj2, &val3);
7524 if (!SWIG_IsOK(ecode3)) {
7525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7526 }
7527 arg3 = static_cast< int >(val3);
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 {
7535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7536 }
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 wxPoint *arg2 = 0 ;
7547 bool result;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 wxPoint temp2 ;
7551 PyObject * obj0 = 0 ;
7552 PyObject * obj1 = 0 ;
7553 char * kwnames[] = {
7554 (char *) "self",(char *) "pt", NULL
7555 };
7556
7557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7561 }
7562 arg1 = reinterpret_cast< wxRect * >(argp1);
7563 {
7564 arg2 = &temp2;
7565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7566 }
7567 {
7568 PyThreadState* __tstate = wxPyBeginAllowThreads();
7569 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7570 wxPyEndAllowThreads(__tstate);
7571 if (PyErr_Occurred()) SWIG_fail;
7572 }
7573 {
7574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7575 }
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj = 0;
7584 wxRect *arg1 = (wxRect *) 0 ;
7585 wxRect *arg2 = 0 ;
7586 bool result;
7587 void *argp1 = 0 ;
7588 int res1 = 0 ;
7589 wxRect temp2 ;
7590 PyObject * obj0 = 0 ;
7591 PyObject * obj1 = 0 ;
7592 char * kwnames[] = {
7593 (char *) "self",(char *) "rect", NULL
7594 };
7595
7596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7598 if (!SWIG_IsOK(res1)) {
7599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7600 }
7601 arg1 = reinterpret_cast< wxRect * >(argp1);
7602 {
7603 arg2 = &temp2;
7604 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7605 }
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 {
7613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7614 }
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj = 0;
7623 wxRect *arg1 = (wxRect *) 0 ;
7624 wxRect *arg2 = 0 ;
7625 bool result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 wxRect temp2 ;
7629 PyObject * obj0 = 0 ;
7630 PyObject * obj1 = 0 ;
7631 char * kwnames[] = {
7632 (char *) "self",(char *) "rect", NULL
7633 };
7634
7635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7637 if (!SWIG_IsOK(res1)) {
7638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7639 }
7640 arg1 = reinterpret_cast< wxRect * >(argp1);
7641 {
7642 arg2 = &temp2;
7643 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7644 }
7645 {
7646 PyThreadState* __tstate = wxPyBeginAllowThreads();
7647 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7648 wxPyEndAllowThreads(__tstate);
7649 if (PyErr_Occurred()) SWIG_fail;
7650 }
7651 {
7652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7653 }
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj = 0;
7662 wxRect *arg1 = (wxRect *) 0 ;
7663 wxRect *arg2 = 0 ;
7664 int arg3 = (int) wxBOTH ;
7665 wxRect result;
7666 void *argp1 = 0 ;
7667 int res1 = 0 ;
7668 wxRect temp2 ;
7669 int val3 ;
7670 int ecode3 = 0 ;
7671 PyObject * obj0 = 0 ;
7672 PyObject * obj1 = 0 ;
7673 PyObject * obj2 = 0 ;
7674 char * kwnames[] = {
7675 (char *) "self",(char *) "r",(char *) "dir", NULL
7676 };
7677
7678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7680 if (!SWIG_IsOK(res1)) {
7681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7682 }
7683 arg1 = reinterpret_cast< wxRect * >(argp1);
7684 {
7685 arg2 = &temp2;
7686 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7687 }
7688 if (obj2) {
7689 ecode3 = SWIG_AsVal_int(obj2, &val3);
7690 if (!SWIG_IsOK(ecode3)) {
7691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7692 }
7693 arg3 = static_cast< int >(val3);
7694 }
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7709 PyObject *resultobj = 0;
7710 wxRect *arg1 = (wxRect *) 0 ;
7711 int arg2 ;
7712 void *argp1 = 0 ;
7713 int res1 = 0 ;
7714 int val2 ;
7715 int ecode2 = 0 ;
7716 PyObject *swig_obj[2] ;
7717
7718 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7722 }
7723 arg1 = reinterpret_cast< wxRect * >(argp1);
7724 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7725 if (!SWIG_IsOK(ecode2)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7727 }
7728 arg2 = static_cast< int >(val2);
7729 if (arg1) (arg1)->x = arg2;
7730
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7739 PyObject *resultobj = 0;
7740 wxRect *arg1 = (wxRect *) 0 ;
7741 int result;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 PyObject *swig_obj[1] ;
7745
7746 if (!args) SWIG_fail;
7747 swig_obj[0] = args;
7748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7749 if (!SWIG_IsOK(res1)) {
7750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7751 }
7752 arg1 = reinterpret_cast< wxRect * >(argp1);
7753 result = (int) ((arg1)->x);
7754 resultobj = SWIG_From_int(static_cast< int >(result));
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7762 PyObject *resultobj = 0;
7763 wxRect *arg1 = (wxRect *) 0 ;
7764 int arg2 ;
7765 void *argp1 = 0 ;
7766 int res1 = 0 ;
7767 int val2 ;
7768 int ecode2 = 0 ;
7769 PyObject *swig_obj[2] ;
7770
7771 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7773 if (!SWIG_IsOK(res1)) {
7774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7775 }
7776 arg1 = reinterpret_cast< wxRect * >(argp1);
7777 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7778 if (!SWIG_IsOK(ecode2)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7780 }
7781 arg2 = static_cast< int >(val2);
7782 if (arg1) (arg1)->y = arg2;
7783
7784 resultobj = SWIG_Py_Void();
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7792 PyObject *resultobj = 0;
7793 wxRect *arg1 = (wxRect *) 0 ;
7794 int result;
7795 void *argp1 = 0 ;
7796 int res1 = 0 ;
7797 PyObject *swig_obj[1] ;
7798
7799 if (!args) SWIG_fail;
7800 swig_obj[0] = args;
7801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7802 if (!SWIG_IsOK(res1)) {
7803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7804 }
7805 arg1 = reinterpret_cast< wxRect * >(argp1);
7806 result = (int) ((arg1)->y);
7807 resultobj = SWIG_From_int(static_cast< int >(result));
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7815 PyObject *resultobj = 0;
7816 wxRect *arg1 = (wxRect *) 0 ;
7817 int arg2 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 int val2 ;
7821 int ecode2 = 0 ;
7822 PyObject *swig_obj[2] ;
7823
7824 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7826 if (!SWIG_IsOK(res1)) {
7827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7828 }
7829 arg1 = reinterpret_cast< wxRect * >(argp1);
7830 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7831 if (!SWIG_IsOK(ecode2)) {
7832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7833 }
7834 arg2 = static_cast< int >(val2);
7835 if (arg1) (arg1)->width = arg2;
7836
7837 resultobj = SWIG_Py_Void();
7838 return resultobj;
7839 fail:
7840 return NULL;
7841 }
7842
7843
7844 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7845 PyObject *resultobj = 0;
7846 wxRect *arg1 = (wxRect *) 0 ;
7847 int result;
7848 void *argp1 = 0 ;
7849 int res1 = 0 ;
7850 PyObject *swig_obj[1] ;
7851
7852 if (!args) SWIG_fail;
7853 swig_obj[0] = args;
7854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7855 if (!SWIG_IsOK(res1)) {
7856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7857 }
7858 arg1 = reinterpret_cast< wxRect * >(argp1);
7859 result = (int) ((arg1)->width);
7860 resultobj = SWIG_From_int(static_cast< int >(result));
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7868 PyObject *resultobj = 0;
7869 wxRect *arg1 = (wxRect *) 0 ;
7870 int arg2 ;
7871 void *argp1 = 0 ;
7872 int res1 = 0 ;
7873 int val2 ;
7874 int ecode2 = 0 ;
7875 PyObject *swig_obj[2] ;
7876
7877 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7879 if (!SWIG_IsOK(res1)) {
7880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7881 }
7882 arg1 = reinterpret_cast< wxRect * >(argp1);
7883 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7884 if (!SWIG_IsOK(ecode2)) {
7885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7886 }
7887 arg2 = static_cast< int >(val2);
7888 if (arg1) (arg1)->height = arg2;
7889
7890 resultobj = SWIG_Py_Void();
7891 return resultobj;
7892 fail:
7893 return NULL;
7894 }
7895
7896
7897 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7898 PyObject *resultobj = 0;
7899 wxRect *arg1 = (wxRect *) 0 ;
7900 int result;
7901 void *argp1 = 0 ;
7902 int res1 = 0 ;
7903 PyObject *swig_obj[1] ;
7904
7905 if (!args) SWIG_fail;
7906 swig_obj[0] = args;
7907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7908 if (!SWIG_IsOK(res1)) {
7909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7910 }
7911 arg1 = reinterpret_cast< wxRect * >(argp1);
7912 result = (int) ((arg1)->height);
7913 resultobj = SWIG_From_int(static_cast< int >(result));
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj = 0;
7922 wxRect *arg1 = (wxRect *) 0 ;
7923 int arg2 = (int) 0 ;
7924 int arg3 = (int) 0 ;
7925 int arg4 = (int) 0 ;
7926 int arg5 = (int) 0 ;
7927 void *argp1 = 0 ;
7928 int res1 = 0 ;
7929 int val2 ;
7930 int ecode2 = 0 ;
7931 int val3 ;
7932 int ecode3 = 0 ;
7933 int val4 ;
7934 int ecode4 = 0 ;
7935 int val5 ;
7936 int ecode5 = 0 ;
7937 PyObject * obj0 = 0 ;
7938 PyObject * obj1 = 0 ;
7939 PyObject * obj2 = 0 ;
7940 PyObject * obj3 = 0 ;
7941 PyObject * obj4 = 0 ;
7942 char * kwnames[] = {
7943 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7944 };
7945
7946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7948 if (!SWIG_IsOK(res1)) {
7949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7950 }
7951 arg1 = reinterpret_cast< wxRect * >(argp1);
7952 if (obj1) {
7953 ecode2 = SWIG_AsVal_int(obj1, &val2);
7954 if (!SWIG_IsOK(ecode2)) {
7955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7956 }
7957 arg2 = static_cast< int >(val2);
7958 }
7959 if (obj2) {
7960 ecode3 = SWIG_AsVal_int(obj2, &val3);
7961 if (!SWIG_IsOK(ecode3)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7963 }
7964 arg3 = static_cast< int >(val3);
7965 }
7966 if (obj3) {
7967 ecode4 = SWIG_AsVal_int(obj3, &val4);
7968 if (!SWIG_IsOK(ecode4)) {
7969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7970 }
7971 arg4 = static_cast< int >(val4);
7972 }
7973 if (obj4) {
7974 ecode5 = SWIG_AsVal_int(obj4, &val5);
7975 if (!SWIG_IsOK(ecode5)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7977 }
7978 arg5 = static_cast< int >(val5);
7979 }
7980 {
7981 PyThreadState* __tstate = wxPyBeginAllowThreads();
7982 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 resultobj = SWIG_Py_Void();
7987 return resultobj;
7988 fail:
7989 return NULL;
7990 }
7991
7992
7993 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7994 PyObject *resultobj = 0;
7995 wxRect *arg1 = (wxRect *) 0 ;
7996 PyObject *result = 0 ;
7997 void *argp1 = 0 ;
7998 int res1 = 0 ;
7999 PyObject *swig_obj[1] ;
8000
8001 if (!args) SWIG_fail;
8002 swig_obj[0] = args;
8003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8004 if (!SWIG_IsOK(res1)) {
8005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8006 }
8007 arg1 = reinterpret_cast< wxRect * >(argp1);
8008 {
8009 PyThreadState* __tstate = wxPyBeginAllowThreads();
8010 result = (PyObject *)wxRect_Get(arg1);
8011 wxPyEndAllowThreads(__tstate);
8012 if (PyErr_Occurred()) SWIG_fail;
8013 }
8014 resultobj = result;
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *obj;
8023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8024 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8025 return SWIG_Py_Void();
8026 }
8027
8028 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8029 return SWIG_Python_InitShadowInstance(args);
8030 }
8031
8032 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj = 0;
8034 wxRect *arg1 = (wxRect *) 0 ;
8035 wxRect *arg2 = (wxRect *) 0 ;
8036 PyObject *result = 0 ;
8037 void *argp1 = 0 ;
8038 int res1 = 0 ;
8039 void *argp2 = 0 ;
8040 int res2 = 0 ;
8041 PyObject * obj0 = 0 ;
8042 PyObject * obj1 = 0 ;
8043 char * kwnames[] = {
8044 (char *) "r1",(char *) "r2", NULL
8045 };
8046
8047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8049 if (!SWIG_IsOK(res1)) {
8050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8051 }
8052 arg1 = reinterpret_cast< wxRect * >(argp1);
8053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8054 if (!SWIG_IsOK(res2)) {
8055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8056 }
8057 arg2 = reinterpret_cast< wxRect * >(argp2);
8058 {
8059 if (!wxPyCheckForApp()) SWIG_fail;
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 result = (PyObject *)wxIntersectRect(arg1,arg2);
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 resultobj = result;
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj = 0;
8074 double arg1 = (double) 0.0 ;
8075 double arg2 = (double) 0.0 ;
8076 wxPoint2D *result = 0 ;
8077 double val1 ;
8078 int ecode1 = 0 ;
8079 double val2 ;
8080 int ecode2 = 0 ;
8081 PyObject * obj0 = 0 ;
8082 PyObject * obj1 = 0 ;
8083 char * kwnames[] = {
8084 (char *) "x",(char *) "y", NULL
8085 };
8086
8087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8088 if (obj0) {
8089 ecode1 = SWIG_AsVal_double(obj0, &val1);
8090 if (!SWIG_IsOK(ecode1)) {
8091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8092 }
8093 arg1 = static_cast< double >(val1);
8094 }
8095 if (obj1) {
8096 ecode2 = SWIG_AsVal_double(obj1, &val2);
8097 if (!SWIG_IsOK(ecode2)) {
8098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8099 }
8100 arg2 = static_cast< double >(val2);
8101 }
8102 {
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8109 return resultobj;
8110 fail:
8111 return NULL;
8112 }
8113
8114
8115 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8116 PyObject *resultobj = 0;
8117 wxPoint2D *arg1 = 0 ;
8118 wxPoint2D *result = 0 ;
8119 wxPoint2D temp1 ;
8120 PyObject * obj0 = 0 ;
8121 char * kwnames[] = {
8122 (char *) "pt", NULL
8123 };
8124
8125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8126 {
8127 arg1 = &temp1;
8128 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8129 }
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8137 return resultobj;
8138 fail:
8139 return NULL;
8140 }
8141
8142
8143 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8144 PyObject *resultobj = 0;
8145 wxPoint *arg1 = 0 ;
8146 wxPoint2D *result = 0 ;
8147 wxPoint temp1 ;
8148 PyObject * obj0 = 0 ;
8149 char * kwnames[] = {
8150 (char *) "pt", NULL
8151 };
8152
8153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8154 {
8155 arg1 = &temp1;
8156 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8157 }
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8165 return resultobj;
8166 fail:
8167 return NULL;
8168 }
8169
8170
8171 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8172 PyObject *resultobj = 0;
8173 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8174 int *arg2 = (int *) 0 ;
8175 int *arg3 = (int *) 0 ;
8176 void *argp1 = 0 ;
8177 int res1 = 0 ;
8178 int temp2 ;
8179 int res2 = SWIG_TMPOBJ ;
8180 int temp3 ;
8181 int res3 = SWIG_TMPOBJ ;
8182 PyObject *swig_obj[1] ;
8183
8184 arg2 = &temp2;
8185 arg3 = &temp3;
8186 if (!args) SWIG_fail;
8187 swig_obj[0] = args;
8188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8189 if (!SWIG_IsOK(res1)) {
8190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8191 }
8192 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8193 {
8194 PyThreadState* __tstate = wxPyBeginAllowThreads();
8195 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8196 wxPyEndAllowThreads(__tstate);
8197 if (PyErr_Occurred()) SWIG_fail;
8198 }
8199 resultobj = SWIG_Py_Void();
8200 if (SWIG_IsTmpObj(res2)) {
8201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8202 } else {
8203 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8205 }
8206 if (SWIG_IsTmpObj(res3)) {
8207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8208 } else {
8209 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8211 }
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8219 PyObject *resultobj = 0;
8220 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8221 int *arg2 = (int *) 0 ;
8222 int *arg3 = (int *) 0 ;
8223 void *argp1 = 0 ;
8224 int res1 = 0 ;
8225 int temp2 ;
8226 int res2 = SWIG_TMPOBJ ;
8227 int temp3 ;
8228 int res3 = SWIG_TMPOBJ ;
8229 PyObject *swig_obj[1] ;
8230
8231 arg2 = &temp2;
8232 arg3 = &temp3;
8233 if (!args) SWIG_fail;
8234 swig_obj[0] = args;
8235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8236 if (!SWIG_IsOK(res1)) {
8237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8238 }
8239 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 resultobj = SWIG_Py_Void();
8247 if (SWIG_IsTmpObj(res2)) {
8248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8249 } else {
8250 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8252 }
8253 if (SWIG_IsTmpObj(res3)) {
8254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8255 } else {
8256 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8258 }
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8266 PyObject *resultobj = 0;
8267 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8268 double result;
8269 void *argp1 = 0 ;
8270 int res1 = 0 ;
8271 PyObject *swig_obj[1] ;
8272
8273 if (!args) SWIG_fail;
8274 swig_obj[0] = args;
8275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8276 if (!SWIG_IsOK(res1)) {
8277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8278 }
8279 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8280 {
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8283 wxPyEndAllowThreads(__tstate);
8284 if (PyErr_Occurred()) SWIG_fail;
8285 }
8286 resultobj = SWIG_From_double(static_cast< double >(result));
8287 return resultobj;
8288 fail:
8289 return NULL;
8290 }
8291
8292
8293 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8294 PyObject *resultobj = 0;
8295 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8296 double result;
8297 void *argp1 = 0 ;
8298 int res1 = 0 ;
8299 PyObject *swig_obj[1] ;
8300
8301 if (!args) SWIG_fail;
8302 swig_obj[0] = args;
8303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8304 if (!SWIG_IsOK(res1)) {
8305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8306 }
8307 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8308 {
8309 PyThreadState* __tstate = wxPyBeginAllowThreads();
8310 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 resultobj = SWIG_From_double(static_cast< double >(result));
8315 return resultobj;
8316 fail:
8317 return NULL;
8318 }
8319
8320
8321 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj = 0;
8323 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8324 double arg2 ;
8325 void *argp1 = 0 ;
8326 int res1 = 0 ;
8327 double val2 ;
8328 int ecode2 = 0 ;
8329 PyObject * obj0 = 0 ;
8330 PyObject * obj1 = 0 ;
8331 char * kwnames[] = {
8332 (char *) "self",(char *) "length", NULL
8333 };
8334
8335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8337 if (!SWIG_IsOK(res1)) {
8338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8339 }
8340 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8341 ecode2 = SWIG_AsVal_double(obj1, &val2);
8342 if (!SWIG_IsOK(ecode2)) {
8343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8344 }
8345 arg2 = static_cast< double >(val2);
8346 {
8347 PyThreadState* __tstate = wxPyBeginAllowThreads();
8348 (arg1)->SetVectorLength(arg2);
8349 wxPyEndAllowThreads(__tstate);
8350 if (PyErr_Occurred()) SWIG_fail;
8351 }
8352 resultobj = SWIG_Py_Void();
8353 return resultobj;
8354 fail:
8355 return NULL;
8356 }
8357
8358
8359 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8360 PyObject *resultobj = 0;
8361 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8362 double arg2 ;
8363 void *argp1 = 0 ;
8364 int res1 = 0 ;
8365 double val2 ;
8366 int ecode2 = 0 ;
8367 PyObject * obj0 = 0 ;
8368 PyObject * obj1 = 0 ;
8369 char * kwnames[] = {
8370 (char *) "self",(char *) "degrees", NULL
8371 };
8372
8373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8375 if (!SWIG_IsOK(res1)) {
8376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8377 }
8378 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8379 ecode2 = SWIG_AsVal_double(obj1, &val2);
8380 if (!SWIG_IsOK(ecode2)) {
8381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8382 }
8383 arg2 = static_cast< double >(val2);
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 (arg1)->SetVectorAngle(arg2);
8387 wxPyEndAllowThreads(__tstate);
8388 if (PyErr_Occurred()) SWIG_fail;
8389 }
8390 resultobj = SWIG_Py_Void();
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8398 PyObject *resultobj = 0;
8399 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8400 wxPoint2D *arg2 = 0 ;
8401 double result;
8402 void *argp1 = 0 ;
8403 int res1 = 0 ;
8404 wxPoint2D temp2 ;
8405 PyObject * obj0 = 0 ;
8406 PyObject * obj1 = 0 ;
8407 char * kwnames[] = {
8408 (char *) "self",(char *) "pt", NULL
8409 };
8410
8411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8413 if (!SWIG_IsOK(res1)) {
8414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8415 }
8416 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8417 {
8418 arg2 = &temp2;
8419 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8420 }
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8424 wxPyEndAllowThreads(__tstate);
8425 if (PyErr_Occurred()) SWIG_fail;
8426 }
8427 resultobj = SWIG_From_double(static_cast< double >(result));
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj = 0;
8436 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8437 wxPoint2D *arg2 = 0 ;
8438 double result;
8439 void *argp1 = 0 ;
8440 int res1 = 0 ;
8441 wxPoint2D temp2 ;
8442 PyObject * obj0 = 0 ;
8443 PyObject * obj1 = 0 ;
8444 char * kwnames[] = {
8445 (char *) "self",(char *) "pt", NULL
8446 };
8447
8448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8450 if (!SWIG_IsOK(res1)) {
8451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8452 }
8453 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8454 {
8455 arg2 = &temp2;
8456 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8457 }
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8461 wxPyEndAllowThreads(__tstate);
8462 if (PyErr_Occurred()) SWIG_fail;
8463 }
8464 resultobj = SWIG_From_double(static_cast< double >(result));
8465 return resultobj;
8466 fail:
8467 return NULL;
8468 }
8469
8470
8471 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8472 PyObject *resultobj = 0;
8473 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8474 wxPoint2D *arg2 = 0 ;
8475 double result;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 wxPoint2D temp2 ;
8479 PyObject * obj0 = 0 ;
8480 PyObject * obj1 = 0 ;
8481 char * kwnames[] = {
8482 (char *) "self",(char *) "vec", NULL
8483 };
8484
8485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8487 if (!SWIG_IsOK(res1)) {
8488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8489 }
8490 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8491 {
8492 arg2 = &temp2;
8493 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8494 }
8495 {
8496 PyThreadState* __tstate = wxPyBeginAllowThreads();
8497 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 resultobj = SWIG_From_double(static_cast< double >(result));
8502 return resultobj;
8503 fail:
8504 return NULL;
8505 }
8506
8507
8508 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8509 PyObject *resultobj = 0;
8510 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8511 wxPoint2D *arg2 = 0 ;
8512 double result;
8513 void *argp1 = 0 ;
8514 int res1 = 0 ;
8515 wxPoint2D temp2 ;
8516 PyObject * obj0 = 0 ;
8517 PyObject * obj1 = 0 ;
8518 char * kwnames[] = {
8519 (char *) "self",(char *) "vec", NULL
8520 };
8521
8522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8526 }
8527 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8528 {
8529 arg2 = &temp2;
8530 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8531 }
8532 {
8533 PyThreadState* __tstate = wxPyBeginAllowThreads();
8534 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 resultobj = SWIG_From_double(static_cast< double >(result));
8539 return resultobj;
8540 fail:
8541 return NULL;
8542 }
8543
8544
8545 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8546 PyObject *resultobj = 0;
8547 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8548 wxPoint2D result;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 PyObject *swig_obj[1] ;
8552
8553 if (!args) SWIG_fail;
8554 swig_obj[0] = args;
8555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (arg1)->operator -();
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj = 0;
8575 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8576 wxPoint2D *arg2 = 0 ;
8577 wxPoint2D *result = 0 ;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 wxPoint2D temp2 ;
8581 PyObject * obj0 = 0 ;
8582 PyObject * obj1 = 0 ;
8583 char * kwnames[] = {
8584 (char *) "self",(char *) "pt", NULL
8585 };
8586
8587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8589 if (!SWIG_IsOK(res1)) {
8590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8591 }
8592 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8593 {
8594 arg2 = &temp2;
8595 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8596 }
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 {
8600 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8601 result = (wxPoint2D *) &_result_ref;
8602 }
8603 wxPyEndAllowThreads(__tstate);
8604 if (PyErr_Occurred()) SWIG_fail;
8605 }
8606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8607 return resultobj;
8608 fail:
8609 return NULL;
8610 }
8611
8612
8613 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8614 PyObject *resultobj = 0;
8615 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8616 wxPoint2D *arg2 = 0 ;
8617 wxPoint2D *result = 0 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 wxPoint2D temp2 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 char * kwnames[] = {
8624 (char *) "self",(char *) "pt", NULL
8625 };
8626
8627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8629 if (!SWIG_IsOK(res1)) {
8630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8631 }
8632 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8633 {
8634 arg2 = &temp2;
8635 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8636 }
8637 {
8638 PyThreadState* __tstate = wxPyBeginAllowThreads();
8639 {
8640 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8641 result = (wxPoint2D *) &_result_ref;
8642 }
8643 wxPyEndAllowThreads(__tstate);
8644 if (PyErr_Occurred()) SWIG_fail;
8645 }
8646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8647 return resultobj;
8648 fail:
8649 return NULL;
8650 }
8651
8652
8653 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8654 PyObject *resultobj = 0;
8655 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8656 wxPoint2D *arg2 = 0 ;
8657 wxPoint2D *result = 0 ;
8658 void *argp1 = 0 ;
8659 int res1 = 0 ;
8660 wxPoint2D temp2 ;
8661 PyObject * obj0 = 0 ;
8662 PyObject * obj1 = 0 ;
8663 char * kwnames[] = {
8664 (char *) "self",(char *) "pt", NULL
8665 };
8666
8667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8669 if (!SWIG_IsOK(res1)) {
8670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8671 }
8672 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8673 {
8674 arg2 = &temp2;
8675 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8676 }
8677 {
8678 PyThreadState* __tstate = wxPyBeginAllowThreads();
8679 {
8680 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8681 result = (wxPoint2D *) &_result_ref;
8682 }
8683 wxPyEndAllowThreads(__tstate);
8684 if (PyErr_Occurred()) SWIG_fail;
8685 }
8686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 wxPoint2D *arg2 = 0 ;
8697 wxPoint2D *result = 0 ;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 wxPoint2D temp2 ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 char * kwnames[] = {
8704 (char *) "self",(char *) "pt", NULL
8705 };
8706
8707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8709 if (!SWIG_IsOK(res1)) {
8710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8711 }
8712 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8713 {
8714 arg2 = &temp2;
8715 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8716 }
8717 {
8718 PyThreadState* __tstate = wxPyBeginAllowThreads();
8719 {
8720 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8721 result = (wxPoint2D *) &_result_ref;
8722 }
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8734 PyObject *resultobj = 0;
8735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8736 PyObject *arg2 = (PyObject *) 0 ;
8737 bool result;
8738 void *argp1 = 0 ;
8739 int res1 = 0 ;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 char * kwnames[] = {
8743 (char *) "self",(char *) "other", NULL
8744 };
8745
8746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8748 if (!SWIG_IsOK(res1)) {
8749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8750 }
8751 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8752 arg2 = obj1;
8753 {
8754 result = (bool)wxPoint2D___eq__(arg1,arg2);
8755 if (PyErr_Occurred()) SWIG_fail;
8756 }
8757 {
8758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8759 }
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8767 PyObject *resultobj = 0;
8768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8769 PyObject *arg2 = (PyObject *) 0 ;
8770 bool result;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 PyObject * obj0 = 0 ;
8774 PyObject * obj1 = 0 ;
8775 char * kwnames[] = {
8776 (char *) "self",(char *) "other", NULL
8777 };
8778
8779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8781 if (!SWIG_IsOK(res1)) {
8782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8783 }
8784 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8785 arg2 = obj1;
8786 {
8787 result = (bool)wxPoint2D___ne__(arg1,arg2);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 {
8791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8792 }
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8800 PyObject *resultobj = 0;
8801 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8802 double arg2 ;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 double val2 ;
8806 int ecode2 = 0 ;
8807 PyObject *swig_obj[2] ;
8808
8809 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8811 if (!SWIG_IsOK(res1)) {
8812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8813 }
8814 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8815 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8816 if (!SWIG_IsOK(ecode2)) {
8817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8818 }
8819 arg2 = static_cast< double >(val2);
8820 if (arg1) (arg1)->m_x = arg2;
8821
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8830 PyObject *resultobj = 0;
8831 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8832 double result;
8833 void *argp1 = 0 ;
8834 int res1 = 0 ;
8835 PyObject *swig_obj[1] ;
8836
8837 if (!args) SWIG_fail;
8838 swig_obj[0] = args;
8839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8840 if (!SWIG_IsOK(res1)) {
8841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8842 }
8843 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8844 result = (double) ((arg1)->m_x);
8845 resultobj = SWIG_From_double(static_cast< double >(result));
8846 return resultobj;
8847 fail:
8848 return NULL;
8849 }
8850
8851
8852 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8853 PyObject *resultobj = 0;
8854 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8855 double arg2 ;
8856 void *argp1 = 0 ;
8857 int res1 = 0 ;
8858 double val2 ;
8859 int ecode2 = 0 ;
8860 PyObject *swig_obj[2] ;
8861
8862 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8864 if (!SWIG_IsOK(res1)) {
8865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8866 }
8867 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8868 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8869 if (!SWIG_IsOK(ecode2)) {
8870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8871 }
8872 arg2 = static_cast< double >(val2);
8873 if (arg1) (arg1)->m_y = arg2;
8874
8875 resultobj = SWIG_Py_Void();
8876 return resultobj;
8877 fail:
8878 return NULL;
8879 }
8880
8881
8882 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8883 PyObject *resultobj = 0;
8884 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8885 double result;
8886 void *argp1 = 0 ;
8887 int res1 = 0 ;
8888 PyObject *swig_obj[1] ;
8889
8890 if (!args) SWIG_fail;
8891 swig_obj[0] = args;
8892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8893 if (!SWIG_IsOK(res1)) {
8894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8895 }
8896 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8897 result = (double) ((arg1)->m_y);
8898 resultobj = SWIG_From_double(static_cast< double >(result));
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj = 0;
8907 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8908 double arg2 = (double) 0 ;
8909 double arg3 = (double) 0 ;
8910 void *argp1 = 0 ;
8911 int res1 = 0 ;
8912 double val2 ;
8913 int ecode2 = 0 ;
8914 double val3 ;
8915 int ecode3 = 0 ;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 PyObject * obj2 = 0 ;
8919 char * kwnames[] = {
8920 (char *) "self",(char *) "x",(char *) "y", NULL
8921 };
8922
8923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8925 if (!SWIG_IsOK(res1)) {
8926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8927 }
8928 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8929 if (obj1) {
8930 ecode2 = SWIG_AsVal_double(obj1, &val2);
8931 if (!SWIG_IsOK(ecode2)) {
8932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8933 }
8934 arg2 = static_cast< double >(val2);
8935 }
8936 if (obj2) {
8937 ecode3 = SWIG_AsVal_double(obj2, &val3);
8938 if (!SWIG_IsOK(ecode3)) {
8939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8940 }
8941 arg3 = static_cast< double >(val3);
8942 }
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 wxPoint2D_Set(arg1,arg2,arg3);
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *resultobj = 0;
8958 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8959 PyObject *result = 0 ;
8960 void *argp1 = 0 ;
8961 int res1 = 0 ;
8962 PyObject *swig_obj[1] ;
8963
8964 if (!args) SWIG_fail;
8965 swig_obj[0] = args;
8966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8967 if (!SWIG_IsOK(res1)) {
8968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8969 }
8970 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8971 {
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 result = (PyObject *)wxPoint2D_Get(arg1);
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 resultobj = result;
8978 return resultobj;
8979 fail:
8980 return NULL;
8981 }
8982
8983
8984 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8985 PyObject *obj;
8986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8987 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8988 return SWIG_Py_Void();
8989 }
8990
8991 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8992 return SWIG_Python_InitShadowInstance(args);
8993 }
8994
8995 SWIGINTERN int DefaultPosition_set(PyObject *) {
8996 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8997 return 1;
8998 }
8999
9000
9001 SWIGINTERN PyObject *DefaultPosition_get(void) {
9002 PyObject *pyobj = 0;
9003
9004 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9005 return pyobj;
9006 }
9007
9008
9009 SWIGINTERN int DefaultSize_set(PyObject *) {
9010 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9011 return 1;
9012 }
9013
9014
9015 SWIGINTERN PyObject *DefaultSize_get(void) {
9016 PyObject *pyobj = 0;
9017
9018 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9019 return pyobj;
9020 }
9021
9022
9023 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9024 PyObject *resultobj = 0;
9025 PyObject *arg1 = (PyObject *) 0 ;
9026 wxPyInputStream *result = 0 ;
9027 PyObject * obj0 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "p", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9033 arg1 = obj0;
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9041 return resultobj;
9042 fail:
9043 return NULL;
9044 }
9045
9046
9047 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9048 PyObject *resultobj = 0;
9049 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 PyObject *swig_obj[1] ;
9053
9054 if (!args) SWIG_fail;
9055 swig_obj[0] = args;
9056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9057 if (!SWIG_IsOK(res1)) {
9058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9059 }
9060 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 delete arg1;
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 resultobj = SWIG_Py_Void();
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9076 PyObject *resultobj = 0;
9077 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9078 void *argp1 = 0 ;
9079 int res1 = 0 ;
9080 PyObject *swig_obj[1] ;
9081
9082 if (!args) SWIG_fail;
9083 swig_obj[0] = args;
9084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9085 if (!SWIG_IsOK(res1)) {
9086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9087 }
9088 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9089 {
9090 PyThreadState* __tstate = wxPyBeginAllowThreads();
9091 (arg1)->close();
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 resultobj = SWIG_Py_Void();
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 PyObject *resultobj = 0;
9104 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9105 void *argp1 = 0 ;
9106 int res1 = 0 ;
9107 PyObject *swig_obj[1] ;
9108
9109 if (!args) SWIG_fail;
9110 swig_obj[0] = args;
9111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9112 if (!SWIG_IsOK(res1)) {
9113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9114 }
9115 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9116 {
9117 PyThreadState* __tstate = wxPyBeginAllowThreads();
9118 (arg1)->flush();
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 resultobj = SWIG_Py_Void();
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9130 PyObject *resultobj = 0;
9131 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9132 bool result;
9133 void *argp1 = 0 ;
9134 int res1 = 0 ;
9135 PyObject *swig_obj[1] ;
9136
9137 if (!args) SWIG_fail;
9138 swig_obj[0] = args;
9139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9140 if (!SWIG_IsOK(res1)) {
9141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9142 }
9143 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 result = (bool)(arg1)->eof();
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 {
9151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9152 }
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj = 0;
9161 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9162 int arg2 = (int) -1 ;
9163 PyObject *result = 0 ;
9164 void *argp1 = 0 ;
9165 int res1 = 0 ;
9166 int val2 ;
9167 int ecode2 = 0 ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 char * kwnames[] = {
9171 (char *) "self",(char *) "size", NULL
9172 };
9173
9174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9176 if (!SWIG_IsOK(res1)) {
9177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9178 }
9179 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9180 if (obj1) {
9181 ecode2 = SWIG_AsVal_int(obj1, &val2);
9182 if (!SWIG_IsOK(ecode2)) {
9183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9184 }
9185 arg2 = static_cast< int >(val2);
9186 }
9187 {
9188 PyThreadState* __tstate = wxPyBeginAllowThreads();
9189 result = (PyObject *)(arg1)->read(arg2);
9190 wxPyEndAllowThreads(__tstate);
9191 if (PyErr_Occurred()) SWIG_fail;
9192 }
9193 resultobj = result;
9194 return resultobj;
9195 fail:
9196 return NULL;
9197 }
9198
9199
9200 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9201 PyObject *resultobj = 0;
9202 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9203 int arg2 = (int) -1 ;
9204 PyObject *result = 0 ;
9205 void *argp1 = 0 ;
9206 int res1 = 0 ;
9207 int val2 ;
9208 int ecode2 = 0 ;
9209 PyObject * obj0 = 0 ;
9210 PyObject * obj1 = 0 ;
9211 char * kwnames[] = {
9212 (char *) "self",(char *) "size", NULL
9213 };
9214
9215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9217 if (!SWIG_IsOK(res1)) {
9218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9219 }
9220 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9221 if (obj1) {
9222 ecode2 = SWIG_AsVal_int(obj1, &val2);
9223 if (!SWIG_IsOK(ecode2)) {
9224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9225 }
9226 arg2 = static_cast< int >(val2);
9227 }
9228 {
9229 PyThreadState* __tstate = wxPyBeginAllowThreads();
9230 result = (PyObject *)(arg1)->readline(arg2);
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 resultobj = result;
9235 return resultobj;
9236 fail:
9237 return NULL;
9238 }
9239
9240
9241 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9242 PyObject *resultobj = 0;
9243 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9244 int arg2 = (int) -1 ;
9245 PyObject *result = 0 ;
9246 void *argp1 = 0 ;
9247 int res1 = 0 ;
9248 int val2 ;
9249 int ecode2 = 0 ;
9250 PyObject * obj0 = 0 ;
9251 PyObject * obj1 = 0 ;
9252 char * kwnames[] = {
9253 (char *) "self",(char *) "sizehint", NULL
9254 };
9255
9256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9258 if (!SWIG_IsOK(res1)) {
9259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9260 }
9261 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9262 if (obj1) {
9263 ecode2 = SWIG_AsVal_int(obj1, &val2);
9264 if (!SWIG_IsOK(ecode2)) {
9265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9266 }
9267 arg2 = static_cast< int >(val2);
9268 }
9269 {
9270 PyThreadState* __tstate = wxPyBeginAllowThreads();
9271 result = (PyObject *)(arg1)->readlines(arg2);
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = result;
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9283 PyObject *resultobj = 0;
9284 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9285 int arg2 ;
9286 int arg3 = (int) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 int val2 ;
9290 int ecode2 = 0 ;
9291 int val3 ;
9292 int ecode3 = 0 ;
9293 PyObject * obj0 = 0 ;
9294 PyObject * obj1 = 0 ;
9295 PyObject * obj2 = 0 ;
9296 char * kwnames[] = {
9297 (char *) "self",(char *) "offset",(char *) "whence", NULL
9298 };
9299
9300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9302 if (!SWIG_IsOK(res1)) {
9303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9304 }
9305 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9306 ecode2 = SWIG_AsVal_int(obj1, &val2);
9307 if (!SWIG_IsOK(ecode2)) {
9308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9309 }
9310 arg2 = static_cast< int >(val2);
9311 if (obj2) {
9312 ecode3 = SWIG_AsVal_int(obj2, &val3);
9313 if (!SWIG_IsOK(ecode3)) {
9314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9315 }
9316 arg3 = static_cast< int >(val3);
9317 }
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 (arg1)->seek(arg2,arg3);
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9332 PyObject *resultobj = 0;
9333 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9334 int result;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 PyObject *swig_obj[1] ;
9338
9339 if (!args) SWIG_fail;
9340 swig_obj[0] = args;
9341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9342 if (!SWIG_IsOK(res1)) {
9343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9344 }
9345 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (int)(arg1)->tell();
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 resultobj = SWIG_From_int(static_cast< int >(result));
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9360 PyObject *resultobj = 0;
9361 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9362 char result;
9363 void *argp1 = 0 ;
9364 int res1 = 0 ;
9365 PyObject *swig_obj[1] ;
9366
9367 if (!args) SWIG_fail;
9368 swig_obj[0] = args;
9369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9370 if (!SWIG_IsOK(res1)) {
9371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9372 }
9373 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9374 {
9375 PyThreadState* __tstate = wxPyBeginAllowThreads();
9376 result = (char)(arg1)->Peek();
9377 wxPyEndAllowThreads(__tstate);
9378 if (PyErr_Occurred()) SWIG_fail;
9379 }
9380 resultobj = SWIG_From_char(static_cast< char >(result));
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9388 PyObject *resultobj = 0;
9389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9390 char result;
9391 void *argp1 = 0 ;
9392 int res1 = 0 ;
9393 PyObject *swig_obj[1] ;
9394
9395 if (!args) SWIG_fail;
9396 swig_obj[0] = args;
9397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9398 if (!SWIG_IsOK(res1)) {
9399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9400 }
9401 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9402 {
9403 PyThreadState* __tstate = wxPyBeginAllowThreads();
9404 result = (char)(arg1)->GetC();
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_From_char(static_cast< char >(result));
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 PyObject *resultobj = 0;
9417 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9418 size_t result;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 PyObject *swig_obj[1] ;
9422
9423 if (!args) SWIG_fail;
9424 swig_obj[0] = args;
9425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9428 }
9429 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (size_t)(arg1)->LastRead();
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9437 return resultobj;
9438 fail:
9439 return NULL;
9440 }
9441
9442
9443 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9444 PyObject *resultobj = 0;
9445 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9446 bool result;
9447 void *argp1 = 0 ;
9448 int res1 = 0 ;
9449 PyObject *swig_obj[1] ;
9450
9451 if (!args) SWIG_fail;
9452 swig_obj[0] = args;
9453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9454 if (!SWIG_IsOK(res1)) {
9455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9456 }
9457 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9458 {
9459 PyThreadState* __tstate = wxPyBeginAllowThreads();
9460 result = (bool)(arg1)->CanRead();
9461 wxPyEndAllowThreads(__tstate);
9462 if (PyErr_Occurred()) SWIG_fail;
9463 }
9464 {
9465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9466 }
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9474 PyObject *resultobj = 0;
9475 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9476 bool result;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 PyObject *swig_obj[1] ;
9480
9481 if (!args) SWIG_fail;
9482 swig_obj[0] = args;
9483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9484 if (!SWIG_IsOK(res1)) {
9485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9486 }
9487 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9488 {
9489 PyThreadState* __tstate = wxPyBeginAllowThreads();
9490 result = (bool)(arg1)->Eof();
9491 wxPyEndAllowThreads(__tstate);
9492 if (PyErr_Occurred()) SWIG_fail;
9493 }
9494 {
9495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9496 }
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9504 PyObject *resultobj = 0;
9505 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9506 char arg2 ;
9507 bool result;
9508 void *argp1 = 0 ;
9509 int res1 = 0 ;
9510 char val2 ;
9511 int ecode2 = 0 ;
9512 PyObject * obj0 = 0 ;
9513 PyObject * obj1 = 0 ;
9514 char * kwnames[] = {
9515 (char *) "self",(char *) "c", NULL
9516 };
9517
9518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9520 if (!SWIG_IsOK(res1)) {
9521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9522 }
9523 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9524 ecode2 = SWIG_AsVal_char(obj1, &val2);
9525 if (!SWIG_IsOK(ecode2)) {
9526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9527 }
9528 arg2 = static_cast< char >(val2);
9529 {
9530 PyThreadState* __tstate = wxPyBeginAllowThreads();
9531 result = (bool)(arg1)->Ungetch(arg2);
9532 wxPyEndAllowThreads(__tstate);
9533 if (PyErr_Occurred()) SWIG_fail;
9534 }
9535 {
9536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9537 }
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj = 0;
9546 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9547 long arg2 ;
9548 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9549 long result;
9550 void *argp1 = 0 ;
9551 int res1 = 0 ;
9552 long val2 ;
9553 int ecode2 = 0 ;
9554 int val3 ;
9555 int ecode3 = 0 ;
9556 PyObject * obj0 = 0 ;
9557 PyObject * obj1 = 0 ;
9558 PyObject * obj2 = 0 ;
9559 char * kwnames[] = {
9560 (char *) "self",(char *) "pos",(char *) "mode", NULL
9561 };
9562
9563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9565 if (!SWIG_IsOK(res1)) {
9566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9567 }
9568 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9569 ecode2 = SWIG_AsVal_long(obj1, &val2);
9570 if (!SWIG_IsOK(ecode2)) {
9571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9572 }
9573 arg2 = static_cast< long >(val2);
9574 if (obj2) {
9575 ecode3 = SWIG_AsVal_int(obj2, &val3);
9576 if (!SWIG_IsOK(ecode3)) {
9577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9578 }
9579 arg3 = static_cast< wxSeekMode >(val3);
9580 }
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (long)(arg1)->SeekI(arg2,arg3);
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 resultobj = SWIG_From_long(static_cast< long >(result));
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9595 PyObject *resultobj = 0;
9596 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9597 long result;
9598 void *argp1 = 0 ;
9599 int res1 = 0 ;
9600 PyObject *swig_obj[1] ;
9601
9602 if (!args) SWIG_fail;
9603 swig_obj[0] = args;
9604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9605 if (!SWIG_IsOK(res1)) {
9606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9607 }
9608 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 result = (long)(arg1)->TellI();
9612 wxPyEndAllowThreads(__tstate);
9613 if (PyErr_Occurred()) SWIG_fail;
9614 }
9615 resultobj = SWIG_From_long(static_cast< long >(result));
9616 return resultobj;
9617 fail:
9618 return NULL;
9619 }
9620
9621
9622 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9623 PyObject *obj;
9624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9625 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9626 return SWIG_Py_Void();
9627 }
9628
9629 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9630 return SWIG_Python_InitShadowInstance(args);
9631 }
9632
9633 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj = 0;
9635 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9636 PyObject *arg2 = (PyObject *) 0 ;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 char * kwnames[] = {
9642 (char *) "self",(char *) "obj", NULL
9643 };
9644
9645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9647 if (!SWIG_IsOK(res1)) {
9648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9649 }
9650 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9651 arg2 = obj1;
9652 {
9653 PyThreadState* __tstate = wxPyBeginAllowThreads();
9654 wxOutputStream_write(arg1,arg2);
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_Py_Void();
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9666 PyObject *resultobj = 0;
9667 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9668 size_t result;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 PyObject *swig_obj[1] ;
9672
9673 if (!args) SWIG_fail;
9674 swig_obj[0] = args;
9675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9676 if (!SWIG_IsOK(res1)) {
9677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9678 }
9679 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9687 return resultobj;
9688 fail:
9689 return NULL;
9690 }
9691
9692
9693 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9694 PyObject *obj;
9695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9696 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9697 return SWIG_Py_Void();
9698 }
9699
9700 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9701 PyObject *resultobj = 0;
9702 wxInputStream *arg1 = (wxInputStream *) 0 ;
9703 wxString *arg2 = 0 ;
9704 wxString *arg3 = 0 ;
9705 wxString *arg4 = 0 ;
9706 wxDateTime arg5 ;
9707 wxFSFile *result = 0 ;
9708 wxPyInputStream *temp1 ;
9709 bool temp2 = false ;
9710 bool temp3 = false ;
9711 bool temp4 = false ;
9712 void *argp5 ;
9713 int res5 = 0 ;
9714 PyObject * obj0 = 0 ;
9715 PyObject * obj1 = 0 ;
9716 PyObject * obj2 = 0 ;
9717 PyObject * obj3 = 0 ;
9718 PyObject * obj4 = 0 ;
9719 char * kwnames[] = {
9720 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9721 };
9722
9723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9724 {
9725 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9726 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9727 } else {
9728 PyErr_Clear(); // clear the failure of the wxPyConvert above
9729 arg1 = wxPyCBInputStream_create(obj0, true);
9730 if (arg1 == NULL) {
9731 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9732 SWIG_fail;
9733 }
9734 }
9735 }
9736 {
9737 arg2 = wxString_in_helper(obj1);
9738 if (arg2 == NULL) SWIG_fail;
9739 temp2 = true;
9740 }
9741 {
9742 arg3 = wxString_in_helper(obj2);
9743 if (arg3 == NULL) SWIG_fail;
9744 temp3 = true;
9745 }
9746 {
9747 arg4 = wxString_in_helper(obj3);
9748 if (arg4 == NULL) SWIG_fail;
9749 temp4 = true;
9750 }
9751 {
9752 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9753 if (!SWIG_IsOK(res5)) {
9754 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9755 }
9756 if (!argp5) {
9757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9758 } else {
9759 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9760 arg5 = *temp;
9761 if (SWIG_IsNewObj(res5)) delete temp;
9762 }
9763 }
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9771 {
9772 if (temp2)
9773 delete arg2;
9774 }
9775 {
9776 if (temp3)
9777 delete arg3;
9778 }
9779 {
9780 if (temp4)
9781 delete arg4;
9782 }
9783 return resultobj;
9784 fail:
9785 {
9786 if (temp2)
9787 delete arg2;
9788 }
9789 {
9790 if (temp3)
9791 delete arg3;
9792 }
9793 {
9794 if (temp4)
9795 delete arg4;
9796 }
9797 return NULL;
9798 }
9799
9800
9801 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9802 PyObject *resultobj = 0;
9803 wxFSFile *arg1 = (wxFSFile *) 0 ;
9804 void *argp1 = 0 ;
9805 int res1 = 0 ;
9806 PyObject *swig_obj[1] ;
9807
9808 if (!args) SWIG_fail;
9809 swig_obj[0] = args;
9810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9811 if (!SWIG_IsOK(res1)) {
9812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9813 }
9814 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9815 {
9816 PyThreadState* __tstate = wxPyBeginAllowThreads();
9817 delete arg1;
9818
9819 wxPyEndAllowThreads(__tstate);
9820 if (PyErr_Occurred()) SWIG_fail;
9821 }
9822 resultobj = SWIG_Py_Void();
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 PyObject *resultobj = 0;
9831 wxFSFile *arg1 = (wxFSFile *) 0 ;
9832 wxInputStream *result = 0 ;
9833 void *argp1 = 0 ;
9834 int res1 = 0 ;
9835 PyObject *swig_obj[1] ;
9836
9837 if (!args) SWIG_fail;
9838 swig_obj[0] = args;
9839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9840 if (!SWIG_IsOK(res1)) {
9841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9842 }
9843 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = (wxInputStream *)(arg1)->GetStream();
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 {
9851 wxPyInputStream * _ptr = NULL;
9852
9853 if (result) {
9854 _ptr = new wxPyInputStream(result);
9855 }
9856 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9857 }
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9865 PyObject *resultobj = 0;
9866 wxFSFile *arg1 = (wxFSFile *) 0 ;
9867 wxString *result = 0 ;
9868 void *argp1 = 0 ;
9869 int res1 = 0 ;
9870 PyObject *swig_obj[1] ;
9871
9872 if (!args) SWIG_fail;
9873 swig_obj[0] = args;
9874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9875 if (!SWIG_IsOK(res1)) {
9876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9877 }
9878 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 {
9882 wxString const &_result_ref = (arg1)->GetMimeType();
9883 result = (wxString *) &_result_ref;
9884 }
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 #if wxUSE_UNICODE
9890 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9891 #else
9892 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9893 #endif
9894 }
9895 return resultobj;
9896 fail:
9897 return NULL;
9898 }
9899
9900
9901 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 PyObject *resultobj = 0;
9903 wxFSFile *arg1 = (wxFSFile *) 0 ;
9904 wxString *result = 0 ;
9905 void *argp1 = 0 ;
9906 int res1 = 0 ;
9907 PyObject *swig_obj[1] ;
9908
9909 if (!args) SWIG_fail;
9910 swig_obj[0] = args;
9911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9912 if (!SWIG_IsOK(res1)) {
9913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9914 }
9915 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9916 {
9917 PyThreadState* __tstate = wxPyBeginAllowThreads();
9918 {
9919 wxString const &_result_ref = (arg1)->GetLocation();
9920 result = (wxString *) &_result_ref;
9921 }
9922 wxPyEndAllowThreads(__tstate);
9923 if (PyErr_Occurred()) SWIG_fail;
9924 }
9925 {
9926 #if wxUSE_UNICODE
9927 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9928 #else
9929 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9930 #endif
9931 }
9932 return resultobj;
9933 fail:
9934 return NULL;
9935 }
9936
9937
9938 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9939 PyObject *resultobj = 0;
9940 wxFSFile *arg1 = (wxFSFile *) 0 ;
9941 wxString *result = 0 ;
9942 void *argp1 = 0 ;
9943 int res1 = 0 ;
9944 PyObject *swig_obj[1] ;
9945
9946 if (!args) SWIG_fail;
9947 swig_obj[0] = args;
9948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9949 if (!SWIG_IsOK(res1)) {
9950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9951 }
9952 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 {
9956 wxString const &_result_ref = (arg1)->GetAnchor();
9957 result = (wxString *) &_result_ref;
9958 }
9959 wxPyEndAllowThreads(__tstate);
9960 if (PyErr_Occurred()) SWIG_fail;
9961 }
9962 {
9963 #if wxUSE_UNICODE
9964 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9965 #else
9966 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9967 #endif
9968 }
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9976 PyObject *resultobj = 0;
9977 wxFSFile *arg1 = (wxFSFile *) 0 ;
9978 wxDateTime result;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 PyObject *swig_obj[1] ;
9982
9983 if (!args) SWIG_fail;
9984 swig_obj[0] = args;
9985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9986 if (!SWIG_IsOK(res1)) {
9987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9988 }
9989 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 result = (arg1)->GetModificationTime();
9993 wxPyEndAllowThreads(__tstate);
9994 if (PyErr_Occurred()) SWIG_fail;
9995 }
9996 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9997 return resultobj;
9998 fail:
9999 return NULL;
10000 }
10001
10002
10003 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10004 PyObject *obj;
10005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10006 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10007 return SWIG_Py_Void();
10008 }
10009
10010 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10011 return SWIG_Python_InitShadowInstance(args);
10012 }
10013
10014 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10015 PyObject *resultobj = 0;
10016 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10017 void *argp1 = 0 ;
10018 int res1 = 0 ;
10019 PyObject *swig_obj[1] ;
10020
10021 if (!args) SWIG_fail;
10022 swig_obj[0] = args;
10023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10026 }
10027 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10028 {
10029 PyThreadState* __tstate = wxPyBeginAllowThreads();
10030 delete arg1;
10031
10032 wxPyEndAllowThreads(__tstate);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 resultobj = SWIG_Py_Void();
10036 return resultobj;
10037 fail:
10038 return NULL;
10039 }
10040
10041
10042 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *obj;
10044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10045 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10046 return SWIG_Py_Void();
10047 }
10048
10049 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10050 PyObject *resultobj = 0;
10051 wxPyFileSystemHandler *result = 0 ;
10052
10053 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10061 return resultobj;
10062 fail:
10063 return NULL;
10064 }
10065
10066
10067 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10068 PyObject *resultobj = 0;
10069 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10070 PyObject *arg2 = (PyObject *) 0 ;
10071 PyObject *arg3 = (PyObject *) 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 PyObject * obj0 = 0 ;
10075 PyObject * obj1 = 0 ;
10076 PyObject * obj2 = 0 ;
10077 char * kwnames[] = {
10078 (char *) "self",(char *) "self",(char *) "_class", NULL
10079 };
10080
10081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10083 if (!SWIG_IsOK(res1)) {
10084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10085 }
10086 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10087 arg2 = obj1;
10088 arg3 = obj2;
10089 {
10090 PyThreadState* __tstate = wxPyBeginAllowThreads();
10091 (arg1)->_setCallbackInfo(arg2,arg3);
10092 wxPyEndAllowThreads(__tstate);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 resultobj = SWIG_Py_Void();
10096 return resultobj;
10097 fail:
10098 return NULL;
10099 }
10100
10101
10102 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj = 0;
10104 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10105 wxString *arg2 = 0 ;
10106 bool result;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 bool temp2 = false ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char * kwnames[] = {
10113 (char *) "self",(char *) "location", NULL
10114 };
10115
10116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10120 }
10121 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10122 {
10123 arg2 = wxString_in_helper(obj1);
10124 if (arg2 == NULL) SWIG_fail;
10125 temp2 = true;
10126 }
10127 {
10128 PyThreadState* __tstate = wxPyBeginAllowThreads();
10129 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 {
10134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10135 }
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj = 0;
10152 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10153 wxFileSystem *arg2 = 0 ;
10154 wxString *arg3 = 0 ;
10155 wxFSFile *result = 0 ;
10156 void *argp1 = 0 ;
10157 int res1 = 0 ;
10158 void *argp2 = 0 ;
10159 int res2 = 0 ;
10160 bool temp3 = false ;
10161 PyObject * obj0 = 0 ;
10162 PyObject * obj1 = 0 ;
10163 PyObject * obj2 = 0 ;
10164 char * kwnames[] = {
10165 (char *) "self",(char *) "fs",(char *) "location", NULL
10166 };
10167
10168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10170 if (!SWIG_IsOK(res1)) {
10171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10172 }
10173 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10174 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10175 if (!SWIG_IsOK(res2)) {
10176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10177 }
10178 if (!argp2) {
10179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10180 }
10181 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10182 {
10183 arg3 = wxString_in_helper(obj2);
10184 if (arg3 == NULL) SWIG_fail;
10185 temp3 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 {
10194 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10195 }
10196 {
10197 if (temp3)
10198 delete arg3;
10199 }
10200 return resultobj;
10201 fail:
10202 {
10203 if (temp3)
10204 delete arg3;
10205 }
10206 return NULL;
10207 }
10208
10209
10210 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10211 PyObject *resultobj = 0;
10212 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10213 wxString *arg2 = 0 ;
10214 int arg3 = (int) 0 ;
10215 wxString result;
10216 void *argp1 = 0 ;
10217 int res1 = 0 ;
10218 bool temp2 = false ;
10219 int val3 ;
10220 int ecode3 = 0 ;
10221 PyObject * obj0 = 0 ;
10222 PyObject * obj1 = 0 ;
10223 PyObject * obj2 = 0 ;
10224 char * kwnames[] = {
10225 (char *) "self",(char *) "spec",(char *) "flags", NULL
10226 };
10227
10228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10230 if (!SWIG_IsOK(res1)) {
10231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10232 }
10233 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10234 {
10235 arg2 = wxString_in_helper(obj1);
10236 if (arg2 == NULL) SWIG_fail;
10237 temp2 = true;
10238 }
10239 if (obj2) {
10240 ecode3 = SWIG_AsVal_int(obj2, &val3);
10241 if (!SWIG_IsOK(ecode3)) {
10242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10243 }
10244 arg3 = static_cast< int >(val3);
10245 }
10246 {
10247 PyThreadState* __tstate = wxPyBeginAllowThreads();
10248 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10249 wxPyEndAllowThreads(__tstate);
10250 if (PyErr_Occurred()) SWIG_fail;
10251 }
10252 {
10253 #if wxUSE_UNICODE
10254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10255 #else
10256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10257 #endif
10258 }
10259 {
10260 if (temp2)
10261 delete arg2;
10262 }
10263 return resultobj;
10264 fail:
10265 {
10266 if (temp2)
10267 delete arg2;
10268 }
10269 return NULL;
10270 }
10271
10272
10273 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10274 PyObject *resultobj = 0;
10275 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10276 wxString result;
10277 void *argp1 = 0 ;
10278 int res1 = 0 ;
10279 PyObject *swig_obj[1] ;
10280
10281 if (!args) SWIG_fail;
10282 swig_obj[0] = args;
10283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10284 if (!SWIG_IsOK(res1)) {
10285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10286 }
10287 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10288 {
10289 PyThreadState* __tstate = wxPyBeginAllowThreads();
10290 result = (arg1)->FindNext();
10291 wxPyEndAllowThreads(__tstate);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 {
10295 #if wxUSE_UNICODE
10296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10297 #else
10298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10299 #endif
10300 }
10301 return resultobj;
10302 fail:
10303 return NULL;
10304 }
10305
10306
10307 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj = 0;
10309 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10310 wxString *arg2 = 0 ;
10311 wxString result;
10312 void *argp1 = 0 ;
10313 int res1 = 0 ;
10314 bool temp2 = false ;
10315 PyObject * obj0 = 0 ;
10316 PyObject * obj1 = 0 ;
10317 char * kwnames[] = {
10318 (char *) "self",(char *) "location", NULL
10319 };
10320
10321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10323 if (!SWIG_IsOK(res1)) {
10324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10325 }
10326 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10327 {
10328 arg2 = wxString_in_helper(obj1);
10329 if (arg2 == NULL) SWIG_fail;
10330 temp2 = true;
10331 }
10332 {
10333 PyThreadState* __tstate = wxPyBeginAllowThreads();
10334 result = (arg1)->GetProtocol((wxString const &)*arg2);
10335 wxPyEndAllowThreads(__tstate);
10336 if (PyErr_Occurred()) SWIG_fail;
10337 }
10338 {
10339 #if wxUSE_UNICODE
10340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10341 #else
10342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10343 #endif
10344 }
10345 {
10346 if (temp2)
10347 delete arg2;
10348 }
10349 return resultobj;
10350 fail:
10351 {
10352 if (temp2)
10353 delete arg2;
10354 }
10355 return NULL;
10356 }
10357
10358
10359 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj = 0;
10361 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10362 wxString *arg2 = 0 ;
10363 wxString result;
10364 void *argp1 = 0 ;
10365 int res1 = 0 ;
10366 bool temp2 = false ;
10367 PyObject * obj0 = 0 ;
10368 PyObject * obj1 = 0 ;
10369 char * kwnames[] = {
10370 (char *) "self",(char *) "location", NULL
10371 };
10372
10373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10375 if (!SWIG_IsOK(res1)) {
10376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10377 }
10378 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10379 {
10380 arg2 = wxString_in_helper(obj1);
10381 if (arg2 == NULL) SWIG_fail;
10382 temp2 = true;
10383 }
10384 {
10385 PyThreadState* __tstate = wxPyBeginAllowThreads();
10386 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10387 wxPyEndAllowThreads(__tstate);
10388 if (PyErr_Occurred()) SWIG_fail;
10389 }
10390 {
10391 #if wxUSE_UNICODE
10392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10393 #else
10394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10395 #endif
10396 }
10397 {
10398 if (temp2)
10399 delete arg2;
10400 }
10401 return resultobj;
10402 fail:
10403 {
10404 if (temp2)
10405 delete arg2;
10406 }
10407 return NULL;
10408 }
10409
10410
10411 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10412 PyObject *resultobj = 0;
10413 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10414 wxString *arg2 = 0 ;
10415 wxString result;
10416 void *argp1 = 0 ;
10417 int res1 = 0 ;
10418 bool temp2 = false ;
10419 PyObject * obj0 = 0 ;
10420 PyObject * obj1 = 0 ;
10421 char * kwnames[] = {
10422 (char *) "self",(char *) "location", NULL
10423 };
10424
10425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10427 if (!SWIG_IsOK(res1)) {
10428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10429 }
10430 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10431 {
10432 arg2 = wxString_in_helper(obj1);
10433 if (arg2 == NULL) SWIG_fail;
10434 temp2 = true;
10435 }
10436 {
10437 PyThreadState* __tstate = wxPyBeginAllowThreads();
10438 result = (arg1)->GetAnchor((wxString const &)*arg2);
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 {
10443 #if wxUSE_UNICODE
10444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10445 #else
10446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10447 #endif
10448 }
10449 {
10450 if (temp2)
10451 delete arg2;
10452 }
10453 return resultobj;
10454 fail:
10455 {
10456 if (temp2)
10457 delete arg2;
10458 }
10459 return NULL;
10460 }
10461
10462
10463 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10464 PyObject *resultobj = 0;
10465 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10466 wxString *arg2 = 0 ;
10467 wxString result;
10468 void *argp1 = 0 ;
10469 int res1 = 0 ;
10470 bool temp2 = false ;
10471 PyObject * obj0 = 0 ;
10472 PyObject * obj1 = 0 ;
10473 char * kwnames[] = {
10474 (char *) "self",(char *) "location", NULL
10475 };
10476
10477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10479 if (!SWIG_IsOK(res1)) {
10480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10481 }
10482 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10483 {
10484 arg2 = wxString_in_helper(obj1);
10485 if (arg2 == NULL) SWIG_fail;
10486 temp2 = true;
10487 }
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 {
10495 #if wxUSE_UNICODE
10496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10497 #else
10498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10499 #endif
10500 }
10501 {
10502 if (temp2)
10503 delete arg2;
10504 }
10505 return resultobj;
10506 fail:
10507 {
10508 if (temp2)
10509 delete arg2;
10510 }
10511 return NULL;
10512 }
10513
10514
10515 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10516 PyObject *resultobj = 0;
10517 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10518 wxString *arg2 = 0 ;
10519 wxString result;
10520 void *argp1 = 0 ;
10521 int res1 = 0 ;
10522 bool temp2 = false ;
10523 PyObject * obj0 = 0 ;
10524 PyObject * obj1 = 0 ;
10525 char * kwnames[] = {
10526 (char *) "self",(char *) "location", NULL
10527 };
10528
10529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10533 }
10534 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 {
10547 #if wxUSE_UNICODE
10548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10549 #else
10550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10551 #endif
10552 }
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return resultobj;
10558 fail:
10559 {
10560 if (temp2)
10561 delete arg2;
10562 }
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568 PyObject *obj;
10569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10570 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10571 return SWIG_Py_Void();
10572 }
10573
10574 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10575 return SWIG_Python_InitShadowInstance(args);
10576 }
10577
10578 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10579 PyObject *resultobj = 0;
10580 wxFileSystem *result = 0 ;
10581
10582 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxFileSystem *)new wxFileSystem();
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 {
10590 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10591 }
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10599 PyObject *resultobj = 0;
10600 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10601 void *argp1 = 0 ;
10602 int res1 = 0 ;
10603 PyObject *swig_obj[1] ;
10604
10605 if (!args) SWIG_fail;
10606 swig_obj[0] = args;
10607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10608 if (!SWIG_IsOK(res1)) {
10609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10610 }
10611 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 delete arg1;
10615
10616 wxPyEndAllowThreads(__tstate);
10617 if (PyErr_Occurred()) SWIG_fail;
10618 }
10619 resultobj = SWIG_Py_Void();
10620 return resultobj;
10621 fail:
10622 return NULL;
10623 }
10624
10625
10626 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10627 PyObject *resultobj = 0;
10628 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10629 wxString *arg2 = 0 ;
10630 bool arg3 = (bool) false ;
10631 void *argp1 = 0 ;
10632 int res1 = 0 ;
10633 bool temp2 = false ;
10634 bool val3 ;
10635 int ecode3 = 0 ;
10636 PyObject * obj0 = 0 ;
10637 PyObject * obj1 = 0 ;
10638 PyObject * obj2 = 0 ;
10639 char * kwnames[] = {
10640 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10641 };
10642
10643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10645 if (!SWIG_IsOK(res1)) {
10646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10647 }
10648 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10649 {
10650 arg2 = wxString_in_helper(obj1);
10651 if (arg2 == NULL) SWIG_fail;
10652 temp2 = true;
10653 }
10654 if (obj2) {
10655 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10656 if (!SWIG_IsOK(ecode3)) {
10657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10658 }
10659 arg3 = static_cast< bool >(val3);
10660 }
10661 {
10662 PyThreadState* __tstate = wxPyBeginAllowThreads();
10663 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10664 wxPyEndAllowThreads(__tstate);
10665 if (PyErr_Occurred()) SWIG_fail;
10666 }
10667 resultobj = SWIG_Py_Void();
10668 {
10669 if (temp2)
10670 delete arg2;
10671 }
10672 return resultobj;
10673 fail:
10674 {
10675 if (temp2)
10676 delete arg2;
10677 }
10678 return NULL;
10679 }
10680
10681
10682 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10683 PyObject *resultobj = 0;
10684 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10685 wxString result;
10686 void *argp1 = 0 ;
10687 int res1 = 0 ;
10688 PyObject *swig_obj[1] ;
10689
10690 if (!args) SWIG_fail;
10691 swig_obj[0] = args;
10692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10693 if (!SWIG_IsOK(res1)) {
10694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10695 }
10696 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 result = (arg1)->GetPath();
10700 wxPyEndAllowThreads(__tstate);
10701 if (PyErr_Occurred()) SWIG_fail;
10702 }
10703 {
10704 #if wxUSE_UNICODE
10705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10706 #else
10707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10708 #endif
10709 }
10710 return resultobj;
10711 fail:
10712 return NULL;
10713 }
10714
10715
10716 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10717 PyObject *resultobj = 0;
10718 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10719 wxString *arg2 = 0 ;
10720 wxFSFile *result = 0 ;
10721 void *argp1 = 0 ;
10722 int res1 = 0 ;
10723 bool temp2 = false ;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 char * kwnames[] = {
10727 (char *) "self",(char *) "location", NULL
10728 };
10729
10730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10732 if (!SWIG_IsOK(res1)) {
10733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10734 }
10735 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10736 {
10737 arg2 = wxString_in_helper(obj1);
10738 if (arg2 == NULL) SWIG_fail;
10739 temp2 = true;
10740 }
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 {
10748 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10749 }
10750 {
10751 if (temp2)
10752 delete arg2;
10753 }
10754 return resultobj;
10755 fail:
10756 {
10757 if (temp2)
10758 delete arg2;
10759 }
10760 return NULL;
10761 }
10762
10763
10764 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj = 0;
10766 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10767 wxString *arg2 = 0 ;
10768 int arg3 = (int) 0 ;
10769 wxString result;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 bool temp2 = false ;
10773 int val3 ;
10774 int ecode3 = 0 ;
10775 PyObject * obj0 = 0 ;
10776 PyObject * obj1 = 0 ;
10777 PyObject * obj2 = 0 ;
10778 char * kwnames[] = {
10779 (char *) "self",(char *) "spec",(char *) "flags", NULL
10780 };
10781
10782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10784 if (!SWIG_IsOK(res1)) {
10785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10786 }
10787 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10788 {
10789 arg2 = wxString_in_helper(obj1);
10790 if (arg2 == NULL) SWIG_fail;
10791 temp2 = true;
10792 }
10793 if (obj2) {
10794 ecode3 = SWIG_AsVal_int(obj2, &val3);
10795 if (!SWIG_IsOK(ecode3)) {
10796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10797 }
10798 arg3 = static_cast< int >(val3);
10799 }
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 {
10807 #if wxUSE_UNICODE
10808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10809 #else
10810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10811 #endif
10812 }
10813 {
10814 if (temp2)
10815 delete arg2;
10816 }
10817 return resultobj;
10818 fail:
10819 {
10820 if (temp2)
10821 delete arg2;
10822 }
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10828 PyObject *resultobj = 0;
10829 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10830 wxString result;
10831 void *argp1 = 0 ;
10832 int res1 = 0 ;
10833 PyObject *swig_obj[1] ;
10834
10835 if (!args) SWIG_fail;
10836 swig_obj[0] = args;
10837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10838 if (!SWIG_IsOK(res1)) {
10839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10840 }
10841 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 result = (arg1)->FindNext();
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 {
10849 #if wxUSE_UNICODE
10850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10851 #else
10852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10853 #endif
10854 }
10855 return resultobj;
10856 fail:
10857 return NULL;
10858 }
10859
10860
10861 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj = 0;
10863 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10864 int res1 = 0 ;
10865 PyObject * obj0 = 0 ;
10866 char * kwnames[] = {
10867 (char *) "handler", NULL
10868 };
10869
10870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10871 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10872 if (!SWIG_IsOK(res1)) {
10873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10874 }
10875 {
10876 PyThreadState* __tstate = wxPyBeginAllowThreads();
10877 wxFileSystem::AddHandler(arg1);
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 resultobj = SWIG_Py_Void();
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10889 PyObject *resultobj = 0;
10890
10891 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 wxFileSystem::CleanUpHandlers();
10895 wxPyEndAllowThreads(__tstate);
10896 if (PyErr_Occurred()) SWIG_fail;
10897 }
10898 resultobj = SWIG_Py_Void();
10899 return resultobj;
10900 fail:
10901 return NULL;
10902 }
10903
10904
10905 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10906 PyObject *resultobj = 0;
10907 wxString *arg1 = 0 ;
10908 wxString result;
10909 bool temp1 = false ;
10910 PyObject * obj0 = 0 ;
10911 char * kwnames[] = {
10912 (char *) "filename", NULL
10913 };
10914
10915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10916 {
10917 arg1 = wxString_in_helper(obj0);
10918 if (arg1 == NULL) SWIG_fail;
10919 temp1 = true;
10920 }
10921 {
10922 PyThreadState* __tstate = wxPyBeginAllowThreads();
10923 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10924 wxPyEndAllowThreads(__tstate);
10925 if (PyErr_Occurred()) SWIG_fail;
10926 }
10927 {
10928 #if wxUSE_UNICODE
10929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10930 #else
10931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10932 #endif
10933 }
10934 {
10935 if (temp1)
10936 delete arg1;
10937 }
10938 return resultobj;
10939 fail:
10940 {
10941 if (temp1)
10942 delete arg1;
10943 }
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxString *arg1 = 0 ;
10951 wxString result;
10952 bool temp1 = false ;
10953 PyObject * obj0 = 0 ;
10954 char * kwnames[] = {
10955 (char *) "url", NULL
10956 };
10957
10958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10959 {
10960 arg1 = wxString_in_helper(obj0);
10961 if (arg1 == NULL) SWIG_fail;
10962 temp1 = true;
10963 }
10964 {
10965 PyThreadState* __tstate = wxPyBeginAllowThreads();
10966 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 {
10971 #if wxUSE_UNICODE
10972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10973 #else
10974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10975 #endif
10976 }
10977 {
10978 if (temp1)
10979 delete arg1;
10980 }
10981 return resultobj;
10982 fail:
10983 {
10984 if (temp1)
10985 delete arg1;
10986 }
10987 return NULL;
10988 }
10989
10990
10991 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10992 PyObject *obj;
10993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10994 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10995 return SWIG_Py_Void();
10996 }
10997
10998 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10999 return SWIG_Python_InitShadowInstance(args);
11000 }
11001
11002 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11003 PyObject *resultobj = 0;
11004 wxInternetFSHandler *result = 0 ;
11005
11006 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11007 {
11008 PyThreadState* __tstate = wxPyBeginAllowThreads();
11009 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11010 wxPyEndAllowThreads(__tstate);
11011 if (PyErr_Occurred()) SWIG_fail;
11012 }
11013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11014 return resultobj;
11015 fail:
11016 return NULL;
11017 }
11018
11019
11020 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11021 PyObject *resultobj = 0;
11022 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11023 wxString *arg2 = 0 ;
11024 bool result;
11025 void *argp1 = 0 ;
11026 int res1 = 0 ;
11027 bool temp2 = false ;
11028 PyObject * obj0 = 0 ;
11029 PyObject * obj1 = 0 ;
11030 char * kwnames[] = {
11031 (char *) "self",(char *) "location", NULL
11032 };
11033
11034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11036 if (!SWIG_IsOK(res1)) {
11037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11038 }
11039 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11040 {
11041 arg2 = wxString_in_helper(obj1);
11042 if (arg2 == NULL) SWIG_fail;
11043 temp2 = true;
11044 }
11045 {
11046 PyThreadState* __tstate = wxPyBeginAllowThreads();
11047 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11048 wxPyEndAllowThreads(__tstate);
11049 if (PyErr_Occurred()) SWIG_fail;
11050 }
11051 {
11052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11053 }
11054 {
11055 if (temp2)
11056 delete arg2;
11057 }
11058 return resultobj;
11059 fail:
11060 {
11061 if (temp2)
11062 delete arg2;
11063 }
11064 return NULL;
11065 }
11066
11067
11068 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11069 PyObject *resultobj = 0;
11070 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11071 wxFileSystem *arg2 = 0 ;
11072 wxString *arg3 = 0 ;
11073 wxFSFile *result = 0 ;
11074 void *argp1 = 0 ;
11075 int res1 = 0 ;
11076 void *argp2 = 0 ;
11077 int res2 = 0 ;
11078 bool temp3 = false ;
11079 PyObject * obj0 = 0 ;
11080 PyObject * obj1 = 0 ;
11081 PyObject * obj2 = 0 ;
11082 char * kwnames[] = {
11083 (char *) "self",(char *) "fs",(char *) "location", NULL
11084 };
11085
11086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11088 if (!SWIG_IsOK(res1)) {
11089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11090 }
11091 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11092 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11093 if (!SWIG_IsOK(res2)) {
11094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11095 }
11096 if (!argp2) {
11097 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11098 }
11099 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11100 {
11101 arg3 = wxString_in_helper(obj2);
11102 if (arg3 == NULL) SWIG_fail;
11103 temp3 = true;
11104 }
11105 {
11106 PyThreadState* __tstate = wxPyBeginAllowThreads();
11107 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11108 wxPyEndAllowThreads(__tstate);
11109 if (PyErr_Occurred()) SWIG_fail;
11110 }
11111 {
11112 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11113 }
11114 {
11115 if (temp3)
11116 delete arg3;
11117 }
11118 return resultobj;
11119 fail:
11120 {
11121 if (temp3)
11122 delete arg3;
11123 }
11124 return NULL;
11125 }
11126
11127
11128 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11129 PyObject *obj;
11130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11131 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11132 return SWIG_Py_Void();
11133 }
11134
11135 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11136 return SWIG_Python_InitShadowInstance(args);
11137 }
11138
11139 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxZipFSHandler *result = 0 ;
11142
11143 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 result = (wxZipFSHandler *)new wxZipFSHandler();
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11158 PyObject *resultobj = 0;
11159 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11160 wxString *arg2 = 0 ;
11161 bool result;
11162 void *argp1 = 0 ;
11163 int res1 = 0 ;
11164 bool temp2 = false ;
11165 PyObject * obj0 = 0 ;
11166 PyObject * obj1 = 0 ;
11167 char * kwnames[] = {
11168 (char *) "self",(char *) "location", NULL
11169 };
11170
11171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11173 if (!SWIG_IsOK(res1)) {
11174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11175 }
11176 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11177 {
11178 arg2 = wxString_in_helper(obj1);
11179 if (arg2 == NULL) SWIG_fail;
11180 temp2 = true;
11181 }
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11185 wxPyEndAllowThreads(__tstate);
11186 if (PyErr_Occurred()) SWIG_fail;
11187 }
11188 {
11189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11190 }
11191 {
11192 if (temp2)
11193 delete arg2;
11194 }
11195 return resultobj;
11196 fail:
11197 {
11198 if (temp2)
11199 delete arg2;
11200 }
11201 return NULL;
11202 }
11203
11204
11205 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj = 0;
11207 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11208 wxFileSystem *arg2 = 0 ;
11209 wxString *arg3 = 0 ;
11210 wxFSFile *result = 0 ;
11211 void *argp1 = 0 ;
11212 int res1 = 0 ;
11213 void *argp2 = 0 ;
11214 int res2 = 0 ;
11215 bool temp3 = false ;
11216 PyObject * obj0 = 0 ;
11217 PyObject * obj1 = 0 ;
11218 PyObject * obj2 = 0 ;
11219 char * kwnames[] = {
11220 (char *) "self",(char *) "fs",(char *) "location", NULL
11221 };
11222
11223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11225 if (!SWIG_IsOK(res1)) {
11226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11227 }
11228 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11229 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11230 if (!SWIG_IsOK(res2)) {
11231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11232 }
11233 if (!argp2) {
11234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11235 }
11236 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11237 {
11238 arg3 = wxString_in_helper(obj2);
11239 if (arg3 == NULL) SWIG_fail;
11240 temp3 = true;
11241 }
11242 {
11243 PyThreadState* __tstate = wxPyBeginAllowThreads();
11244 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 {
11249 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11250 }
11251 {
11252 if (temp3)
11253 delete arg3;
11254 }
11255 return resultobj;
11256 fail:
11257 {
11258 if (temp3)
11259 delete arg3;
11260 }
11261 return NULL;
11262 }
11263
11264
11265 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11266 PyObject *resultobj = 0;
11267 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11268 wxString *arg2 = 0 ;
11269 int arg3 = (int) 0 ;
11270 wxString result;
11271 void *argp1 = 0 ;
11272 int res1 = 0 ;
11273 bool temp2 = false ;
11274 int val3 ;
11275 int ecode3 = 0 ;
11276 PyObject * obj0 = 0 ;
11277 PyObject * obj1 = 0 ;
11278 PyObject * obj2 = 0 ;
11279 char * kwnames[] = {
11280 (char *) "self",(char *) "spec",(char *) "flags", NULL
11281 };
11282
11283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11285 if (!SWIG_IsOK(res1)) {
11286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11287 }
11288 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11289 {
11290 arg2 = wxString_in_helper(obj1);
11291 if (arg2 == NULL) SWIG_fail;
11292 temp2 = true;
11293 }
11294 if (obj2) {
11295 ecode3 = SWIG_AsVal_int(obj2, &val3);
11296 if (!SWIG_IsOK(ecode3)) {
11297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11298 }
11299 arg3 = static_cast< int >(val3);
11300 }
11301 {
11302 PyThreadState* __tstate = wxPyBeginAllowThreads();
11303 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 {
11308 #if wxUSE_UNICODE
11309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11310 #else
11311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11312 #endif
11313 }
11314 {
11315 if (temp2)
11316 delete arg2;
11317 }
11318 return resultobj;
11319 fail:
11320 {
11321 if (temp2)
11322 delete arg2;
11323 }
11324 return NULL;
11325 }
11326
11327
11328 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11329 PyObject *resultobj = 0;
11330 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11331 wxString result;
11332 void *argp1 = 0 ;
11333 int res1 = 0 ;
11334 PyObject *swig_obj[1] ;
11335
11336 if (!args) SWIG_fail;
11337 swig_obj[0] = args;
11338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11339 if (!SWIG_IsOK(res1)) {
11340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11341 }
11342 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 result = (arg1)->FindNext();
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 {
11350 #if wxUSE_UNICODE
11351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11352 #else
11353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11354 #endif
11355 }
11356 return resultobj;
11357 fail:
11358 return NULL;
11359 }
11360
11361
11362 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11363 PyObject *obj;
11364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11365 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11366 return SWIG_Py_Void();
11367 }
11368
11369 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11370 return SWIG_Python_InitShadowInstance(args);
11371 }
11372
11373 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 wxString *arg1 = 0 ;
11376 wxImage *arg2 = 0 ;
11377 long arg3 ;
11378 bool temp1 = false ;
11379 void *argp2 = 0 ;
11380 int res2 = 0 ;
11381 long val3 ;
11382 int ecode3 = 0 ;
11383 PyObject * obj0 = 0 ;
11384 PyObject * obj1 = 0 ;
11385 PyObject * obj2 = 0 ;
11386 char * kwnames[] = {
11387 (char *) "filename",(char *) "image",(char *) "type", NULL
11388 };
11389
11390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11391 {
11392 arg1 = wxString_in_helper(obj0);
11393 if (arg1 == NULL) SWIG_fail;
11394 temp1 = true;
11395 }
11396 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11397 if (!SWIG_IsOK(res2)) {
11398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11399 }
11400 if (!argp2) {
11401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11402 }
11403 arg2 = reinterpret_cast< wxImage * >(argp2);
11404 ecode3 = SWIG_AsVal_long(obj2, &val3);
11405 if (!SWIG_IsOK(ecode3)) {
11406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11407 }
11408 arg3 = static_cast< long >(val3);
11409 {
11410 PyThreadState* __tstate = wxPyBeginAllowThreads();
11411 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 resultobj = SWIG_Py_Void();
11416 {
11417 if (temp1)
11418 delete arg1;
11419 }
11420 return resultobj;
11421 fail:
11422 {
11423 if (temp1)
11424 delete arg1;
11425 }
11426 return NULL;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 wxString *arg1 = 0 ;
11433 wxBitmap *arg2 = 0 ;
11434 long arg3 ;
11435 bool temp1 = false ;
11436 void *argp2 = 0 ;
11437 int res2 = 0 ;
11438 long val3 ;
11439 int ecode3 = 0 ;
11440 PyObject * obj0 = 0 ;
11441 PyObject * obj1 = 0 ;
11442 PyObject * obj2 = 0 ;
11443 char * kwnames[] = {
11444 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11445 };
11446
11447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11448 {
11449 arg1 = wxString_in_helper(obj0);
11450 if (arg1 == NULL) SWIG_fail;
11451 temp1 = true;
11452 }
11453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11454 if (!SWIG_IsOK(res2)) {
11455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11456 }
11457 if (!argp2) {
11458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11459 }
11460 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11461 ecode3 = SWIG_AsVal_long(obj2, &val3);
11462 if (!SWIG_IsOK(ecode3)) {
11463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11464 }
11465 arg3 = static_cast< long >(val3);
11466 {
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 resultobj = SWIG_Py_Void();
11473 {
11474 if (temp1)
11475 delete arg1;
11476 }
11477 return resultobj;
11478 fail:
11479 {
11480 if (temp1)
11481 delete arg1;
11482 }
11483 return NULL;
11484 }
11485
11486
11487 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11488 PyObject *resultobj = 0;
11489 wxString *arg1 = 0 ;
11490 PyObject *arg2 = (PyObject *) 0 ;
11491 bool temp1 = false ;
11492 PyObject * obj0 = 0 ;
11493 PyObject * obj1 = 0 ;
11494 char * kwnames[] = {
11495 (char *) "filename",(char *) "data", NULL
11496 };
11497
11498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11499 {
11500 arg1 = wxString_in_helper(obj0);
11501 if (arg1 == NULL) SWIG_fail;
11502 temp1 = true;
11503 }
11504 arg2 = obj1;
11505 {
11506 PyThreadState* __tstate = wxPyBeginAllowThreads();
11507 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 resultobj = SWIG_Py_Void();
11512 {
11513 if (temp1)
11514 delete arg1;
11515 }
11516 return resultobj;
11517 fail:
11518 {
11519 if (temp1)
11520 delete arg1;
11521 }
11522 return NULL;
11523 }
11524
11525
11526 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11527 PyObject *resultobj = 0;
11528 wxMemoryFSHandler *result = 0 ;
11529
11530 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11531 {
11532 PyThreadState* __tstate = wxPyBeginAllowThreads();
11533 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11534 wxPyEndAllowThreads(__tstate);
11535 if (PyErr_Occurred()) SWIG_fail;
11536 }
11537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11538 return resultobj;
11539 fail:
11540 return NULL;
11541 }
11542
11543
11544 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11545 PyObject *resultobj = 0;
11546 wxString *arg1 = 0 ;
11547 bool temp1 = false ;
11548 PyObject * obj0 = 0 ;
11549 char * kwnames[] = {
11550 (char *) "filename", NULL
11551 };
11552
11553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11554 {
11555 arg1 = wxString_in_helper(obj0);
11556 if (arg1 == NULL) SWIG_fail;
11557 temp1 = true;
11558 }
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 resultobj = SWIG_Py_Void();
11566 {
11567 if (temp1)
11568 delete arg1;
11569 }
11570 return resultobj;
11571 fail:
11572 {
11573 if (temp1)
11574 delete arg1;
11575 }
11576 return NULL;
11577 }
11578
11579
11580 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11581 PyObject *resultobj = 0;
11582 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11583 wxString *arg2 = 0 ;
11584 bool result;
11585 void *argp1 = 0 ;
11586 int res1 = 0 ;
11587 bool temp2 = false ;
11588 PyObject * obj0 = 0 ;
11589 PyObject * obj1 = 0 ;
11590 char * kwnames[] = {
11591 (char *) "self",(char *) "location", NULL
11592 };
11593
11594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11596 if (!SWIG_IsOK(res1)) {
11597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11598 }
11599 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11600 {
11601 arg2 = wxString_in_helper(obj1);
11602 if (arg2 == NULL) SWIG_fail;
11603 temp2 = true;
11604 }
11605 {
11606 PyThreadState* __tstate = wxPyBeginAllowThreads();
11607 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11608 wxPyEndAllowThreads(__tstate);
11609 if (PyErr_Occurred()) SWIG_fail;
11610 }
11611 {
11612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11613 }
11614 {
11615 if (temp2)
11616 delete arg2;
11617 }
11618 return resultobj;
11619 fail:
11620 {
11621 if (temp2)
11622 delete arg2;
11623 }
11624 return NULL;
11625 }
11626
11627
11628 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11629 PyObject *resultobj = 0;
11630 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11631 wxFileSystem *arg2 = 0 ;
11632 wxString *arg3 = 0 ;
11633 wxFSFile *result = 0 ;
11634 void *argp1 = 0 ;
11635 int res1 = 0 ;
11636 void *argp2 = 0 ;
11637 int res2 = 0 ;
11638 bool temp3 = false ;
11639 PyObject * obj0 = 0 ;
11640 PyObject * obj1 = 0 ;
11641 PyObject * obj2 = 0 ;
11642 char * kwnames[] = {
11643 (char *) "self",(char *) "fs",(char *) "location", NULL
11644 };
11645
11646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11648 if (!SWIG_IsOK(res1)) {
11649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11650 }
11651 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11653 if (!SWIG_IsOK(res2)) {
11654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11655 }
11656 if (!argp2) {
11657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11658 }
11659 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11660 {
11661 arg3 = wxString_in_helper(obj2);
11662 if (arg3 == NULL) SWIG_fail;
11663 temp3 = true;
11664 }
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 {
11672 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11673 }
11674 {
11675 if (temp3)
11676 delete arg3;
11677 }
11678 return resultobj;
11679 fail:
11680 {
11681 if (temp3)
11682 delete arg3;
11683 }
11684 return NULL;
11685 }
11686
11687
11688 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj = 0;
11690 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11691 wxString *arg2 = 0 ;
11692 int arg3 = (int) 0 ;
11693 wxString result;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 bool temp2 = false ;
11697 int val3 ;
11698 int ecode3 = 0 ;
11699 PyObject * obj0 = 0 ;
11700 PyObject * obj1 = 0 ;
11701 PyObject * obj2 = 0 ;
11702 char * kwnames[] = {
11703 (char *) "self",(char *) "spec",(char *) "flags", NULL
11704 };
11705
11706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11708 if (!SWIG_IsOK(res1)) {
11709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11710 }
11711 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11712 {
11713 arg2 = wxString_in_helper(obj1);
11714 if (arg2 == NULL) SWIG_fail;
11715 temp2 = true;
11716 }
11717 if (obj2) {
11718 ecode3 = SWIG_AsVal_int(obj2, &val3);
11719 if (!SWIG_IsOK(ecode3)) {
11720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11721 }
11722 arg3 = static_cast< int >(val3);
11723 }
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 {
11731 #if wxUSE_UNICODE
11732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11733 #else
11734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11735 #endif
11736 }
11737 {
11738 if (temp2)
11739 delete arg2;
11740 }
11741 return resultobj;
11742 fail:
11743 {
11744 if (temp2)
11745 delete arg2;
11746 }
11747 return NULL;
11748 }
11749
11750
11751 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11752 PyObject *resultobj = 0;
11753 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11754 wxString result;
11755 void *argp1 = 0 ;
11756 int res1 = 0 ;
11757 PyObject *swig_obj[1] ;
11758
11759 if (!args) SWIG_fail;
11760 swig_obj[0] = args;
11761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11762 if (!SWIG_IsOK(res1)) {
11763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11764 }
11765 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (arg1)->FindNext();
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 #if wxUSE_UNICODE
11774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11775 #else
11776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11777 #endif
11778 }
11779 return resultobj;
11780 fail:
11781 return NULL;
11782 }
11783
11784
11785 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11786 PyObject *obj;
11787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11788 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11789 return SWIG_Py_Void();
11790 }
11791
11792 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11793 return SWIG_Python_InitShadowInstance(args);
11794 }
11795
11796 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11797 PyObject *resultobj = 0;
11798 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11799 wxString result;
11800 void *argp1 = 0 ;
11801 int res1 = 0 ;
11802 PyObject *swig_obj[1] ;
11803
11804 if (!args) SWIG_fail;
11805 swig_obj[0] = args;
11806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11807 if (!SWIG_IsOK(res1)) {
11808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11809 }
11810 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11811 {
11812 PyThreadState* __tstate = wxPyBeginAllowThreads();
11813 result = (arg1)->GetName();
11814 wxPyEndAllowThreads(__tstate);
11815 if (PyErr_Occurred()) SWIG_fail;
11816 }
11817 {
11818 #if wxUSE_UNICODE
11819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11820 #else
11821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11822 #endif
11823 }
11824 return resultobj;
11825 fail:
11826 return NULL;
11827 }
11828
11829
11830 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11831 PyObject *resultobj = 0;
11832 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11833 wxString result;
11834 void *argp1 = 0 ;
11835 int res1 = 0 ;
11836 PyObject *swig_obj[1] ;
11837
11838 if (!args) SWIG_fail;
11839 swig_obj[0] = args;
11840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11841 if (!SWIG_IsOK(res1)) {
11842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11843 }
11844 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (arg1)->GetExtension();
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 {
11852 #if wxUSE_UNICODE
11853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11854 #else
11855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11856 #endif
11857 }
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 PyObject *resultobj = 0;
11866 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11867 long result;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 PyObject *swig_obj[1] ;
11871
11872 if (!args) SWIG_fail;
11873 swig_obj[0] = args;
11874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11877 }
11878 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (long)(arg1)->GetType();
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 resultobj = SWIG_From_long(static_cast< long >(result));
11886 return resultobj;
11887 fail:
11888 return NULL;
11889 }
11890
11891
11892 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11893 PyObject *resultobj = 0;
11894 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11895 wxString result;
11896 void *argp1 = 0 ;
11897 int res1 = 0 ;
11898 PyObject *swig_obj[1] ;
11899
11900 if (!args) SWIG_fail;
11901 swig_obj[0] = args;
11902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11903 if (!SWIG_IsOK(res1)) {
11904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11905 }
11906 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 result = (arg1)->GetMimeType();
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 {
11914 #if wxUSE_UNICODE
11915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11916 #else
11917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11918 #endif
11919 }
11920 return resultobj;
11921 fail:
11922 return NULL;
11923 }
11924
11925
11926 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11927 PyObject *resultobj = 0;
11928 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11929 wxString *arg2 = 0 ;
11930 bool result;
11931 void *argp1 = 0 ;
11932 int res1 = 0 ;
11933 bool temp2 = false ;
11934 PyObject * obj0 = 0 ;
11935 PyObject * obj1 = 0 ;
11936 char * kwnames[] = {
11937 (char *) "self",(char *) "name", NULL
11938 };
11939
11940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11942 if (!SWIG_IsOK(res1)) {
11943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11944 }
11945 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11946 {
11947 arg2 = wxString_in_helper(obj1);
11948 if (arg2 == NULL) SWIG_fail;
11949 temp2 = true;
11950 }
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 {
11958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11959 }
11960 {
11961 if (temp2)
11962 delete arg2;
11963 }
11964 return resultobj;
11965 fail:
11966 {
11967 if (temp2)
11968 delete arg2;
11969 }
11970 return NULL;
11971 }
11972
11973
11974 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11975 PyObject *resultobj = 0;
11976 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11977 wxInputStream *arg2 = 0 ;
11978 bool result;
11979 void *argp1 = 0 ;
11980 int res1 = 0 ;
11981 wxPyInputStream *temp2 ;
11982 bool created2 ;
11983 PyObject * obj0 = 0 ;
11984 PyObject * obj1 = 0 ;
11985 char * kwnames[] = {
11986 (char *) "self",(char *) "stream", NULL
11987 };
11988
11989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11991 if (!SWIG_IsOK(res1)) {
11992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11993 }
11994 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11995 {
11996 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11997 arg2 = temp2->m_wxis;
11998 created2 = false;
11999 } else {
12000 PyErr_Clear(); // clear the failure of the wxPyConvert above
12001 arg2 = wxPyCBInputStream_create(obj1, false);
12002 if (arg2 == NULL) {
12003 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12004 SWIG_fail;
12005 }
12006 created2 = true;
12007 }
12008 }
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (bool)(arg1)->CanRead(*arg2);
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 {
12016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12017 }
12018 {
12019 if (created2) delete arg2;
12020 }
12021 return resultobj;
12022 fail:
12023 {
12024 if (created2) delete arg2;
12025 }
12026 return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12031 PyObject *resultobj = 0;
12032 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12033 wxString *arg2 = 0 ;
12034 void *argp1 = 0 ;
12035 int res1 = 0 ;
12036 bool temp2 = false ;
12037 PyObject * obj0 = 0 ;
12038 PyObject * obj1 = 0 ;
12039 char * kwnames[] = {
12040 (char *) "self",(char *) "name", NULL
12041 };
12042
12043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12045 if (!SWIG_IsOK(res1)) {
12046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12047 }
12048 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12049 {
12050 arg2 = wxString_in_helper(obj1);
12051 if (arg2 == NULL) SWIG_fail;
12052 temp2 = true;
12053 }
12054 {
12055 PyThreadState* __tstate = wxPyBeginAllowThreads();
12056 (arg1)->SetName((wxString const &)*arg2);
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 resultobj = SWIG_Py_Void();
12061 {
12062 if (temp2)
12063 delete arg2;
12064 }
12065 return resultobj;
12066 fail:
12067 {
12068 if (temp2)
12069 delete arg2;
12070 }
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12076 PyObject *resultobj = 0;
12077 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12078 wxString *arg2 = 0 ;
12079 void *argp1 = 0 ;
12080 int res1 = 0 ;
12081 bool temp2 = false ;
12082 PyObject * obj0 = 0 ;
12083 PyObject * obj1 = 0 ;
12084 char * kwnames[] = {
12085 (char *) "self",(char *) "extension", NULL
12086 };
12087
12088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12090 if (!SWIG_IsOK(res1)) {
12091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12092 }
12093 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12094 {
12095 arg2 = wxString_in_helper(obj1);
12096 if (arg2 == NULL) SWIG_fail;
12097 temp2 = true;
12098 }
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 (arg1)->SetExtension((wxString const &)*arg2);
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 resultobj = SWIG_Py_Void();
12106 {
12107 if (temp2)
12108 delete arg2;
12109 }
12110 return resultobj;
12111 fail:
12112 {
12113 if (temp2)
12114 delete arg2;
12115 }
12116 return NULL;
12117 }
12118
12119
12120 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12121 PyObject *resultobj = 0;
12122 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12123 long arg2 ;
12124 void *argp1 = 0 ;
12125 int res1 = 0 ;
12126 long val2 ;
12127 int ecode2 = 0 ;
12128 PyObject * obj0 = 0 ;
12129 PyObject * obj1 = 0 ;
12130 char * kwnames[] = {
12131 (char *) "self",(char *) "type", NULL
12132 };
12133
12134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12136 if (!SWIG_IsOK(res1)) {
12137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12138 }
12139 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12140 ecode2 = SWIG_AsVal_long(obj1, &val2);
12141 if (!SWIG_IsOK(ecode2)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12143 }
12144 arg2 = static_cast< long >(val2);
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 (arg1)->SetType(arg2);
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 resultobj = SWIG_Py_Void();
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12159 PyObject *resultobj = 0;
12160 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12161 wxString *arg2 = 0 ;
12162 void *argp1 = 0 ;
12163 int res1 = 0 ;
12164 bool temp2 = false ;
12165 PyObject * obj0 = 0 ;
12166 PyObject * obj1 = 0 ;
12167 char * kwnames[] = {
12168 (char *) "self",(char *) "mimetype", NULL
12169 };
12170
12171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12173 if (!SWIG_IsOK(res1)) {
12174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12175 }
12176 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12177 {
12178 arg2 = wxString_in_helper(obj1);
12179 if (arg2 == NULL) SWIG_fail;
12180 temp2 = true;
12181 }
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 (arg1)->SetMimeType((wxString const &)*arg2);
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 resultobj = SWIG_Py_Void();
12189 {
12190 if (temp2)
12191 delete arg2;
12192 }
12193 return resultobj;
12194 fail:
12195 {
12196 if (temp2)
12197 delete arg2;
12198 }
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12204 PyObject *obj;
12205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12206 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12207 return SWIG_Py_Void();
12208 }
12209
12210 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12211 PyObject *resultobj = 0;
12212 wxPyImageHandler *result = 0 ;
12213
12214 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (wxPyImageHandler *)new wxPyImageHandler();
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj = 0;
12230 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12231 PyObject *arg2 = (PyObject *) 0 ;
12232 void *argp1 = 0 ;
12233 int res1 = 0 ;
12234 PyObject * obj0 = 0 ;
12235 PyObject * obj1 = 0 ;
12236 char * kwnames[] = {
12237 (char *) "self",(char *) "self", NULL
12238 };
12239
12240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12242 if (!SWIG_IsOK(res1)) {
12243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12244 }
12245 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12246 arg2 = obj1;
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 (arg1)->_SetSelf(arg2);
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 resultobj = SWIG_Py_Void();
12254 return resultobj;
12255 fail:
12256 return NULL;
12257 }
12258
12259
12260 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12261 PyObject *obj;
12262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12263 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12264 return SWIG_Py_Void();
12265 }
12266
12267 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12268 return SWIG_Python_InitShadowInstance(args);
12269 }
12270
12271 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12272 PyObject *resultobj = 0;
12273 wxImageHistogram *result = 0 ;
12274
12275 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 result = (wxImageHistogram *)new wxImageHistogram();
12279 wxPyEndAllowThreads(__tstate);
12280 if (PyErr_Occurred()) SWIG_fail;
12281 }
12282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12283 return resultobj;
12284 fail:
12285 return NULL;
12286 }
12287
12288
12289 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj = 0;
12291 byte arg1 ;
12292 byte arg2 ;
12293 byte arg3 ;
12294 unsigned long result;
12295 unsigned char val1 ;
12296 int ecode1 = 0 ;
12297 unsigned char val2 ;
12298 int ecode2 = 0 ;
12299 unsigned char val3 ;
12300 int ecode3 = 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 PyObject * obj2 = 0 ;
12304 char * kwnames[] = {
12305 (char *) "r",(char *) "g",(char *) "b", NULL
12306 };
12307
12308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12309 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12310 if (!SWIG_IsOK(ecode1)) {
12311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12312 }
12313 arg1 = static_cast< byte >(val1);
12314 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12315 if (!SWIG_IsOK(ecode2)) {
12316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12317 }
12318 arg2 = static_cast< byte >(val2);
12319 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12320 if (!SWIG_IsOK(ecode3)) {
12321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12322 }
12323 arg3 = static_cast< byte >(val3);
12324 {
12325 PyThreadState* __tstate = wxPyBeginAllowThreads();
12326 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj = 0;
12339 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12340 byte *arg2 = (byte *) 0 ;
12341 byte *arg3 = (byte *) 0 ;
12342 byte *arg4 = (byte *) 0 ;
12343 byte arg5 = (byte) 1 ;
12344 byte arg6 = (byte) 0 ;
12345 byte arg7 = (byte) 0 ;
12346 bool result;
12347 void *argp1 = 0 ;
12348 int res1 = 0 ;
12349 byte temp2 ;
12350 int res2 = SWIG_TMPOBJ ;
12351 byte temp3 ;
12352 int res3 = SWIG_TMPOBJ ;
12353 byte temp4 ;
12354 int res4 = SWIG_TMPOBJ ;
12355 unsigned char val5 ;
12356 int ecode5 = 0 ;
12357 unsigned char val6 ;
12358 int ecode6 = 0 ;
12359 unsigned char val7 ;
12360 int ecode7 = 0 ;
12361 PyObject * obj0 = 0 ;
12362 PyObject * obj1 = 0 ;
12363 PyObject * obj2 = 0 ;
12364 PyObject * obj3 = 0 ;
12365 char * kwnames[] = {
12366 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12367 };
12368
12369 arg2 = &temp2;
12370 arg3 = &temp3;
12371 arg4 = &temp4;
12372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12374 if (!SWIG_IsOK(res1)) {
12375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12376 }
12377 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12378 if (obj1) {
12379 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12380 if (!SWIG_IsOK(ecode5)) {
12381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12382 }
12383 arg5 = static_cast< byte >(val5);
12384 }
12385 if (obj2) {
12386 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12387 if (!SWIG_IsOK(ecode6)) {
12388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12389 }
12390 arg6 = static_cast< byte >(val6);
12391 }
12392 if (obj3) {
12393 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12394 if (!SWIG_IsOK(ecode7)) {
12395 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12396 }
12397 arg7 = static_cast< byte >(val7);
12398 }
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 {
12406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12407 }
12408 if (SWIG_IsTmpObj(res2)) {
12409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12410 } else {
12411 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12413 }
12414 if (SWIG_IsTmpObj(res3)) {
12415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12416 } else {
12417 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12419 }
12420 if (SWIG_IsTmpObj(res4)) {
12421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12422 } else {
12423 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12425 }
12426 return resultobj;
12427 fail:
12428 return NULL;
12429 }
12430
12431
12432 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12433 PyObject *resultobj = 0;
12434 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12435 unsigned long arg2 ;
12436 unsigned long result;
12437 void *argp1 = 0 ;
12438 int res1 = 0 ;
12439 unsigned long val2 ;
12440 int ecode2 = 0 ;
12441 PyObject * obj0 = 0 ;
12442 PyObject * obj1 = 0 ;
12443 char * kwnames[] = {
12444 (char *) "self",(char *) "key", NULL
12445 };
12446
12447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12449 if (!SWIG_IsOK(res1)) {
12450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12451 }
12452 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12453 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12454 if (!SWIG_IsOK(ecode2)) {
12455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12456 }
12457 arg2 = static_cast< unsigned long >(val2);
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12461 wxPyEndAllowThreads(__tstate);
12462 if (PyErr_Occurred()) SWIG_fail;
12463 }
12464 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj = 0;
12473 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12474 byte arg2 ;
12475 byte arg3 ;
12476 byte arg4 ;
12477 unsigned long result;
12478 void *argp1 = 0 ;
12479 int res1 = 0 ;
12480 unsigned char val2 ;
12481 int ecode2 = 0 ;
12482 unsigned char val3 ;
12483 int ecode3 = 0 ;
12484 unsigned char val4 ;
12485 int ecode4 = 0 ;
12486 PyObject * obj0 = 0 ;
12487 PyObject * obj1 = 0 ;
12488 PyObject * obj2 = 0 ;
12489 PyObject * obj3 = 0 ;
12490 char * kwnames[] = {
12491 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12492 };
12493
12494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12496 if (!SWIG_IsOK(res1)) {
12497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12498 }
12499 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12500 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12501 if (!SWIG_IsOK(ecode2)) {
12502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12503 }
12504 arg2 = static_cast< byte >(val2);
12505 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12506 if (!SWIG_IsOK(ecode3)) {
12507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12508 }
12509 arg3 = static_cast< byte >(val3);
12510 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12511 if (!SWIG_IsOK(ecode4)) {
12512 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12513 }
12514 arg4 = static_cast< byte >(val4);
12515 {
12516 PyThreadState* __tstate = wxPyBeginAllowThreads();
12517 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12522 return resultobj;
12523 fail:
12524 return NULL;
12525 }
12526
12527
12528 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj = 0;
12530 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12531 wxColour *arg2 = 0 ;
12532 unsigned long result;
12533 void *argp1 = 0 ;
12534 int res1 = 0 ;
12535 wxColour temp2 ;
12536 PyObject * obj0 = 0 ;
12537 PyObject * obj1 = 0 ;
12538 char * kwnames[] = {
12539 (char *) "self",(char *) "colour", NULL
12540 };
12541
12542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12544 if (!SWIG_IsOK(res1)) {
12545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12546 }
12547 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12548 {
12549 arg2 = &temp2;
12550 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12551 }
12552 {
12553 PyThreadState* __tstate = wxPyBeginAllowThreads();
12554 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12559 return resultobj;
12560 fail:
12561 return NULL;
12562 }
12563
12564
12565 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12566 PyObject *obj;
12567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12568 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12569 return SWIG_Py_Void();
12570 }
12571
12572 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12573 return SWIG_Python_InitShadowInstance(args);
12574 }
12575
12576 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12577 PyObject *resultobj = 0;
12578 byte arg1 = (byte) 0 ;
12579 byte arg2 = (byte) 0 ;
12580 byte arg3 = (byte) 0 ;
12581 wxImage_RGBValue *result = 0 ;
12582 unsigned char val1 ;
12583 int ecode1 = 0 ;
12584 unsigned char val2 ;
12585 int ecode2 = 0 ;
12586 unsigned char val3 ;
12587 int ecode3 = 0 ;
12588 PyObject * obj0 = 0 ;
12589 PyObject * obj1 = 0 ;
12590 PyObject * obj2 = 0 ;
12591 char * kwnames[] = {
12592 (char *) "r",(char *) "g",(char *) "b", NULL
12593 };
12594
12595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12596 if (obj0) {
12597 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12598 if (!SWIG_IsOK(ecode1)) {
12599 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12600 }
12601 arg1 = static_cast< byte >(val1);
12602 }
12603 if (obj1) {
12604 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12605 if (!SWIG_IsOK(ecode2)) {
12606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12607 }
12608 arg2 = static_cast< byte >(val2);
12609 }
12610 if (obj2) {
12611 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12612 if (!SWIG_IsOK(ecode3)) {
12613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12614 }
12615 arg3 = static_cast< byte >(val3);
12616 }
12617 {
12618 PyThreadState* __tstate = wxPyBeginAllowThreads();
12619 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12631 PyObject *resultobj = 0;
12632 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12633 byte arg2 ;
12634 void *argp1 = 0 ;
12635 int res1 = 0 ;
12636 unsigned char val2 ;
12637 int ecode2 = 0 ;
12638 PyObject *swig_obj[2] ;
12639
12640 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12642 if (!SWIG_IsOK(res1)) {
12643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12644 }
12645 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12646 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12647 if (!SWIG_IsOK(ecode2)) {
12648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12649 }
12650 arg2 = static_cast< byte >(val2);
12651 if (arg1) (arg1)->red = arg2;
12652
12653 resultobj = SWIG_Py_Void();
12654 return resultobj;
12655 fail:
12656 return NULL;
12657 }
12658
12659
12660 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12661 PyObject *resultobj = 0;
12662 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12663 byte result;
12664 void *argp1 = 0 ;
12665 int res1 = 0 ;
12666 PyObject *swig_obj[1] ;
12667
12668 if (!args) SWIG_fail;
12669 swig_obj[0] = args;
12670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12671 if (!SWIG_IsOK(res1)) {
12672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12673 }
12674 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12675 result = (byte) ((arg1)->red);
12676 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *resultobj = 0;
12685 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12686 byte arg2 ;
12687 void *argp1 = 0 ;
12688 int res1 = 0 ;
12689 unsigned char val2 ;
12690 int ecode2 = 0 ;
12691 PyObject *swig_obj[2] ;
12692
12693 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12697 }
12698 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12699 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12700 if (!SWIG_IsOK(ecode2)) {
12701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12702 }
12703 arg2 = static_cast< byte >(val2);
12704 if (arg1) (arg1)->green = arg2;
12705
12706 resultobj = SWIG_Py_Void();
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12714 PyObject *resultobj = 0;
12715 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12716 byte result;
12717 void *argp1 = 0 ;
12718 int res1 = 0 ;
12719 PyObject *swig_obj[1] ;
12720
12721 if (!args) SWIG_fail;
12722 swig_obj[0] = args;
12723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12724 if (!SWIG_IsOK(res1)) {
12725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12726 }
12727 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12728 result = (byte) ((arg1)->green);
12729 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12737 PyObject *resultobj = 0;
12738 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12739 byte arg2 ;
12740 void *argp1 = 0 ;
12741 int res1 = 0 ;
12742 unsigned char val2 ;
12743 int ecode2 = 0 ;
12744 PyObject *swig_obj[2] ;
12745
12746 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12748 if (!SWIG_IsOK(res1)) {
12749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12750 }
12751 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12752 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12753 if (!SWIG_IsOK(ecode2)) {
12754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12755 }
12756 arg2 = static_cast< byte >(val2);
12757 if (arg1) (arg1)->blue = arg2;
12758
12759 resultobj = SWIG_Py_Void();
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12767 PyObject *resultobj = 0;
12768 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12769 byte result;
12770 void *argp1 = 0 ;
12771 int res1 = 0 ;
12772 PyObject *swig_obj[1] ;
12773
12774 if (!args) SWIG_fail;
12775 swig_obj[0] = args;
12776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12777 if (!SWIG_IsOK(res1)) {
12778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12779 }
12780 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12781 result = (byte) ((arg1)->blue);
12782 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12783 return resultobj;
12784 fail:
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12790 PyObject *obj;
12791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12792 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12793 return SWIG_Py_Void();
12794 }
12795
12796 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12797 return SWIG_Python_InitShadowInstance(args);
12798 }
12799
12800 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12801 PyObject *resultobj = 0;
12802 double arg1 = (double) 0.0 ;
12803 double arg2 = (double) 0.0 ;
12804 double arg3 = (double) 0.0 ;
12805 wxImage_HSVValue *result = 0 ;
12806 double val1 ;
12807 int ecode1 = 0 ;
12808 double val2 ;
12809 int ecode2 = 0 ;
12810 double val3 ;
12811 int ecode3 = 0 ;
12812 PyObject * obj0 = 0 ;
12813 PyObject * obj1 = 0 ;
12814 PyObject * obj2 = 0 ;
12815 char * kwnames[] = {
12816 (char *) "h",(char *) "s",(char *) "v", NULL
12817 };
12818
12819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12820 if (obj0) {
12821 ecode1 = SWIG_AsVal_double(obj0, &val1);
12822 if (!SWIG_IsOK(ecode1)) {
12823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12824 }
12825 arg1 = static_cast< double >(val1);
12826 }
12827 if (obj1) {
12828 ecode2 = SWIG_AsVal_double(obj1, &val2);
12829 if (!SWIG_IsOK(ecode2)) {
12830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12831 }
12832 arg2 = static_cast< double >(val2);
12833 }
12834 if (obj2) {
12835 ecode3 = SWIG_AsVal_double(obj2, &val3);
12836 if (!SWIG_IsOK(ecode3)) {
12837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12838 }
12839 arg3 = static_cast< double >(val3);
12840 }
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12844 wxPyEndAllowThreads(__tstate);
12845 if (PyErr_Occurred()) SWIG_fail;
12846 }
12847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12848 return resultobj;
12849 fail:
12850 return NULL;
12851 }
12852
12853
12854 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 PyObject *resultobj = 0;
12856 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12857 double arg2 ;
12858 void *argp1 = 0 ;
12859 int res1 = 0 ;
12860 double val2 ;
12861 int ecode2 = 0 ;
12862 PyObject *swig_obj[2] ;
12863
12864 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12866 if (!SWIG_IsOK(res1)) {
12867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12868 }
12869 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12870 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12871 if (!SWIG_IsOK(ecode2)) {
12872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12873 }
12874 arg2 = static_cast< double >(val2);
12875 if (arg1) (arg1)->hue = arg2;
12876
12877 resultobj = SWIG_Py_Void();
12878 return resultobj;
12879 fail:
12880 return NULL;
12881 }
12882
12883
12884 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12885 PyObject *resultobj = 0;
12886 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12887 double result;
12888 void *argp1 = 0 ;
12889 int res1 = 0 ;
12890 PyObject *swig_obj[1] ;
12891
12892 if (!args) SWIG_fail;
12893 swig_obj[0] = args;
12894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12895 if (!SWIG_IsOK(res1)) {
12896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12897 }
12898 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12899 result = (double) ((arg1)->hue);
12900 resultobj = SWIG_From_double(static_cast< double >(result));
12901 return resultobj;
12902 fail:
12903 return NULL;
12904 }
12905
12906
12907 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 PyObject *resultobj = 0;
12909 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12910 double arg2 ;
12911 void *argp1 = 0 ;
12912 int res1 = 0 ;
12913 double val2 ;
12914 int ecode2 = 0 ;
12915 PyObject *swig_obj[2] ;
12916
12917 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12919 if (!SWIG_IsOK(res1)) {
12920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12921 }
12922 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12923 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12924 if (!SWIG_IsOK(ecode2)) {
12925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12926 }
12927 arg2 = static_cast< double >(val2);
12928 if (arg1) (arg1)->saturation = arg2;
12929
12930 resultobj = SWIG_Py_Void();
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *resultobj = 0;
12939 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12940 double result;
12941 void *argp1 = 0 ;
12942 int res1 = 0 ;
12943 PyObject *swig_obj[1] ;
12944
12945 if (!args) SWIG_fail;
12946 swig_obj[0] = args;
12947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12948 if (!SWIG_IsOK(res1)) {
12949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12950 }
12951 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12952 result = (double) ((arg1)->saturation);
12953 resultobj = SWIG_From_double(static_cast< double >(result));
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 PyObject *resultobj = 0;
12962 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12963 double arg2 ;
12964 void *argp1 = 0 ;
12965 int res1 = 0 ;
12966 double val2 ;
12967 int ecode2 = 0 ;
12968 PyObject *swig_obj[2] ;
12969
12970 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12972 if (!SWIG_IsOK(res1)) {
12973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12974 }
12975 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12976 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12977 if (!SWIG_IsOK(ecode2)) {
12978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12979 }
12980 arg2 = static_cast< double >(val2);
12981 if (arg1) (arg1)->value = arg2;
12982
12983 resultobj = SWIG_Py_Void();
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12991 PyObject *resultobj = 0;
12992 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12993 double result;
12994 void *argp1 = 0 ;
12995 int res1 = 0 ;
12996 PyObject *swig_obj[1] ;
12997
12998 if (!args) SWIG_fail;
12999 swig_obj[0] = args;
13000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13001 if (!SWIG_IsOK(res1)) {
13002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13003 }
13004 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13005 result = (double) ((arg1)->value);
13006 resultobj = SWIG_From_double(static_cast< double >(result));
13007 return resultobj;
13008 fail:
13009 return NULL;
13010 }
13011
13012
13013 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13014 PyObject *obj;
13015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13016 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13017 return SWIG_Py_Void();
13018 }
13019
13020 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13021 return SWIG_Python_InitShadowInstance(args);
13022 }
13023
13024 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13025 PyObject *resultobj = 0;
13026 wxString *arg1 = 0 ;
13027 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13028 int arg3 = (int) -1 ;
13029 wxImage *result = 0 ;
13030 bool temp1 = false ;
13031 long val2 ;
13032 int ecode2 = 0 ;
13033 int val3 ;
13034 int ecode3 = 0 ;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 PyObject * obj2 = 0 ;
13038 char * kwnames[] = {
13039 (char *) "name",(char *) "type",(char *) "index", NULL
13040 };
13041
13042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13043 {
13044 arg1 = wxString_in_helper(obj0);
13045 if (arg1 == NULL) SWIG_fail;
13046 temp1 = true;
13047 }
13048 if (obj1) {
13049 ecode2 = SWIG_AsVal_long(obj1, &val2);
13050 if (!SWIG_IsOK(ecode2)) {
13051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13052 }
13053 arg2 = static_cast< long >(val2);
13054 }
13055 if (obj2) {
13056 ecode3 = SWIG_AsVal_int(obj2, &val3);
13057 if (!SWIG_IsOK(ecode3)) {
13058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13059 }
13060 arg3 = static_cast< int >(val3);
13061 }
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13065 wxPyEndAllowThreads(__tstate);
13066 if (PyErr_Occurred()) SWIG_fail;
13067 }
13068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13069 {
13070 if (temp1)
13071 delete arg1;
13072 }
13073 return resultobj;
13074 fail:
13075 {
13076 if (temp1)
13077 delete arg1;
13078 }
13079 return NULL;
13080 }
13081
13082
13083 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *resultobj = 0;
13085 wxImage *arg1 = (wxImage *) 0 ;
13086 void *argp1 = 0 ;
13087 int res1 = 0 ;
13088 PyObject *swig_obj[1] ;
13089
13090 if (!args) SWIG_fail;
13091 swig_obj[0] = args;
13092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13093 if (!SWIG_IsOK(res1)) {
13094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13095 }
13096 arg1 = reinterpret_cast< wxImage * >(argp1);
13097 {
13098 PyThreadState* __tstate = wxPyBeginAllowThreads();
13099 delete arg1;
13100
13101 wxPyEndAllowThreads(__tstate);
13102 if (PyErr_Occurred()) SWIG_fail;
13103 }
13104 resultobj = SWIG_Py_Void();
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13112 PyObject *resultobj = 0;
13113 wxString *arg1 = 0 ;
13114 wxString *arg2 = 0 ;
13115 int arg3 = (int) -1 ;
13116 wxImage *result = 0 ;
13117 bool temp1 = false ;
13118 bool temp2 = false ;
13119 int val3 ;
13120 int ecode3 = 0 ;
13121 PyObject * obj0 = 0 ;
13122 PyObject * obj1 = 0 ;
13123 PyObject * obj2 = 0 ;
13124 char * kwnames[] = {
13125 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13126 };
13127
13128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13129 {
13130 arg1 = wxString_in_helper(obj0);
13131 if (arg1 == NULL) SWIG_fail;
13132 temp1 = true;
13133 }
13134 {
13135 arg2 = wxString_in_helper(obj1);
13136 if (arg2 == NULL) SWIG_fail;
13137 temp2 = true;
13138 }
13139 if (obj2) {
13140 ecode3 = SWIG_AsVal_int(obj2, &val3);
13141 if (!SWIG_IsOK(ecode3)) {
13142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13143 }
13144 arg3 = static_cast< int >(val3);
13145 }
13146 {
13147 PyThreadState* __tstate = wxPyBeginAllowThreads();
13148 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13153 {
13154 if (temp1)
13155 delete arg1;
13156 }
13157 {
13158 if (temp2)
13159 delete arg2;
13160 }
13161 return resultobj;
13162 fail:
13163 {
13164 if (temp1)
13165 delete arg1;
13166 }
13167 {
13168 if (temp2)
13169 delete arg2;
13170 }
13171 return NULL;
13172 }
13173
13174
13175 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13176 PyObject *resultobj = 0;
13177 wxInputStream *arg1 = 0 ;
13178 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13179 int arg3 = (int) -1 ;
13180 wxImage *result = 0 ;
13181 wxPyInputStream *temp1 ;
13182 bool created1 ;
13183 long val2 ;
13184 int ecode2 = 0 ;
13185 int val3 ;
13186 int ecode3 = 0 ;
13187 PyObject * obj0 = 0 ;
13188 PyObject * obj1 = 0 ;
13189 PyObject * obj2 = 0 ;
13190 char * kwnames[] = {
13191 (char *) "stream",(char *) "type",(char *) "index", NULL
13192 };
13193
13194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13195 {
13196 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13197 arg1 = temp1->m_wxis;
13198 created1 = false;
13199 } else {
13200 PyErr_Clear(); // clear the failure of the wxPyConvert above
13201 arg1 = wxPyCBInputStream_create(obj0, false);
13202 if (arg1 == NULL) {
13203 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13204 SWIG_fail;
13205 }
13206 created1 = true;
13207 }
13208 }
13209 if (obj1) {
13210 ecode2 = SWIG_AsVal_long(obj1, &val2);
13211 if (!SWIG_IsOK(ecode2)) {
13212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13213 }
13214 arg2 = static_cast< long >(val2);
13215 }
13216 if (obj2) {
13217 ecode3 = SWIG_AsVal_int(obj2, &val3);
13218 if (!SWIG_IsOK(ecode3)) {
13219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13220 }
13221 arg3 = static_cast< int >(val3);
13222 }
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13226 wxPyEndAllowThreads(__tstate);
13227 if (PyErr_Occurred()) SWIG_fail;
13228 }
13229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13230 {
13231 if (created1) delete arg1;
13232 }
13233 return resultobj;
13234 fail:
13235 {
13236 if (created1) delete arg1;
13237 }
13238 return NULL;
13239 }
13240
13241
13242 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13243 PyObject *resultobj = 0;
13244 wxInputStream *arg1 = 0 ;
13245 wxString *arg2 = 0 ;
13246 int arg3 = (int) -1 ;
13247 wxImage *result = 0 ;
13248 wxPyInputStream *temp1 ;
13249 bool created1 ;
13250 bool temp2 = false ;
13251 int val3 ;
13252 int ecode3 = 0 ;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 PyObject * obj2 = 0 ;
13256 char * kwnames[] = {
13257 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13258 };
13259
13260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13261 {
13262 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13263 arg1 = temp1->m_wxis;
13264 created1 = false;
13265 } else {
13266 PyErr_Clear(); // clear the failure of the wxPyConvert above
13267 arg1 = wxPyCBInputStream_create(obj0, false);
13268 if (arg1 == NULL) {
13269 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13270 SWIG_fail;
13271 }
13272 created1 = true;
13273 }
13274 }
13275 {
13276 arg2 = wxString_in_helper(obj1);
13277 if (arg2 == NULL) SWIG_fail;
13278 temp2 = true;
13279 }
13280 if (obj2) {
13281 ecode3 = SWIG_AsVal_int(obj2, &val3);
13282 if (!SWIG_IsOK(ecode3)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13284 }
13285 arg3 = static_cast< int >(val3);
13286 }
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13294 {
13295 if (created1) delete arg1;
13296 }
13297 {
13298 if (temp2)
13299 delete arg2;
13300 }
13301 return resultobj;
13302 fail:
13303 {
13304 if (created1) delete arg1;
13305 }
13306 {
13307 if (temp2)
13308 delete arg2;
13309 }
13310 return NULL;
13311 }
13312
13313
13314 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13315 PyObject *resultobj = 0;
13316 int arg1 = (int) 0 ;
13317 int arg2 = (int) 0 ;
13318 bool arg3 = (bool) true ;
13319 wxImage *result = 0 ;
13320 int val1 ;
13321 int ecode1 = 0 ;
13322 int val2 ;
13323 int ecode2 = 0 ;
13324 bool val3 ;
13325 int ecode3 = 0 ;
13326 PyObject * obj0 = 0 ;
13327 PyObject * obj1 = 0 ;
13328 PyObject * obj2 = 0 ;
13329 char * kwnames[] = {
13330 (char *) "width",(char *) "height",(char *) "clear", NULL
13331 };
13332
13333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13334 if (obj0) {
13335 ecode1 = SWIG_AsVal_int(obj0, &val1);
13336 if (!SWIG_IsOK(ecode1)) {
13337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13338 }
13339 arg1 = static_cast< int >(val1);
13340 }
13341 if (obj1) {
13342 ecode2 = SWIG_AsVal_int(obj1, &val2);
13343 if (!SWIG_IsOK(ecode2)) {
13344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13345 }
13346 arg2 = static_cast< int >(val2);
13347 }
13348 if (obj2) {
13349 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13350 if (!SWIG_IsOK(ecode3)) {
13351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13352 }
13353 arg3 = static_cast< bool >(val3);
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13362 return resultobj;
13363 fail:
13364 return NULL;
13365 }
13366
13367
13368 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13369 PyObject *resultobj = 0;
13370 wxBitmap *arg1 = 0 ;
13371 wxImage *result = 0 ;
13372 void *argp1 = 0 ;
13373 int res1 = 0 ;
13374 PyObject * obj0 = 0 ;
13375 char * kwnames[] = {
13376 (char *) "bitmap", NULL
13377 };
13378
13379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13380 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13381 if (!SWIG_IsOK(res1)) {
13382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13383 }
13384 if (!argp1) {
13385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13386 }
13387 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13388 {
13389 if (!wxPyCheckForApp()) SWIG_fail;
13390 PyThreadState* __tstate = wxPyBeginAllowThreads();
13391 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13392 wxPyEndAllowThreads(__tstate);
13393 if (PyErr_Occurred()) SWIG_fail;
13394 }
13395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13396 return resultobj;
13397 fail:
13398 return NULL;
13399 }
13400
13401
13402 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13403 PyObject *resultobj = 0;
13404 int arg1 ;
13405 int arg2 ;
13406 buffer arg3 ;
13407 int arg4 ;
13408 wxImage *result = 0 ;
13409 int val1 ;
13410 int ecode1 = 0 ;
13411 int val2 ;
13412 int ecode2 = 0 ;
13413 Py_ssize_t temp3 ;
13414 PyObject * obj0 = 0 ;
13415 PyObject * obj1 = 0 ;
13416 PyObject * obj2 = 0 ;
13417 char * kwnames[] = {
13418 (char *) "width",(char *) "height",(char *) "data", NULL
13419 };
13420
13421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13422 ecode1 = SWIG_AsVal_int(obj0, &val1);
13423 if (!SWIG_IsOK(ecode1)) {
13424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13425 }
13426 arg1 = static_cast< int >(val1);
13427 ecode2 = SWIG_AsVal_int(obj1, &val2);
13428 if (!SWIG_IsOK(ecode2)) {
13429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13430 }
13431 arg2 = static_cast< int >(val2);
13432 {
13433 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13434 arg4 = (int)temp3;
13435 }
13436 {
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13439 wxPyEndAllowThreads(__tstate);
13440 if (PyErr_Occurred()) SWIG_fail;
13441 }
13442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13443 return resultobj;
13444 fail:
13445 return NULL;
13446 }
13447
13448
13449 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13450 PyObject *resultobj = 0;
13451 int arg1 ;
13452 int arg2 ;
13453 buffer arg3 ;
13454 int arg4 ;
13455 buffer arg5 ;
13456 int arg6 ;
13457 wxImage *result = 0 ;
13458 int val1 ;
13459 int ecode1 = 0 ;
13460 int val2 ;
13461 int ecode2 = 0 ;
13462 Py_ssize_t temp3 ;
13463 Py_ssize_t temp5 ;
13464 PyObject * obj0 = 0 ;
13465 PyObject * obj1 = 0 ;
13466 PyObject * obj2 = 0 ;
13467 PyObject * obj3 = 0 ;
13468 char * kwnames[] = {
13469 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13470 };
13471
13472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13473 ecode1 = SWIG_AsVal_int(obj0, &val1);
13474 if (!SWIG_IsOK(ecode1)) {
13475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13476 }
13477 arg1 = static_cast< int >(val1);
13478 ecode2 = SWIG_AsVal_int(obj1, &val2);
13479 if (!SWIG_IsOK(ecode2)) {
13480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13481 }
13482 arg2 = static_cast< int >(val2);
13483 {
13484 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13485 arg4 = (int)temp3;
13486 }
13487 {
13488 if (obj3 != Py_None) {
13489 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13490 arg6 = (int)temp5;
13491 }
13492 }
13493 {
13494 PyThreadState* __tstate = wxPyBeginAllowThreads();
13495 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13496 wxPyEndAllowThreads(__tstate);
13497 if (PyErr_Occurred()) SWIG_fail;
13498 }
13499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj = 0;
13508 wxImage *arg1 = (wxImage *) 0 ;
13509 int arg2 ;
13510 int arg3 ;
13511 bool arg4 = (bool) true ;
13512 void *argp1 = 0 ;
13513 int res1 = 0 ;
13514 int val2 ;
13515 int ecode2 = 0 ;
13516 int val3 ;
13517 int ecode3 = 0 ;
13518 bool val4 ;
13519 int ecode4 = 0 ;
13520 PyObject * obj0 = 0 ;
13521 PyObject * obj1 = 0 ;
13522 PyObject * obj2 = 0 ;
13523 PyObject * obj3 = 0 ;
13524 char * kwnames[] = {
13525 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13526 };
13527
13528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13530 if (!SWIG_IsOK(res1)) {
13531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13532 }
13533 arg1 = reinterpret_cast< wxImage * >(argp1);
13534 ecode2 = SWIG_AsVal_int(obj1, &val2);
13535 if (!SWIG_IsOK(ecode2)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13537 }
13538 arg2 = static_cast< int >(val2);
13539 ecode3 = SWIG_AsVal_int(obj2, &val3);
13540 if (!SWIG_IsOK(ecode3)) {
13541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13542 }
13543 arg3 = static_cast< int >(val3);
13544 if (obj3) {
13545 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13546 if (!SWIG_IsOK(ecode4)) {
13547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13548 }
13549 arg4 = static_cast< bool >(val4);
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 (arg1)->Create(arg2,arg3,arg4);
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 resultobj = SWIG_Py_Void();
13558 return resultobj;
13559 fail:
13560 return NULL;
13561 }
13562
13563
13564 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13565 PyObject *resultobj = 0;
13566 wxImage *arg1 = (wxImage *) 0 ;
13567 void *argp1 = 0 ;
13568 int res1 = 0 ;
13569 PyObject *swig_obj[1] ;
13570
13571 if (!args) SWIG_fail;
13572 swig_obj[0] = args;
13573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13574 if (!SWIG_IsOK(res1)) {
13575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13576 }
13577 arg1 = reinterpret_cast< wxImage * >(argp1);
13578 {
13579 PyThreadState* __tstate = wxPyBeginAllowThreads();
13580 (arg1)->Destroy();
13581 wxPyEndAllowThreads(__tstate);
13582 if (PyErr_Occurred()) SWIG_fail;
13583 }
13584 resultobj = SWIG_Py_Void();
13585 return resultobj;
13586 fail:
13587 return NULL;
13588 }
13589
13590
13591 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13592 PyObject *resultobj = 0;
13593 wxImage *arg1 = (wxImage *) 0 ;
13594 int arg2 ;
13595 int arg3 ;
13596 SwigValueWrapper<wxImage > result;
13597 void *argp1 = 0 ;
13598 int res1 = 0 ;
13599 int val2 ;
13600 int ecode2 = 0 ;
13601 int val3 ;
13602 int ecode3 = 0 ;
13603 PyObject * obj0 = 0 ;
13604 PyObject * obj1 = 0 ;
13605 PyObject * obj2 = 0 ;
13606 char * kwnames[] = {
13607 (char *) "self",(char *) "width",(char *) "height", NULL
13608 };
13609
13610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13612 if (!SWIG_IsOK(res1)) {
13613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13614 }
13615 arg1 = reinterpret_cast< wxImage * >(argp1);
13616 ecode2 = SWIG_AsVal_int(obj1, &val2);
13617 if (!SWIG_IsOK(ecode2)) {
13618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13619 }
13620 arg2 = static_cast< int >(val2);
13621 ecode3 = SWIG_AsVal_int(obj2, &val3);
13622 if (!SWIG_IsOK(ecode3)) {
13623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13624 }
13625 arg3 = static_cast< int >(val3);
13626 {
13627 PyThreadState* __tstate = wxPyBeginAllowThreads();
13628 result = (arg1)->Scale(arg2,arg3);
13629 wxPyEndAllowThreads(__tstate);
13630 if (PyErr_Occurred()) SWIG_fail;
13631 }
13632 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13633 return resultobj;
13634 fail:
13635 return NULL;
13636 }
13637
13638
13639 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13640 PyObject *resultobj = 0;
13641 wxImage *arg1 = (wxImage *) 0 ;
13642 int arg2 ;
13643 int arg3 ;
13644 SwigValueWrapper<wxImage > result;
13645 void *argp1 = 0 ;
13646 int res1 = 0 ;
13647 int val2 ;
13648 int ecode2 = 0 ;
13649 int val3 ;
13650 int ecode3 = 0 ;
13651 PyObject * obj0 = 0 ;
13652 PyObject * obj1 = 0 ;
13653 PyObject * obj2 = 0 ;
13654 char * kwnames[] = {
13655 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13656 };
13657
13658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13660 if (!SWIG_IsOK(res1)) {
13661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13662 }
13663 arg1 = reinterpret_cast< wxImage * >(argp1);
13664 ecode2 = SWIG_AsVal_int(obj1, &val2);
13665 if (!SWIG_IsOK(ecode2)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13667 }
13668 arg2 = static_cast< int >(val2);
13669 ecode3 = SWIG_AsVal_int(obj2, &val3);
13670 if (!SWIG_IsOK(ecode3)) {
13671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13672 }
13673 arg3 = static_cast< int >(val3);
13674 {
13675 PyThreadState* __tstate = wxPyBeginAllowThreads();
13676 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13677 wxPyEndAllowThreads(__tstate);
13678 if (PyErr_Occurred()) SWIG_fail;
13679 }
13680 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13681 return resultobj;
13682 fail:
13683 return NULL;
13684 }
13685
13686
13687 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj = 0;
13689 wxImage *arg1 = (wxImage *) 0 ;
13690 int arg2 ;
13691 int arg3 ;
13692 wxImage *result = 0 ;
13693 void *argp1 = 0 ;
13694 int res1 = 0 ;
13695 int val2 ;
13696 int ecode2 = 0 ;
13697 int val3 ;
13698 int ecode3 = 0 ;
13699 PyObject * obj0 = 0 ;
13700 PyObject * obj1 = 0 ;
13701 PyObject * obj2 = 0 ;
13702 char * kwnames[] = {
13703 (char *) "self",(char *) "width",(char *) "height", NULL
13704 };
13705
13706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13708 if (!SWIG_IsOK(res1)) {
13709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13710 }
13711 arg1 = reinterpret_cast< wxImage * >(argp1);
13712 ecode2 = SWIG_AsVal_int(obj1, &val2);
13713 if (!SWIG_IsOK(ecode2)) {
13714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13715 }
13716 arg2 = static_cast< int >(val2);
13717 ecode3 = SWIG_AsVal_int(obj2, &val3);
13718 if (!SWIG_IsOK(ecode3)) {
13719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13720 }
13721 arg3 = static_cast< int >(val3);
13722 {
13723 PyThreadState* __tstate = wxPyBeginAllowThreads();
13724 {
13725 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13726 result = (wxImage *) &_result_ref;
13727 }
13728 wxPyEndAllowThreads(__tstate);
13729 if (PyErr_Occurred()) SWIG_fail;
13730 }
13731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13732 return resultobj;
13733 fail:
13734 return NULL;
13735 }
13736
13737
13738 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13739 PyObject *resultobj = 0;
13740 wxImage *arg1 = (wxImage *) 0 ;
13741 wxSize *arg2 = 0 ;
13742 wxPoint *arg3 = 0 ;
13743 int arg4 = (int) -1 ;
13744 int arg5 = (int) -1 ;
13745 int arg6 = (int) -1 ;
13746 wxImage *result = 0 ;
13747 void *argp1 = 0 ;
13748 int res1 = 0 ;
13749 wxSize temp2 ;
13750 wxPoint temp3 ;
13751 int val4 ;
13752 int ecode4 = 0 ;
13753 int val5 ;
13754 int ecode5 = 0 ;
13755 int val6 ;
13756 int ecode6 = 0 ;
13757 PyObject * obj0 = 0 ;
13758 PyObject * obj1 = 0 ;
13759 PyObject * obj2 = 0 ;
13760 PyObject * obj3 = 0 ;
13761 PyObject * obj4 = 0 ;
13762 PyObject * obj5 = 0 ;
13763 char * kwnames[] = {
13764 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13765 };
13766
13767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13769 if (!SWIG_IsOK(res1)) {
13770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13771 }
13772 arg1 = reinterpret_cast< wxImage * >(argp1);
13773 {
13774 arg2 = &temp2;
13775 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13776 }
13777 {
13778 arg3 = &temp3;
13779 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13780 }
13781 if (obj3) {
13782 ecode4 = SWIG_AsVal_int(obj3, &val4);
13783 if (!SWIG_IsOK(ecode4)) {
13784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13785 }
13786 arg4 = static_cast< int >(val4);
13787 }
13788 if (obj4) {
13789 ecode5 = SWIG_AsVal_int(obj4, &val5);
13790 if (!SWIG_IsOK(ecode5)) {
13791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13792 }
13793 arg5 = static_cast< int >(val5);
13794 }
13795 if (obj5) {
13796 ecode6 = SWIG_AsVal_int(obj5, &val6);
13797 if (!SWIG_IsOK(ecode6)) {
13798 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13799 }
13800 arg6 = static_cast< int >(val6);
13801 }
13802 {
13803 PyThreadState* __tstate = wxPyBeginAllowThreads();
13804 {
13805 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13806 result = (wxImage *) &_result_ref;
13807 }
13808 wxPyEndAllowThreads(__tstate);
13809 if (PyErr_Occurred()) SWIG_fail;
13810 }
13811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13812 return resultobj;
13813 fail:
13814 return NULL;
13815 }
13816
13817
13818 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13819 PyObject *resultobj = 0;
13820 wxImage *arg1 = (wxImage *) 0 ;
13821 int arg2 ;
13822 int arg3 ;
13823 byte arg4 ;
13824 byte arg5 ;
13825 byte arg6 ;
13826 void *argp1 = 0 ;
13827 int res1 = 0 ;
13828 int val2 ;
13829 int ecode2 = 0 ;
13830 int val3 ;
13831 int ecode3 = 0 ;
13832 unsigned char val4 ;
13833 int ecode4 = 0 ;
13834 unsigned char val5 ;
13835 int ecode5 = 0 ;
13836 unsigned char val6 ;
13837 int ecode6 = 0 ;
13838 PyObject * obj0 = 0 ;
13839 PyObject * obj1 = 0 ;
13840 PyObject * obj2 = 0 ;
13841 PyObject * obj3 = 0 ;
13842 PyObject * obj4 = 0 ;
13843 PyObject * obj5 = 0 ;
13844 char * kwnames[] = {
13845 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13846 };
13847
13848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13850 if (!SWIG_IsOK(res1)) {
13851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13852 }
13853 arg1 = reinterpret_cast< wxImage * >(argp1);
13854 ecode2 = SWIG_AsVal_int(obj1, &val2);
13855 if (!SWIG_IsOK(ecode2)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13857 }
13858 arg2 = static_cast< int >(val2);
13859 ecode3 = SWIG_AsVal_int(obj2, &val3);
13860 if (!SWIG_IsOK(ecode3)) {
13861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13862 }
13863 arg3 = static_cast< int >(val3);
13864 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13865 if (!SWIG_IsOK(ecode4)) {
13866 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13867 }
13868 arg4 = static_cast< byte >(val4);
13869 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13870 if (!SWIG_IsOK(ecode5)) {
13871 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13872 }
13873 arg5 = static_cast< byte >(val5);
13874 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13875 if (!SWIG_IsOK(ecode6)) {
13876 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13877 }
13878 arg6 = static_cast< byte >(val6);
13879 {
13880 PyThreadState* __tstate = wxPyBeginAllowThreads();
13881 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13882 wxPyEndAllowThreads(__tstate);
13883 if (PyErr_Occurred()) SWIG_fail;
13884 }
13885 resultobj = SWIG_Py_Void();
13886 return resultobj;
13887 fail:
13888 return NULL;
13889 }
13890
13891
13892 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj = 0;
13894 wxImage *arg1 = (wxImage *) 0 ;
13895 wxRect *arg2 = 0 ;
13896 byte arg3 ;
13897 byte arg4 ;
13898 byte arg5 ;
13899 void *argp1 = 0 ;
13900 int res1 = 0 ;
13901 wxRect temp2 ;
13902 unsigned char val3 ;
13903 int ecode3 = 0 ;
13904 unsigned char val4 ;
13905 int ecode4 = 0 ;
13906 unsigned char val5 ;
13907 int ecode5 = 0 ;
13908 PyObject * obj0 = 0 ;
13909 PyObject * obj1 = 0 ;
13910 PyObject * obj2 = 0 ;
13911 PyObject * obj3 = 0 ;
13912 PyObject * obj4 = 0 ;
13913 char * kwnames[] = {
13914 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13915 };
13916
13917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13919 if (!SWIG_IsOK(res1)) {
13920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13921 }
13922 arg1 = reinterpret_cast< wxImage * >(argp1);
13923 {
13924 arg2 = &temp2;
13925 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13926 }
13927 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13928 if (!SWIG_IsOK(ecode3)) {
13929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13930 }
13931 arg3 = static_cast< byte >(val3);
13932 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13933 if (!SWIG_IsOK(ecode4)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13935 }
13936 arg4 = static_cast< byte >(val4);
13937 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13938 if (!SWIG_IsOK(ecode5)) {
13939 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13940 }
13941 arg5 = static_cast< byte >(val5);
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13945 wxPyEndAllowThreads(__tstate);
13946 if (PyErr_Occurred()) SWIG_fail;
13947 }
13948 resultobj = SWIG_Py_Void();
13949 return resultobj;
13950 fail:
13951 return NULL;
13952 }
13953
13954
13955 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13956 PyObject *resultobj = 0;
13957 wxImage *arg1 = (wxImage *) 0 ;
13958 int arg2 ;
13959 int arg3 ;
13960 byte result;
13961 void *argp1 = 0 ;
13962 int res1 = 0 ;
13963 int val2 ;
13964 int ecode2 = 0 ;
13965 int val3 ;
13966 int ecode3 = 0 ;
13967 PyObject * obj0 = 0 ;
13968 PyObject * obj1 = 0 ;
13969 PyObject * obj2 = 0 ;
13970 char * kwnames[] = {
13971 (char *) "self",(char *) "x",(char *) "y", NULL
13972 };
13973
13974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13976 if (!SWIG_IsOK(res1)) {
13977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13978 }
13979 arg1 = reinterpret_cast< wxImage * >(argp1);
13980 ecode2 = SWIG_AsVal_int(obj1, &val2);
13981 if (!SWIG_IsOK(ecode2)) {
13982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13983 }
13984 arg2 = static_cast< int >(val2);
13985 ecode3 = SWIG_AsVal_int(obj2, &val3);
13986 if (!SWIG_IsOK(ecode3)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13988 }
13989 arg3 = static_cast< int >(val3);
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 result = (byte)(arg1)->GetRed(arg2,arg3);
13993 wxPyEndAllowThreads(__tstate);
13994 if (PyErr_Occurred()) SWIG_fail;
13995 }
13996 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13997 return resultobj;
13998 fail:
13999 return NULL;
14000 }
14001
14002
14003 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14004 PyObject *resultobj = 0;
14005 wxImage *arg1 = (wxImage *) 0 ;
14006 int arg2 ;
14007 int arg3 ;
14008 byte result;
14009 void *argp1 = 0 ;
14010 int res1 = 0 ;
14011 int val2 ;
14012 int ecode2 = 0 ;
14013 int val3 ;
14014 int ecode3 = 0 ;
14015 PyObject * obj0 = 0 ;
14016 PyObject * obj1 = 0 ;
14017 PyObject * obj2 = 0 ;
14018 char * kwnames[] = {
14019 (char *) "self",(char *) "x",(char *) "y", NULL
14020 };
14021
14022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14024 if (!SWIG_IsOK(res1)) {
14025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14026 }
14027 arg1 = reinterpret_cast< wxImage * >(argp1);
14028 ecode2 = SWIG_AsVal_int(obj1, &val2);
14029 if (!SWIG_IsOK(ecode2)) {
14030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14031 }
14032 arg2 = static_cast< int >(val2);
14033 ecode3 = SWIG_AsVal_int(obj2, &val3);
14034 if (!SWIG_IsOK(ecode3)) {
14035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14036 }
14037 arg3 = static_cast< int >(val3);
14038 {
14039 PyThreadState* __tstate = wxPyBeginAllowThreads();
14040 result = (byte)(arg1)->GetGreen(arg2,arg3);
14041 wxPyEndAllowThreads(__tstate);
14042 if (PyErr_Occurred()) SWIG_fail;
14043 }
14044 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14045 return resultobj;
14046 fail:
14047 return NULL;
14048 }
14049
14050
14051 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14052 PyObject *resultobj = 0;
14053 wxImage *arg1 = (wxImage *) 0 ;
14054 int arg2 ;
14055 int arg3 ;
14056 byte result;
14057 void *argp1 = 0 ;
14058 int res1 = 0 ;
14059 int val2 ;
14060 int ecode2 = 0 ;
14061 int val3 ;
14062 int ecode3 = 0 ;
14063 PyObject * obj0 = 0 ;
14064 PyObject * obj1 = 0 ;
14065 PyObject * obj2 = 0 ;
14066 char * kwnames[] = {
14067 (char *) "self",(char *) "x",(char *) "y", NULL
14068 };
14069
14070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14072 if (!SWIG_IsOK(res1)) {
14073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14074 }
14075 arg1 = reinterpret_cast< wxImage * >(argp1);
14076 ecode2 = SWIG_AsVal_int(obj1, &val2);
14077 if (!SWIG_IsOK(ecode2)) {
14078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14079 }
14080 arg2 = static_cast< int >(val2);
14081 ecode3 = SWIG_AsVal_int(obj2, &val3);
14082 if (!SWIG_IsOK(ecode3)) {
14083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14084 }
14085 arg3 = static_cast< int >(val3);
14086 {
14087 PyThreadState* __tstate = wxPyBeginAllowThreads();
14088 result = (byte)(arg1)->GetBlue(arg2,arg3);
14089 wxPyEndAllowThreads(__tstate);
14090 if (PyErr_Occurred()) SWIG_fail;
14091 }
14092 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14093 return resultobj;
14094 fail:
14095 return NULL;
14096 }
14097
14098
14099 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14100 PyObject *resultobj = 0;
14101 wxImage *arg1 = (wxImage *) 0 ;
14102 int arg2 ;
14103 int arg3 ;
14104 byte arg4 ;
14105 void *argp1 = 0 ;
14106 int res1 = 0 ;
14107 int val2 ;
14108 int ecode2 = 0 ;
14109 int val3 ;
14110 int ecode3 = 0 ;
14111 unsigned char val4 ;
14112 int ecode4 = 0 ;
14113 PyObject * obj0 = 0 ;
14114 PyObject * obj1 = 0 ;
14115 PyObject * obj2 = 0 ;
14116 PyObject * obj3 = 0 ;
14117 char * kwnames[] = {
14118 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14119 };
14120
14121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14123 if (!SWIG_IsOK(res1)) {
14124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14125 }
14126 arg1 = reinterpret_cast< wxImage * >(argp1);
14127 ecode2 = SWIG_AsVal_int(obj1, &val2);
14128 if (!SWIG_IsOK(ecode2)) {
14129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14130 }
14131 arg2 = static_cast< int >(val2);
14132 ecode3 = SWIG_AsVal_int(obj2, &val3);
14133 if (!SWIG_IsOK(ecode3)) {
14134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14135 }
14136 arg3 = static_cast< int >(val3);
14137 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14138 if (!SWIG_IsOK(ecode4)) {
14139 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14140 }
14141 arg4 = static_cast< byte >(val4);
14142 {
14143 PyThreadState* __tstate = wxPyBeginAllowThreads();
14144 (arg1)->SetAlpha(arg2,arg3,arg4);
14145 wxPyEndAllowThreads(__tstate);
14146 if (PyErr_Occurred()) SWIG_fail;
14147 }
14148 resultobj = SWIG_Py_Void();
14149 return resultobj;
14150 fail:
14151 return NULL;
14152 }
14153
14154
14155 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14156 PyObject *resultobj = 0;
14157 wxImage *arg1 = (wxImage *) 0 ;
14158 int arg2 ;
14159 int arg3 ;
14160 byte result;
14161 void *argp1 = 0 ;
14162 int res1 = 0 ;
14163 int val2 ;
14164 int ecode2 = 0 ;
14165 int val3 ;
14166 int ecode3 = 0 ;
14167 PyObject * obj0 = 0 ;
14168 PyObject * obj1 = 0 ;
14169 PyObject * obj2 = 0 ;
14170 char * kwnames[] = {
14171 (char *) "self",(char *) "x",(char *) "y", NULL
14172 };
14173
14174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14176 if (!SWIG_IsOK(res1)) {
14177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14178 }
14179 arg1 = reinterpret_cast< wxImage * >(argp1);
14180 ecode2 = SWIG_AsVal_int(obj1, &val2);
14181 if (!SWIG_IsOK(ecode2)) {
14182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14183 }
14184 arg2 = static_cast< int >(val2);
14185 ecode3 = SWIG_AsVal_int(obj2, &val3);
14186 if (!SWIG_IsOK(ecode3)) {
14187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14188 }
14189 arg3 = static_cast< int >(val3);
14190 {
14191 PyThreadState* __tstate = wxPyBeginAllowThreads();
14192 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14193 wxPyEndAllowThreads(__tstate);
14194 if (PyErr_Occurred()) SWIG_fail;
14195 }
14196 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14197 return resultobj;
14198 fail:
14199 return NULL;
14200 }
14201
14202
14203 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14204 PyObject *resultobj = 0;
14205 wxImage *arg1 = (wxImage *) 0 ;
14206 bool result;
14207 void *argp1 = 0 ;
14208 int res1 = 0 ;
14209 PyObject *swig_obj[1] ;
14210
14211 if (!args) SWIG_fail;
14212 swig_obj[0] = args;
14213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14214 if (!SWIG_IsOK(res1)) {
14215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14216 }
14217 arg1 = reinterpret_cast< wxImage * >(argp1);
14218 {
14219 PyThreadState* __tstate = wxPyBeginAllowThreads();
14220 result = (bool)(arg1)->HasAlpha();
14221 wxPyEndAllowThreads(__tstate);
14222 if (PyErr_Occurred()) SWIG_fail;
14223 }
14224 {
14225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14226 }
14227 return resultobj;
14228 fail:
14229 return NULL;
14230 }
14231
14232
14233 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14234 PyObject *resultobj = 0;
14235 wxImage *arg1 = (wxImage *) 0 ;
14236 void *argp1 = 0 ;
14237 int res1 = 0 ;
14238 PyObject *swig_obj[1] ;
14239
14240 if (!args) SWIG_fail;
14241 swig_obj[0] = args;
14242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14243 if (!SWIG_IsOK(res1)) {
14244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14245 }
14246 arg1 = reinterpret_cast< wxImage * >(argp1);
14247 {
14248 PyThreadState* __tstate = wxPyBeginAllowThreads();
14249 (arg1)->InitAlpha();
14250 wxPyEndAllowThreads(__tstate);
14251 if (PyErr_Occurred()) SWIG_fail;
14252 }
14253 resultobj = SWIG_Py_Void();
14254 return resultobj;
14255 fail:
14256 return NULL;
14257 }
14258
14259
14260 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14261 PyObject *resultobj = 0;
14262 wxImage *arg1 = (wxImage *) 0 ;
14263 int arg2 ;
14264 int arg3 ;
14265 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14266 bool result;
14267 void *argp1 = 0 ;
14268 int res1 = 0 ;
14269 int val2 ;
14270 int ecode2 = 0 ;
14271 int val3 ;
14272 int ecode3 = 0 ;
14273 unsigned char val4 ;
14274 int ecode4 = 0 ;
14275 PyObject * obj0 = 0 ;
14276 PyObject * obj1 = 0 ;
14277 PyObject * obj2 = 0 ;
14278 PyObject * obj3 = 0 ;
14279 char * kwnames[] = {
14280 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14281 };
14282
14283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14285 if (!SWIG_IsOK(res1)) {
14286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14287 }
14288 arg1 = reinterpret_cast< wxImage * >(argp1);
14289 ecode2 = SWIG_AsVal_int(obj1, &val2);
14290 if (!SWIG_IsOK(ecode2)) {
14291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14292 }
14293 arg2 = static_cast< int >(val2);
14294 ecode3 = SWIG_AsVal_int(obj2, &val3);
14295 if (!SWIG_IsOK(ecode3)) {
14296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14297 }
14298 arg3 = static_cast< int >(val3);
14299 if (obj3) {
14300 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14301 if (!SWIG_IsOK(ecode4)) {
14302 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14303 }
14304 arg4 = static_cast< byte >(val4);
14305 }
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 {
14313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14314 }
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj = 0;
14323 wxImage *arg1 = (wxImage *) 0 ;
14324 byte *arg2 = (byte *) 0 ;
14325 byte *arg3 = (byte *) 0 ;
14326 byte *arg4 = (byte *) 0 ;
14327 byte arg5 = (byte) 0 ;
14328 byte arg6 = (byte) 0 ;
14329 byte arg7 = (byte) 0 ;
14330 bool result;
14331 void *argp1 = 0 ;
14332 int res1 = 0 ;
14333 byte temp2 ;
14334 int res2 = SWIG_TMPOBJ ;
14335 byte temp3 ;
14336 int res3 = SWIG_TMPOBJ ;
14337 byte temp4 ;
14338 int res4 = SWIG_TMPOBJ ;
14339 unsigned char val5 ;
14340 int ecode5 = 0 ;
14341 unsigned char val6 ;
14342 int ecode6 = 0 ;
14343 unsigned char val7 ;
14344 int ecode7 = 0 ;
14345 PyObject * obj0 = 0 ;
14346 PyObject * obj1 = 0 ;
14347 PyObject * obj2 = 0 ;
14348 PyObject * obj3 = 0 ;
14349 char * kwnames[] = {
14350 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14351 };
14352
14353 arg2 = &temp2;
14354 arg3 = &temp3;
14355 arg4 = &temp4;
14356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14358 if (!SWIG_IsOK(res1)) {
14359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14360 }
14361 arg1 = reinterpret_cast< wxImage * >(argp1);
14362 if (obj1) {
14363 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14364 if (!SWIG_IsOK(ecode5)) {
14365 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14366 }
14367 arg5 = static_cast< byte >(val5);
14368 }
14369 if (obj2) {
14370 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14371 if (!SWIG_IsOK(ecode6)) {
14372 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14373 }
14374 arg6 = static_cast< byte >(val6);
14375 }
14376 if (obj3) {
14377 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14378 if (!SWIG_IsOK(ecode7)) {
14379 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14380 }
14381 arg7 = static_cast< byte >(val7);
14382 }
14383 {
14384 PyThreadState* __tstate = wxPyBeginAllowThreads();
14385 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14386 wxPyEndAllowThreads(__tstate);
14387 if (PyErr_Occurred()) SWIG_fail;
14388 }
14389 {
14390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14391 }
14392 if (SWIG_IsTmpObj(res2)) {
14393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14394 } else {
14395 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14397 }
14398 if (SWIG_IsTmpObj(res3)) {
14399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14400 } else {
14401 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14403 }
14404 if (SWIG_IsTmpObj(res4)) {
14405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14406 } else {
14407 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14409 }
14410 return resultobj;
14411 fail:
14412 return NULL;
14413 }
14414
14415
14416 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj = 0;
14418 wxImage *arg1 = (wxImage *) 0 ;
14419 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14420 bool result;
14421 void *argp1 = 0 ;
14422 int res1 = 0 ;
14423 unsigned char val2 ;
14424 int ecode2 = 0 ;
14425 PyObject * obj0 = 0 ;
14426 PyObject * obj1 = 0 ;
14427 char * kwnames[] = {
14428 (char *) "self",(char *) "threshold", NULL
14429 };
14430
14431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14433 if (!SWIG_IsOK(res1)) {
14434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14435 }
14436 arg1 = reinterpret_cast< wxImage * >(argp1);
14437 if (obj1) {
14438 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14439 if (!SWIG_IsOK(ecode2)) {
14440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14441 }
14442 arg2 = static_cast< byte >(val2);
14443 }
14444 {
14445 PyThreadState* __tstate = wxPyBeginAllowThreads();
14446 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14447 wxPyEndAllowThreads(__tstate);
14448 if (PyErr_Occurred()) SWIG_fail;
14449 }
14450 {
14451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14452 }
14453 return resultobj;
14454 fail:
14455 return NULL;
14456 }
14457
14458
14459 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj = 0;
14461 wxImage *arg1 = (wxImage *) 0 ;
14462 byte arg2 ;
14463 byte arg3 ;
14464 byte arg4 ;
14465 bool result;
14466 void *argp1 = 0 ;
14467 int res1 = 0 ;
14468 unsigned char val2 ;
14469 int ecode2 = 0 ;
14470 unsigned char val3 ;
14471 int ecode3 = 0 ;
14472 unsigned char val4 ;
14473 int ecode4 = 0 ;
14474 PyObject * obj0 = 0 ;
14475 PyObject * obj1 = 0 ;
14476 PyObject * obj2 = 0 ;
14477 PyObject * obj3 = 0 ;
14478 char * kwnames[] = {
14479 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14480 };
14481
14482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14484 if (!SWIG_IsOK(res1)) {
14485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14486 }
14487 arg1 = reinterpret_cast< wxImage * >(argp1);
14488 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14489 if (!SWIG_IsOK(ecode2)) {
14490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14491 }
14492 arg2 = static_cast< byte >(val2);
14493 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14494 if (!SWIG_IsOK(ecode3)) {
14495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14496 }
14497 arg3 = static_cast< byte >(val3);
14498 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14499 if (!SWIG_IsOK(ecode4)) {
14500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14501 }
14502 arg4 = static_cast< byte >(val4);
14503 {
14504 PyThreadState* __tstate = wxPyBeginAllowThreads();
14505 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14506 wxPyEndAllowThreads(__tstate);
14507 if (PyErr_Occurred()) SWIG_fail;
14508 }
14509 {
14510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14511 }
14512 return resultobj;
14513 fail:
14514 return NULL;
14515 }
14516
14517
14518 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14519 PyObject *resultobj = 0;
14520 wxImage *arg1 = (wxImage *) 0 ;
14521 wxImage *arg2 = 0 ;
14522 byte arg3 ;
14523 byte arg4 ;
14524 byte arg5 ;
14525 bool result;
14526 void *argp1 = 0 ;
14527 int res1 = 0 ;
14528 void *argp2 = 0 ;
14529 int res2 = 0 ;
14530 unsigned char val3 ;
14531 int ecode3 = 0 ;
14532 unsigned char val4 ;
14533 int ecode4 = 0 ;
14534 unsigned char val5 ;
14535 int ecode5 = 0 ;
14536 PyObject * obj0 = 0 ;
14537 PyObject * obj1 = 0 ;
14538 PyObject * obj2 = 0 ;
14539 PyObject * obj3 = 0 ;
14540 PyObject * obj4 = 0 ;
14541 char * kwnames[] = {
14542 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14543 };
14544
14545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14547 if (!SWIG_IsOK(res1)) {
14548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14549 }
14550 arg1 = reinterpret_cast< wxImage * >(argp1);
14551 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14552 if (!SWIG_IsOK(res2)) {
14553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14554 }
14555 if (!argp2) {
14556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14557 }
14558 arg2 = reinterpret_cast< wxImage * >(argp2);
14559 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14560 if (!SWIG_IsOK(ecode3)) {
14561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14562 }
14563 arg3 = static_cast< byte >(val3);
14564 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14565 if (!SWIG_IsOK(ecode4)) {
14566 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14567 }
14568 arg4 = static_cast< byte >(val4);
14569 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14570 if (!SWIG_IsOK(ecode5)) {
14571 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14572 }
14573 arg5 = static_cast< byte >(val5);
14574 {
14575 PyThreadState* __tstate = wxPyBeginAllowThreads();
14576 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14577 wxPyEndAllowThreads(__tstate);
14578 if (PyErr_Occurred()) SWIG_fail;
14579 }
14580 {
14581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14582 }
14583 return resultobj;
14584 fail:
14585 return NULL;
14586 }
14587
14588
14589 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14590 PyObject *resultobj = 0;
14591 wxString *arg1 = 0 ;
14592 bool result;
14593 bool temp1 = false ;
14594 PyObject * obj0 = 0 ;
14595 char * kwnames[] = {
14596 (char *) "filename", NULL
14597 };
14598
14599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14600 {
14601 arg1 = wxString_in_helper(obj0);
14602 if (arg1 == NULL) SWIG_fail;
14603 temp1 = true;
14604 }
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 {
14612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14613 }
14614 {
14615 if (temp1)
14616 delete arg1;
14617 }
14618 return resultobj;
14619 fail:
14620 {
14621 if (temp1)
14622 delete arg1;
14623 }
14624 return NULL;
14625 }
14626
14627
14628 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14629 PyObject *resultobj = 0;
14630 wxString *arg1 = 0 ;
14631 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14632 int result;
14633 bool temp1 = false ;
14634 long val2 ;
14635 int ecode2 = 0 ;
14636 PyObject * obj0 = 0 ;
14637 PyObject * obj1 = 0 ;
14638 char * kwnames[] = {
14639 (char *) "filename",(char *) "type", NULL
14640 };
14641
14642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14643 {
14644 arg1 = wxString_in_helper(obj0);
14645 if (arg1 == NULL) SWIG_fail;
14646 temp1 = true;
14647 }
14648 if (obj1) {
14649 ecode2 = SWIG_AsVal_long(obj1, &val2);
14650 if (!SWIG_IsOK(ecode2)) {
14651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14652 }
14653 arg2 = static_cast< long >(val2);
14654 }
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 resultobj = SWIG_From_int(static_cast< int >(result));
14662 {
14663 if (temp1)
14664 delete arg1;
14665 }
14666 return resultobj;
14667 fail:
14668 {
14669 if (temp1)
14670 delete arg1;
14671 }
14672 return NULL;
14673 }
14674
14675
14676 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14677 PyObject *resultobj = 0;
14678 wxImage *arg1 = (wxImage *) 0 ;
14679 wxString *arg2 = 0 ;
14680 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14681 int arg4 = (int) -1 ;
14682 bool result;
14683 void *argp1 = 0 ;
14684 int res1 = 0 ;
14685 bool temp2 = false ;
14686 long val3 ;
14687 int ecode3 = 0 ;
14688 int val4 ;
14689 int ecode4 = 0 ;
14690 PyObject * obj0 = 0 ;
14691 PyObject * obj1 = 0 ;
14692 PyObject * obj2 = 0 ;
14693 PyObject * obj3 = 0 ;
14694 char * kwnames[] = {
14695 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14696 };
14697
14698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14700 if (!SWIG_IsOK(res1)) {
14701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14702 }
14703 arg1 = reinterpret_cast< wxImage * >(argp1);
14704 {
14705 arg2 = wxString_in_helper(obj1);
14706 if (arg2 == NULL) SWIG_fail;
14707 temp2 = true;
14708 }
14709 if (obj2) {
14710 ecode3 = SWIG_AsVal_long(obj2, &val3);
14711 if (!SWIG_IsOK(ecode3)) {
14712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14713 }
14714 arg3 = static_cast< long >(val3);
14715 }
14716 if (obj3) {
14717 ecode4 = SWIG_AsVal_int(obj3, &val4);
14718 if (!SWIG_IsOK(ecode4)) {
14719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14720 }
14721 arg4 = static_cast< int >(val4);
14722 }
14723 {
14724 PyThreadState* __tstate = wxPyBeginAllowThreads();
14725 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
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 (temp2)
14734 delete arg2;
14735 }
14736 return resultobj;
14737 fail:
14738 {
14739 if (temp2)
14740 delete arg2;
14741 }
14742 return NULL;
14743 }
14744
14745
14746 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14747 PyObject *resultobj = 0;
14748 wxImage *arg1 = (wxImage *) 0 ;
14749 wxString *arg2 = 0 ;
14750 wxString *arg3 = 0 ;
14751 int arg4 = (int) -1 ;
14752 bool result;
14753 void *argp1 = 0 ;
14754 int res1 = 0 ;
14755 bool temp2 = false ;
14756 bool temp3 = false ;
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 *) "name",(char *) "mimetype",(char *) "index", NULL
14765 };
14766
14767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",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_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14771 }
14772 arg1 = reinterpret_cast< wxImage * >(argp1);
14773 {
14774 arg2 = wxString_in_helper(obj1);
14775 if (arg2 == NULL) SWIG_fail;
14776 temp2 = true;
14777 }
14778 {
14779 arg3 = wxString_in_helper(obj2);
14780 if (arg3 == NULL) SWIG_fail;
14781 temp3 = true;
14782 }
14783 if (obj3) {
14784 ecode4 = SWIG_AsVal_int(obj3, &val4);
14785 if (!SWIG_IsOK(ecode4)) {
14786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14787 }
14788 arg4 = static_cast< int >(val4);
14789 }
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 {
14797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14798 }
14799 {
14800 if (temp2)
14801 delete arg2;
14802 }
14803 {
14804 if (temp3)
14805 delete arg3;
14806 }
14807 return resultobj;
14808 fail:
14809 {
14810 if (temp2)
14811 delete arg2;
14812 }
14813 {
14814 if (temp3)
14815 delete arg3;
14816 }
14817 return NULL;
14818 }
14819
14820
14821 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14822 PyObject *resultobj = 0;
14823 wxImage *arg1 = (wxImage *) 0 ;
14824 wxString *arg2 = 0 ;
14825 int arg3 ;
14826 bool result;
14827 void *argp1 = 0 ;
14828 int res1 = 0 ;
14829 bool temp2 = false ;
14830 int val3 ;
14831 int ecode3 = 0 ;
14832 PyObject * obj0 = 0 ;
14833 PyObject * obj1 = 0 ;
14834 PyObject * obj2 = 0 ;
14835 char * kwnames[] = {
14836 (char *) "self",(char *) "name",(char *) "type", NULL
14837 };
14838
14839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14841 if (!SWIG_IsOK(res1)) {
14842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14843 }
14844 arg1 = reinterpret_cast< wxImage * >(argp1);
14845 {
14846 arg2 = wxString_in_helper(obj1);
14847 if (arg2 == NULL) SWIG_fail;
14848 temp2 = true;
14849 }
14850 ecode3 = SWIG_AsVal_int(obj2, &val3);
14851 if (!SWIG_IsOK(ecode3)) {
14852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14853 }
14854 arg3 = static_cast< int >(val3);
14855 {
14856 PyThreadState* __tstate = wxPyBeginAllowThreads();
14857 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14858 wxPyEndAllowThreads(__tstate);
14859 if (PyErr_Occurred()) SWIG_fail;
14860 }
14861 {
14862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14863 }
14864 {
14865 if (temp2)
14866 delete arg2;
14867 }
14868 return resultobj;
14869 fail:
14870 {
14871 if (temp2)
14872 delete arg2;
14873 }
14874 return NULL;
14875 }
14876
14877
14878 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj = 0;
14880 wxImage *arg1 = (wxImage *) 0 ;
14881 wxString *arg2 = 0 ;
14882 wxString *arg3 = 0 ;
14883 bool result;
14884 void *argp1 = 0 ;
14885 int res1 = 0 ;
14886 bool temp2 = false ;
14887 bool temp3 = false ;
14888 PyObject * obj0 = 0 ;
14889 PyObject * obj1 = 0 ;
14890 PyObject * obj2 = 0 ;
14891 char * kwnames[] = {
14892 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14893 };
14894
14895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14897 if (!SWIG_IsOK(res1)) {
14898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14899 }
14900 arg1 = reinterpret_cast< wxImage * >(argp1);
14901 {
14902 arg2 = wxString_in_helper(obj1);
14903 if (arg2 == NULL) SWIG_fail;
14904 temp2 = true;
14905 }
14906 {
14907 arg3 = wxString_in_helper(obj2);
14908 if (arg3 == NULL) SWIG_fail;
14909 temp3 = true;
14910 }
14911 {
14912 PyThreadState* __tstate = wxPyBeginAllowThreads();
14913 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14914 wxPyEndAllowThreads(__tstate);
14915 if (PyErr_Occurred()) SWIG_fail;
14916 }
14917 {
14918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14919 }
14920 {
14921 if (temp2)
14922 delete arg2;
14923 }
14924 {
14925 if (temp3)
14926 delete arg3;
14927 }
14928 return resultobj;
14929 fail:
14930 {
14931 if (temp2)
14932 delete arg2;
14933 }
14934 {
14935 if (temp3)
14936 delete arg3;
14937 }
14938 return NULL;
14939 }
14940
14941
14942 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14943 PyObject *resultobj = 0;
14944 wxInputStream *arg1 = 0 ;
14945 bool result;
14946 wxPyInputStream *temp1 ;
14947 bool created1 ;
14948 PyObject * obj0 = 0 ;
14949 char * kwnames[] = {
14950 (char *) "stream", NULL
14951 };
14952
14953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14954 {
14955 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14956 arg1 = temp1->m_wxis;
14957 created1 = false;
14958 } else {
14959 PyErr_Clear(); // clear the failure of the wxPyConvert above
14960 arg1 = wxPyCBInputStream_create(obj0, false);
14961 if (arg1 == NULL) {
14962 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14963 SWIG_fail;
14964 }
14965 created1 = true;
14966 }
14967 }
14968 {
14969 PyThreadState* __tstate = wxPyBeginAllowThreads();
14970 result = (bool)wxImage::CanRead(*arg1);
14971 wxPyEndAllowThreads(__tstate);
14972 if (PyErr_Occurred()) SWIG_fail;
14973 }
14974 {
14975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14976 }
14977 {
14978 if (created1) delete arg1;
14979 }
14980 return resultobj;
14981 fail:
14982 {
14983 if (created1) delete arg1;
14984 }
14985 return NULL;
14986 }
14987
14988
14989 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj = 0;
14991 wxImage *arg1 = (wxImage *) 0 ;
14992 wxInputStream *arg2 = 0 ;
14993 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14994 int arg4 = (int) -1 ;
14995 bool result;
14996 void *argp1 = 0 ;
14997 int res1 = 0 ;
14998 wxPyInputStream *temp2 ;
14999 bool created2 ;
15000 long val3 ;
15001 int ecode3 = 0 ;
15002 int val4 ;
15003 int ecode4 = 0 ;
15004 PyObject * obj0 = 0 ;
15005 PyObject * obj1 = 0 ;
15006 PyObject * obj2 = 0 ;
15007 PyObject * obj3 = 0 ;
15008 char * kwnames[] = {
15009 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15010 };
15011
15012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15014 if (!SWIG_IsOK(res1)) {
15015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15016 }
15017 arg1 = reinterpret_cast< wxImage * >(argp1);
15018 {
15019 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15020 arg2 = temp2->m_wxis;
15021 created2 = false;
15022 } else {
15023 PyErr_Clear(); // clear the failure of the wxPyConvert above
15024 arg2 = wxPyCBInputStream_create(obj1, false);
15025 if (arg2 == NULL) {
15026 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15027 SWIG_fail;
15028 }
15029 created2 = true;
15030 }
15031 }
15032 if (obj2) {
15033 ecode3 = SWIG_AsVal_long(obj2, &val3);
15034 if (!SWIG_IsOK(ecode3)) {
15035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15036 }
15037 arg3 = static_cast< long >(val3);
15038 }
15039 if (obj3) {
15040 ecode4 = SWIG_AsVal_int(obj3, &val4);
15041 if (!SWIG_IsOK(ecode4)) {
15042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15043 }
15044 arg4 = static_cast< int >(val4);
15045 }
15046 {
15047 PyThreadState* __tstate = wxPyBeginAllowThreads();
15048 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 {
15053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15054 }
15055 {
15056 if (created2) delete arg2;
15057 }
15058 return resultobj;
15059 fail:
15060 {
15061 if (created2) delete arg2;
15062 }
15063 return NULL;
15064 }
15065
15066
15067 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15068 PyObject *resultobj = 0;
15069 wxImage *arg1 = (wxImage *) 0 ;
15070 wxInputStream *arg2 = 0 ;
15071 wxString *arg3 = 0 ;
15072 int arg4 = (int) -1 ;
15073 bool result;
15074 void *argp1 = 0 ;
15075 int res1 = 0 ;
15076 wxPyInputStream *temp2 ;
15077 bool created2 ;
15078 bool temp3 = false ;
15079 int val4 ;
15080 int ecode4 = 0 ;
15081 PyObject * obj0 = 0 ;
15082 PyObject * obj1 = 0 ;
15083 PyObject * obj2 = 0 ;
15084 PyObject * obj3 = 0 ;
15085 char * kwnames[] = {
15086 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15087 };
15088
15089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15091 if (!SWIG_IsOK(res1)) {
15092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15093 }
15094 arg1 = reinterpret_cast< wxImage * >(argp1);
15095 {
15096 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15097 arg2 = temp2->m_wxis;
15098 created2 = false;
15099 } else {
15100 PyErr_Clear(); // clear the failure of the wxPyConvert above
15101 arg2 = wxPyCBInputStream_create(obj1, false);
15102 if (arg2 == NULL) {
15103 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15104 SWIG_fail;
15105 }
15106 created2 = true;
15107 }
15108 }
15109 {
15110 arg3 = wxString_in_helper(obj2);
15111 if (arg3 == NULL) SWIG_fail;
15112 temp3 = true;
15113 }
15114 if (obj3) {
15115 ecode4 = SWIG_AsVal_int(obj3, &val4);
15116 if (!SWIG_IsOK(ecode4)) {
15117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15118 }
15119 arg4 = static_cast< int >(val4);
15120 }
15121 {
15122 PyThreadState* __tstate = wxPyBeginAllowThreads();
15123 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15124 wxPyEndAllowThreads(__tstate);
15125 if (PyErr_Occurred()) SWIG_fail;
15126 }
15127 {
15128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15129 }
15130 {
15131 if (created2) delete arg2;
15132 }
15133 {
15134 if (temp3)
15135 delete arg3;
15136 }
15137 return resultobj;
15138 fail:
15139 {
15140 if (created2) delete arg2;
15141 }
15142 {
15143 if (temp3)
15144 delete arg3;
15145 }
15146 return NULL;
15147 }
15148
15149
15150 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15151 PyObject *resultobj = 0;
15152 wxImage *arg1 = (wxImage *) 0 ;
15153 bool result;
15154 void *argp1 = 0 ;
15155 int res1 = 0 ;
15156 PyObject *swig_obj[1] ;
15157
15158 if (!args) SWIG_fail;
15159 swig_obj[0] = args;
15160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15161 if (!SWIG_IsOK(res1)) {
15162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15163 }
15164 arg1 = reinterpret_cast< wxImage * >(argp1);
15165 {
15166 PyThreadState* __tstate = wxPyBeginAllowThreads();
15167 result = (bool)(arg1)->Ok();
15168 wxPyEndAllowThreads(__tstate);
15169 if (PyErr_Occurred()) SWIG_fail;
15170 }
15171 {
15172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15173 }
15174 return resultobj;
15175 fail:
15176 return NULL;
15177 }
15178
15179
15180 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15181 PyObject *resultobj = 0;
15182 wxImage *arg1 = (wxImage *) 0 ;
15183 int result;
15184 void *argp1 = 0 ;
15185 int res1 = 0 ;
15186 PyObject *swig_obj[1] ;
15187
15188 if (!args) SWIG_fail;
15189 swig_obj[0] = args;
15190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15191 if (!SWIG_IsOK(res1)) {
15192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15193 }
15194 arg1 = reinterpret_cast< wxImage * >(argp1);
15195 {
15196 PyThreadState* __tstate = wxPyBeginAllowThreads();
15197 result = (int)(arg1)->GetWidth();
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 resultobj = SWIG_From_int(static_cast< int >(result));
15202 return resultobj;
15203 fail:
15204 return NULL;
15205 }
15206
15207
15208 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15209 PyObject *resultobj = 0;
15210 wxImage *arg1 = (wxImage *) 0 ;
15211 int result;
15212 void *argp1 = 0 ;
15213 int res1 = 0 ;
15214 PyObject *swig_obj[1] ;
15215
15216 if (!args) SWIG_fail;
15217 swig_obj[0] = args;
15218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15219 if (!SWIG_IsOK(res1)) {
15220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15221 }
15222 arg1 = reinterpret_cast< wxImage * >(argp1);
15223 {
15224 PyThreadState* __tstate = wxPyBeginAllowThreads();
15225 result = (int)(arg1)->GetHeight();
15226 wxPyEndAllowThreads(__tstate);
15227 if (PyErr_Occurred()) SWIG_fail;
15228 }
15229 resultobj = SWIG_From_int(static_cast< int >(result));
15230 return resultobj;
15231 fail:
15232 return NULL;
15233 }
15234
15235
15236 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15237 PyObject *resultobj = 0;
15238 wxImage *arg1 = (wxImage *) 0 ;
15239 wxSize result;
15240 void *argp1 = 0 ;
15241 int res1 = 0 ;
15242 PyObject *swig_obj[1] ;
15243
15244 if (!args) SWIG_fail;
15245 swig_obj[0] = args;
15246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15247 if (!SWIG_IsOK(res1)) {
15248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15249 }
15250 arg1 = reinterpret_cast< wxImage * >(argp1);
15251 {
15252 PyThreadState* __tstate = wxPyBeginAllowThreads();
15253 result = wxImage_GetSize(arg1);
15254 wxPyEndAllowThreads(__tstate);
15255 if (PyErr_Occurred()) SWIG_fail;
15256 }
15257 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15258 return resultobj;
15259 fail:
15260 return NULL;
15261 }
15262
15263
15264 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15265 PyObject *resultobj = 0;
15266 wxImage *arg1 = (wxImage *) 0 ;
15267 wxRect *arg2 = 0 ;
15268 SwigValueWrapper<wxImage > result;
15269 void *argp1 = 0 ;
15270 int res1 = 0 ;
15271 wxRect temp2 ;
15272 PyObject * obj0 = 0 ;
15273 PyObject * obj1 = 0 ;
15274 char * kwnames[] = {
15275 (char *) "self",(char *) "rect", NULL
15276 };
15277
15278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15280 if (!SWIG_IsOK(res1)) {
15281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15282 }
15283 arg1 = reinterpret_cast< wxImage * >(argp1);
15284 {
15285 arg2 = &temp2;
15286 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15287 }
15288 {
15289 PyThreadState* __tstate = wxPyBeginAllowThreads();
15290 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15302 PyObject *resultobj = 0;
15303 wxImage *arg1 = (wxImage *) 0 ;
15304 wxSize *arg2 = 0 ;
15305 wxPoint *arg3 = 0 ;
15306 int arg4 = (int) -1 ;
15307 int arg5 = (int) -1 ;
15308 int arg6 = (int) -1 ;
15309 SwigValueWrapper<wxImage > result;
15310 void *argp1 = 0 ;
15311 int res1 = 0 ;
15312 wxSize temp2 ;
15313 wxPoint temp3 ;
15314 int val4 ;
15315 int ecode4 = 0 ;
15316 int val5 ;
15317 int ecode5 = 0 ;
15318 int val6 ;
15319 int ecode6 = 0 ;
15320 PyObject * obj0 = 0 ;
15321 PyObject * obj1 = 0 ;
15322 PyObject * obj2 = 0 ;
15323 PyObject * obj3 = 0 ;
15324 PyObject * obj4 = 0 ;
15325 PyObject * obj5 = 0 ;
15326 char * kwnames[] = {
15327 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15328 };
15329
15330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15332 if (!SWIG_IsOK(res1)) {
15333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15334 }
15335 arg1 = reinterpret_cast< wxImage * >(argp1);
15336 {
15337 arg2 = &temp2;
15338 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15339 }
15340 {
15341 arg3 = &temp3;
15342 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15343 }
15344 if (obj3) {
15345 ecode4 = SWIG_AsVal_int(obj3, &val4);
15346 if (!SWIG_IsOK(ecode4)) {
15347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15348 }
15349 arg4 = static_cast< int >(val4);
15350 }
15351 if (obj4) {
15352 ecode5 = SWIG_AsVal_int(obj4, &val5);
15353 if (!SWIG_IsOK(ecode5)) {
15354 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15355 }
15356 arg5 = static_cast< int >(val5);
15357 }
15358 if (obj5) {
15359 ecode6 = SWIG_AsVal_int(obj5, &val6);
15360 if (!SWIG_IsOK(ecode6)) {
15361 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15362 }
15363 arg6 = static_cast< int >(val6);
15364 }
15365 {
15366 PyThreadState* __tstate = wxPyBeginAllowThreads();
15367 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15368 wxPyEndAllowThreads(__tstate);
15369 if (PyErr_Occurred()) SWIG_fail;
15370 }
15371 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15379 PyObject *resultobj = 0;
15380 wxImage *arg1 = (wxImage *) 0 ;
15381 SwigValueWrapper<wxImage > result;
15382 void *argp1 = 0 ;
15383 int res1 = 0 ;
15384 PyObject *swig_obj[1] ;
15385
15386 if (!args) SWIG_fail;
15387 swig_obj[0] = args;
15388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15389 if (!SWIG_IsOK(res1)) {
15390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15391 }
15392 arg1 = reinterpret_cast< wxImage * >(argp1);
15393 {
15394 PyThreadState* __tstate = wxPyBeginAllowThreads();
15395 result = (arg1)->Copy();
15396 wxPyEndAllowThreads(__tstate);
15397 if (PyErr_Occurred()) SWIG_fail;
15398 }
15399 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15407 PyObject *resultobj = 0;
15408 wxImage *arg1 = (wxImage *) 0 ;
15409 wxImage *arg2 = 0 ;
15410 int arg3 ;
15411 int arg4 ;
15412 void *argp1 = 0 ;
15413 int res1 = 0 ;
15414 void *argp2 = 0 ;
15415 int res2 = 0 ;
15416 int val3 ;
15417 int ecode3 = 0 ;
15418 int val4 ;
15419 int ecode4 = 0 ;
15420 PyObject * obj0 = 0 ;
15421 PyObject * obj1 = 0 ;
15422 PyObject * obj2 = 0 ;
15423 PyObject * obj3 = 0 ;
15424 char * kwnames[] = {
15425 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15426 };
15427
15428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15430 if (!SWIG_IsOK(res1)) {
15431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15432 }
15433 arg1 = reinterpret_cast< wxImage * >(argp1);
15434 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15435 if (!SWIG_IsOK(res2)) {
15436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15437 }
15438 if (!argp2) {
15439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15440 }
15441 arg2 = reinterpret_cast< wxImage * >(argp2);
15442 ecode3 = SWIG_AsVal_int(obj2, &val3);
15443 if (!SWIG_IsOK(ecode3)) {
15444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15445 }
15446 arg3 = static_cast< int >(val3);
15447 ecode4 = SWIG_AsVal_int(obj3, &val4);
15448 if (!SWIG_IsOK(ecode4)) {
15449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15450 }
15451 arg4 = static_cast< int >(val4);
15452 {
15453 PyThreadState* __tstate = wxPyBeginAllowThreads();
15454 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15455 wxPyEndAllowThreads(__tstate);
15456 if (PyErr_Occurred()) SWIG_fail;
15457 }
15458 resultobj = SWIG_Py_Void();
15459 return resultobj;
15460 fail:
15461 return NULL;
15462 }
15463
15464
15465 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15466 PyObject *resultobj = 0;
15467 wxImage *arg1 = (wxImage *) 0 ;
15468 PyObject *result = 0 ;
15469 void *argp1 = 0 ;
15470 int res1 = 0 ;
15471 PyObject *swig_obj[1] ;
15472
15473 if (!args) SWIG_fail;
15474 swig_obj[0] = args;
15475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15476 if (!SWIG_IsOK(res1)) {
15477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15478 }
15479 arg1 = reinterpret_cast< wxImage * >(argp1);
15480 {
15481 PyThreadState* __tstate = wxPyBeginAllowThreads();
15482 result = (PyObject *)wxImage_GetData(arg1);
15483 wxPyEndAllowThreads(__tstate);
15484 if (PyErr_Occurred()) SWIG_fail;
15485 }
15486 resultobj = result;
15487 return resultobj;
15488 fail:
15489 return NULL;
15490 }
15491
15492
15493 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15494 PyObject *resultobj = 0;
15495 wxImage *arg1 = (wxImage *) 0 ;
15496 buffer arg2 ;
15497 int arg3 ;
15498 void *argp1 = 0 ;
15499 int res1 = 0 ;
15500 Py_ssize_t temp2 ;
15501 PyObject * obj0 = 0 ;
15502 PyObject * obj1 = 0 ;
15503 char * kwnames[] = {
15504 (char *) "self",(char *) "data", NULL
15505 };
15506
15507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15509 if (!SWIG_IsOK(res1)) {
15510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15511 }
15512 arg1 = reinterpret_cast< wxImage * >(argp1);
15513 {
15514 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15515 arg3 = (int)temp2;
15516 }
15517 {
15518 PyThreadState* __tstate = wxPyBeginAllowThreads();
15519 wxImage_SetData(arg1,arg2,arg3);
15520 wxPyEndAllowThreads(__tstate);
15521 if (PyErr_Occurred()) SWIG_fail;
15522 }
15523 resultobj = SWIG_Py_Void();
15524 return resultobj;
15525 fail:
15526 return NULL;
15527 }
15528
15529
15530 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15531 PyObject *resultobj = 0;
15532 wxImage *arg1 = (wxImage *) 0 ;
15533 PyObject *result = 0 ;
15534 void *argp1 = 0 ;
15535 int res1 = 0 ;
15536 PyObject *swig_obj[1] ;
15537
15538 if (!args) SWIG_fail;
15539 swig_obj[0] = args;
15540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15541 if (!SWIG_IsOK(res1)) {
15542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15543 }
15544 arg1 = reinterpret_cast< wxImage * >(argp1);
15545 {
15546 PyThreadState* __tstate = wxPyBeginAllowThreads();
15547 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15548 wxPyEndAllowThreads(__tstate);
15549 if (PyErr_Occurred()) SWIG_fail;
15550 }
15551 resultobj = result;
15552 return resultobj;
15553 fail:
15554 return NULL;
15555 }
15556
15557
15558 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15559 PyObject *resultobj = 0;
15560 wxImage *arg1 = (wxImage *) 0 ;
15561 buffer arg2 ;
15562 int arg3 ;
15563 void *argp1 = 0 ;
15564 int res1 = 0 ;
15565 Py_ssize_t temp2 ;
15566 PyObject * obj0 = 0 ;
15567 PyObject * obj1 = 0 ;
15568 char * kwnames[] = {
15569 (char *) "self",(char *) "data", NULL
15570 };
15571
15572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15574 if (!SWIG_IsOK(res1)) {
15575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15576 }
15577 arg1 = reinterpret_cast< wxImage * >(argp1);
15578 {
15579 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15580 arg3 = (int)temp2;
15581 }
15582 {
15583 PyThreadState* __tstate = wxPyBeginAllowThreads();
15584 wxImage_SetDataBuffer(arg1,arg2,arg3);
15585 wxPyEndAllowThreads(__tstate);
15586 if (PyErr_Occurred()) SWIG_fail;
15587 }
15588 resultobj = SWIG_Py_Void();
15589 return resultobj;
15590 fail:
15591 return NULL;
15592 }
15593
15594
15595 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15596 PyObject *resultobj = 0;
15597 wxImage *arg1 = (wxImage *) 0 ;
15598 PyObject *result = 0 ;
15599 void *argp1 = 0 ;
15600 int res1 = 0 ;
15601 PyObject *swig_obj[1] ;
15602
15603 if (!args) SWIG_fail;
15604 swig_obj[0] = args;
15605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15606 if (!SWIG_IsOK(res1)) {
15607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15608 }
15609 arg1 = reinterpret_cast< wxImage * >(argp1);
15610 {
15611 PyThreadState* __tstate = wxPyBeginAllowThreads();
15612 result = (PyObject *)wxImage_GetAlphaData(arg1);
15613 wxPyEndAllowThreads(__tstate);
15614 if (PyErr_Occurred()) SWIG_fail;
15615 }
15616 resultobj = result;
15617 return resultobj;
15618 fail:
15619 return NULL;
15620 }
15621
15622
15623 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15624 PyObject *resultobj = 0;
15625 wxImage *arg1 = (wxImage *) 0 ;
15626 buffer arg2 ;
15627 int arg3 ;
15628 void *argp1 = 0 ;
15629 int res1 = 0 ;
15630 Py_ssize_t temp2 ;
15631 PyObject * obj0 = 0 ;
15632 PyObject * obj1 = 0 ;
15633 char * kwnames[] = {
15634 (char *) "self",(char *) "alpha", NULL
15635 };
15636
15637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15639 if (!SWIG_IsOK(res1)) {
15640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15641 }
15642 arg1 = reinterpret_cast< wxImage * >(argp1);
15643 {
15644 if (obj1 != Py_None) {
15645 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15646 arg3 = (int)temp2;
15647 }
15648 }
15649 {
15650 PyThreadState* __tstate = wxPyBeginAllowThreads();
15651 wxImage_SetAlphaData(arg1,arg2,arg3);
15652 wxPyEndAllowThreads(__tstate);
15653 if (PyErr_Occurred()) SWIG_fail;
15654 }
15655 resultobj = SWIG_Py_Void();
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15663 PyObject *resultobj = 0;
15664 wxImage *arg1 = (wxImage *) 0 ;
15665 PyObject *result = 0 ;
15666 void *argp1 = 0 ;
15667 int res1 = 0 ;
15668 PyObject *swig_obj[1] ;
15669
15670 if (!args) SWIG_fail;
15671 swig_obj[0] = args;
15672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15673 if (!SWIG_IsOK(res1)) {
15674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15675 }
15676 arg1 = reinterpret_cast< wxImage * >(argp1);
15677 {
15678 PyThreadState* __tstate = wxPyBeginAllowThreads();
15679 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15680 wxPyEndAllowThreads(__tstate);
15681 if (PyErr_Occurred()) SWIG_fail;
15682 }
15683 resultobj = result;
15684 return resultobj;
15685 fail:
15686 return NULL;
15687 }
15688
15689
15690 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15691 PyObject *resultobj = 0;
15692 wxImage *arg1 = (wxImage *) 0 ;
15693 buffer arg2 ;
15694 int arg3 ;
15695 void *argp1 = 0 ;
15696 int res1 = 0 ;
15697 Py_ssize_t temp2 ;
15698 PyObject * obj0 = 0 ;
15699 PyObject * obj1 = 0 ;
15700 char * kwnames[] = {
15701 (char *) "self",(char *) "alpha", NULL
15702 };
15703
15704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15706 if (!SWIG_IsOK(res1)) {
15707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15708 }
15709 arg1 = reinterpret_cast< wxImage * >(argp1);
15710 {
15711 if (obj1 != Py_None) {
15712 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15713 arg3 = (int)temp2;
15714 }
15715 }
15716 {
15717 PyThreadState* __tstate = wxPyBeginAllowThreads();
15718 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15719 wxPyEndAllowThreads(__tstate);
15720 if (PyErr_Occurred()) SWIG_fail;
15721 }
15722 resultobj = SWIG_Py_Void();
15723 return resultobj;
15724 fail:
15725 return NULL;
15726 }
15727
15728
15729 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15730 PyObject *resultobj = 0;
15731 wxImage *arg1 = (wxImage *) 0 ;
15732 byte arg2 ;
15733 byte arg3 ;
15734 byte arg4 ;
15735 void *argp1 = 0 ;
15736 int res1 = 0 ;
15737 unsigned char val2 ;
15738 int ecode2 = 0 ;
15739 unsigned char val3 ;
15740 int ecode3 = 0 ;
15741 unsigned char val4 ;
15742 int ecode4 = 0 ;
15743 PyObject * obj0 = 0 ;
15744 PyObject * obj1 = 0 ;
15745 PyObject * obj2 = 0 ;
15746 PyObject * obj3 = 0 ;
15747 char * kwnames[] = {
15748 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15749 };
15750
15751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15753 if (!SWIG_IsOK(res1)) {
15754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15755 }
15756 arg1 = reinterpret_cast< wxImage * >(argp1);
15757 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15758 if (!SWIG_IsOK(ecode2)) {
15759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15760 }
15761 arg2 = static_cast< byte >(val2);
15762 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15763 if (!SWIG_IsOK(ecode3)) {
15764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15765 }
15766 arg3 = static_cast< byte >(val3);
15767 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15768 if (!SWIG_IsOK(ecode4)) {
15769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15770 }
15771 arg4 = static_cast< byte >(val4);
15772 {
15773 PyThreadState* __tstate = wxPyBeginAllowThreads();
15774 (arg1)->SetMaskColour(arg2,arg3,arg4);
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 resultobj = SWIG_Py_Void();
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15786 PyObject *resultobj = 0;
15787 wxImage *arg1 = (wxImage *) 0 ;
15788 byte *arg2 = (byte *) 0 ;
15789 byte *arg3 = (byte *) 0 ;
15790 byte *arg4 = (byte *) 0 ;
15791 void *argp1 = 0 ;
15792 int res1 = 0 ;
15793 byte temp2 ;
15794 int res2 = SWIG_TMPOBJ ;
15795 byte temp3 ;
15796 int res3 = SWIG_TMPOBJ ;
15797 byte temp4 ;
15798 int res4 = SWIG_TMPOBJ ;
15799 PyObject *swig_obj[1] ;
15800
15801 arg2 = &temp2;
15802 arg3 = &temp3;
15803 arg4 = &temp4;
15804 if (!args) SWIG_fail;
15805 swig_obj[0] = args;
15806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15807 if (!SWIG_IsOK(res1)) {
15808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15809 }
15810 arg1 = reinterpret_cast< wxImage * >(argp1);
15811 {
15812 PyThreadState* __tstate = wxPyBeginAllowThreads();
15813 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15814 wxPyEndAllowThreads(__tstate);
15815 if (PyErr_Occurred()) SWIG_fail;
15816 }
15817 resultobj = SWIG_Py_Void();
15818 if (SWIG_IsTmpObj(res2)) {
15819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15820 } else {
15821 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15823 }
15824 if (SWIG_IsTmpObj(res3)) {
15825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15826 } else {
15827 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15829 }
15830 if (SWIG_IsTmpObj(res4)) {
15831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15832 } else {
15833 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15835 }
15836 return resultobj;
15837 fail:
15838 return NULL;
15839 }
15840
15841
15842 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15843 PyObject *resultobj = 0;
15844 wxImage *arg1 = (wxImage *) 0 ;
15845 byte result;
15846 void *argp1 = 0 ;
15847 int res1 = 0 ;
15848 PyObject *swig_obj[1] ;
15849
15850 if (!args) SWIG_fail;
15851 swig_obj[0] = args;
15852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15853 if (!SWIG_IsOK(res1)) {
15854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15855 }
15856 arg1 = reinterpret_cast< wxImage * >(argp1);
15857 {
15858 PyThreadState* __tstate = wxPyBeginAllowThreads();
15859 result = (byte)(arg1)->GetMaskRed();
15860 wxPyEndAllowThreads(__tstate);
15861 if (PyErr_Occurred()) SWIG_fail;
15862 }
15863 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15864 return resultobj;
15865 fail:
15866 return NULL;
15867 }
15868
15869
15870 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15871 PyObject *resultobj = 0;
15872 wxImage *arg1 = (wxImage *) 0 ;
15873 byte result;
15874 void *argp1 = 0 ;
15875 int res1 = 0 ;
15876 PyObject *swig_obj[1] ;
15877
15878 if (!args) SWIG_fail;
15879 swig_obj[0] = args;
15880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15881 if (!SWIG_IsOK(res1)) {
15882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15883 }
15884 arg1 = reinterpret_cast< wxImage * >(argp1);
15885 {
15886 PyThreadState* __tstate = wxPyBeginAllowThreads();
15887 result = (byte)(arg1)->GetMaskGreen();
15888 wxPyEndAllowThreads(__tstate);
15889 if (PyErr_Occurred()) SWIG_fail;
15890 }
15891 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15892 return resultobj;
15893 fail:
15894 return NULL;
15895 }
15896
15897
15898 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15899 PyObject *resultobj = 0;
15900 wxImage *arg1 = (wxImage *) 0 ;
15901 byte result;
15902 void *argp1 = 0 ;
15903 int res1 = 0 ;
15904 PyObject *swig_obj[1] ;
15905
15906 if (!args) SWIG_fail;
15907 swig_obj[0] = args;
15908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15909 if (!SWIG_IsOK(res1)) {
15910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15911 }
15912 arg1 = reinterpret_cast< wxImage * >(argp1);
15913 {
15914 PyThreadState* __tstate = wxPyBeginAllowThreads();
15915 result = (byte)(arg1)->GetMaskBlue();
15916 wxPyEndAllowThreads(__tstate);
15917 if (PyErr_Occurred()) SWIG_fail;
15918 }
15919 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15920 return resultobj;
15921 fail:
15922 return NULL;
15923 }
15924
15925
15926 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15927 PyObject *resultobj = 0;
15928 wxImage *arg1 = (wxImage *) 0 ;
15929 bool arg2 = (bool) true ;
15930 void *argp1 = 0 ;
15931 int res1 = 0 ;
15932 bool val2 ;
15933 int ecode2 = 0 ;
15934 PyObject * obj0 = 0 ;
15935 PyObject * obj1 = 0 ;
15936 char * kwnames[] = {
15937 (char *) "self",(char *) "mask", NULL
15938 };
15939
15940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15942 if (!SWIG_IsOK(res1)) {
15943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15944 }
15945 arg1 = reinterpret_cast< wxImage * >(argp1);
15946 if (obj1) {
15947 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15948 if (!SWIG_IsOK(ecode2)) {
15949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15950 }
15951 arg2 = static_cast< bool >(val2);
15952 }
15953 {
15954 PyThreadState* __tstate = wxPyBeginAllowThreads();
15955 (arg1)->SetMask(arg2);
15956 wxPyEndAllowThreads(__tstate);
15957 if (PyErr_Occurred()) SWIG_fail;
15958 }
15959 resultobj = SWIG_Py_Void();
15960 return resultobj;
15961 fail:
15962 return NULL;
15963 }
15964
15965
15966 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15967 PyObject *resultobj = 0;
15968 wxImage *arg1 = (wxImage *) 0 ;
15969 bool result;
15970 void *argp1 = 0 ;
15971 int res1 = 0 ;
15972 PyObject *swig_obj[1] ;
15973
15974 if (!args) SWIG_fail;
15975 swig_obj[0] = args;
15976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15977 if (!SWIG_IsOK(res1)) {
15978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15979 }
15980 arg1 = reinterpret_cast< wxImage * >(argp1);
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 result = (bool)(arg1)->HasMask();
15984 wxPyEndAllowThreads(__tstate);
15985 if (PyErr_Occurred()) SWIG_fail;
15986 }
15987 {
15988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15989 }
15990 return resultobj;
15991 fail:
15992 return NULL;
15993 }
15994
15995
15996 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15997 PyObject *resultobj = 0;
15998 wxImage *arg1 = (wxImage *) 0 ;
15999 double arg2 ;
16000 wxPoint *arg3 = 0 ;
16001 bool arg4 = (bool) true ;
16002 wxPoint *arg5 = (wxPoint *) NULL ;
16003 SwigValueWrapper<wxImage > result;
16004 void *argp1 = 0 ;
16005 int res1 = 0 ;
16006 double val2 ;
16007 int ecode2 = 0 ;
16008 wxPoint temp3 ;
16009 bool val4 ;
16010 int ecode4 = 0 ;
16011 void *argp5 = 0 ;
16012 int res5 = 0 ;
16013 PyObject * obj0 = 0 ;
16014 PyObject * obj1 = 0 ;
16015 PyObject * obj2 = 0 ;
16016 PyObject * obj3 = 0 ;
16017 PyObject * obj4 = 0 ;
16018 char * kwnames[] = {
16019 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16020 };
16021
16022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16024 if (!SWIG_IsOK(res1)) {
16025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16026 }
16027 arg1 = reinterpret_cast< wxImage * >(argp1);
16028 ecode2 = SWIG_AsVal_double(obj1, &val2);
16029 if (!SWIG_IsOK(ecode2)) {
16030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16031 }
16032 arg2 = static_cast< double >(val2);
16033 {
16034 arg3 = &temp3;
16035 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16036 }
16037 if (obj3) {
16038 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16039 if (!SWIG_IsOK(ecode4)) {
16040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16041 }
16042 arg4 = static_cast< bool >(val4);
16043 }
16044 if (obj4) {
16045 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16046 if (!SWIG_IsOK(res5)) {
16047 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16048 }
16049 arg5 = reinterpret_cast< wxPoint * >(argp5);
16050 }
16051 {
16052 PyThreadState* __tstate = wxPyBeginAllowThreads();
16053 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16054 wxPyEndAllowThreads(__tstate);
16055 if (PyErr_Occurred()) SWIG_fail;
16056 }
16057 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16058 return resultobj;
16059 fail:
16060 return NULL;
16061 }
16062
16063
16064 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj = 0;
16066 wxImage *arg1 = (wxImage *) 0 ;
16067 bool arg2 = (bool) true ;
16068 SwigValueWrapper<wxImage > result;
16069 void *argp1 = 0 ;
16070 int res1 = 0 ;
16071 bool val2 ;
16072 int ecode2 = 0 ;
16073 PyObject * obj0 = 0 ;
16074 PyObject * obj1 = 0 ;
16075 char * kwnames[] = {
16076 (char *) "self",(char *) "clockwise", NULL
16077 };
16078
16079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16081 if (!SWIG_IsOK(res1)) {
16082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16083 }
16084 arg1 = reinterpret_cast< wxImage * >(argp1);
16085 if (obj1) {
16086 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16087 if (!SWIG_IsOK(ecode2)) {
16088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16089 }
16090 arg2 = static_cast< bool >(val2);
16091 }
16092 {
16093 PyThreadState* __tstate = wxPyBeginAllowThreads();
16094 result = (arg1)->Rotate90(arg2);
16095 wxPyEndAllowThreads(__tstate);
16096 if (PyErr_Occurred()) SWIG_fail;
16097 }
16098 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16099 return resultobj;
16100 fail:
16101 return NULL;
16102 }
16103
16104
16105 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16106 PyObject *resultobj = 0;
16107 wxImage *arg1 = (wxImage *) 0 ;
16108 bool arg2 = (bool) true ;
16109 SwigValueWrapper<wxImage > result;
16110 void *argp1 = 0 ;
16111 int res1 = 0 ;
16112 bool val2 ;
16113 int ecode2 = 0 ;
16114 PyObject * obj0 = 0 ;
16115 PyObject * obj1 = 0 ;
16116 char * kwnames[] = {
16117 (char *) "self",(char *) "horizontally", NULL
16118 };
16119
16120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16122 if (!SWIG_IsOK(res1)) {
16123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16124 }
16125 arg1 = reinterpret_cast< wxImage * >(argp1);
16126 if (obj1) {
16127 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16128 if (!SWIG_IsOK(ecode2)) {
16129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16130 }
16131 arg2 = static_cast< bool >(val2);
16132 }
16133 {
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 result = (arg1)->Mirror(arg2);
16136 wxPyEndAllowThreads(__tstate);
16137 if (PyErr_Occurred()) SWIG_fail;
16138 }
16139 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16140 return resultobj;
16141 fail:
16142 return NULL;
16143 }
16144
16145
16146 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16147 PyObject *resultobj = 0;
16148 wxImage *arg1 = (wxImage *) 0 ;
16149 byte arg2 ;
16150 byte arg3 ;
16151 byte arg4 ;
16152 byte arg5 ;
16153 byte arg6 ;
16154 byte arg7 ;
16155 void *argp1 = 0 ;
16156 int res1 = 0 ;
16157 unsigned char val2 ;
16158 int ecode2 = 0 ;
16159 unsigned char val3 ;
16160 int ecode3 = 0 ;
16161 unsigned char val4 ;
16162 int ecode4 = 0 ;
16163 unsigned char val5 ;
16164 int ecode5 = 0 ;
16165 unsigned char val6 ;
16166 int ecode6 = 0 ;
16167 unsigned char val7 ;
16168 int ecode7 = 0 ;
16169 PyObject * obj0 = 0 ;
16170 PyObject * obj1 = 0 ;
16171 PyObject * obj2 = 0 ;
16172 PyObject * obj3 = 0 ;
16173 PyObject * obj4 = 0 ;
16174 PyObject * obj5 = 0 ;
16175 PyObject * obj6 = 0 ;
16176 char * kwnames[] = {
16177 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16178 };
16179
16180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16182 if (!SWIG_IsOK(res1)) {
16183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16184 }
16185 arg1 = reinterpret_cast< wxImage * >(argp1);
16186 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16187 if (!SWIG_IsOK(ecode2)) {
16188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16189 }
16190 arg2 = static_cast< byte >(val2);
16191 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16192 if (!SWIG_IsOK(ecode3)) {
16193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16194 }
16195 arg3 = static_cast< byte >(val3);
16196 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16197 if (!SWIG_IsOK(ecode4)) {
16198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16199 }
16200 arg4 = static_cast< byte >(val4);
16201 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16202 if (!SWIG_IsOK(ecode5)) {
16203 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16204 }
16205 arg5 = static_cast< byte >(val5);
16206 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16207 if (!SWIG_IsOK(ecode6)) {
16208 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16209 }
16210 arg6 = static_cast< byte >(val6);
16211 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16212 if (!SWIG_IsOK(ecode7)) {
16213 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16214 }
16215 arg7 = static_cast< byte >(val7);
16216 {
16217 PyThreadState* __tstate = wxPyBeginAllowThreads();
16218 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16219 wxPyEndAllowThreads(__tstate);
16220 if (PyErr_Occurred()) SWIG_fail;
16221 }
16222 resultobj = SWIG_Py_Void();
16223 return resultobj;
16224 fail:
16225 return NULL;
16226 }
16227
16228
16229 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16230 PyObject *resultobj = 0;
16231 wxImage *arg1 = (wxImage *) 0 ;
16232 double arg2 = (double) 0.299 ;
16233 double arg3 = (double) 0.587 ;
16234 double arg4 = (double) 0.114 ;
16235 SwigValueWrapper<wxImage > result;
16236 void *argp1 = 0 ;
16237 int res1 = 0 ;
16238 double val2 ;
16239 int ecode2 = 0 ;
16240 double val3 ;
16241 int ecode3 = 0 ;
16242 double val4 ;
16243 int ecode4 = 0 ;
16244 PyObject * obj0 = 0 ;
16245 PyObject * obj1 = 0 ;
16246 PyObject * obj2 = 0 ;
16247 PyObject * obj3 = 0 ;
16248 char * kwnames[] = {
16249 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16250 };
16251
16252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16254 if (!SWIG_IsOK(res1)) {
16255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16256 }
16257 arg1 = reinterpret_cast< wxImage * >(argp1);
16258 if (obj1) {
16259 ecode2 = SWIG_AsVal_double(obj1, &val2);
16260 if (!SWIG_IsOK(ecode2)) {
16261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16262 }
16263 arg2 = static_cast< double >(val2);
16264 }
16265 if (obj2) {
16266 ecode3 = SWIG_AsVal_double(obj2, &val3);
16267 if (!SWIG_IsOK(ecode3)) {
16268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16269 }
16270 arg3 = static_cast< double >(val3);
16271 }
16272 if (obj3) {
16273 ecode4 = SWIG_AsVal_double(obj3, &val4);
16274 if (!SWIG_IsOK(ecode4)) {
16275 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16276 }
16277 arg4 = static_cast< double >(val4);
16278 }
16279 {
16280 PyThreadState* __tstate = wxPyBeginAllowThreads();
16281 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16282 wxPyEndAllowThreads(__tstate);
16283 if (PyErr_Occurred()) SWIG_fail;
16284 }
16285 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16286 return resultobj;
16287 fail:
16288 return NULL;
16289 }
16290
16291
16292 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16293 PyObject *resultobj = 0;
16294 wxImage *arg1 = (wxImage *) 0 ;
16295 byte arg2 ;
16296 byte arg3 ;
16297 byte arg4 ;
16298 SwigValueWrapper<wxImage > result;
16299 void *argp1 = 0 ;
16300 int res1 = 0 ;
16301 unsigned char val2 ;
16302 int ecode2 = 0 ;
16303 unsigned char val3 ;
16304 int ecode3 = 0 ;
16305 unsigned char val4 ;
16306 int ecode4 = 0 ;
16307 PyObject * obj0 = 0 ;
16308 PyObject * obj1 = 0 ;
16309 PyObject * obj2 = 0 ;
16310 PyObject * obj3 = 0 ;
16311 char * kwnames[] = {
16312 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16313 };
16314
16315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16317 if (!SWIG_IsOK(res1)) {
16318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16319 }
16320 arg1 = reinterpret_cast< wxImage * >(argp1);
16321 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16322 if (!SWIG_IsOK(ecode2)) {
16323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16324 }
16325 arg2 = static_cast< byte >(val2);
16326 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16327 if (!SWIG_IsOK(ecode3)) {
16328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16329 }
16330 arg3 = static_cast< byte >(val3);
16331 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16332 if (!SWIG_IsOK(ecode4)) {
16333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16334 }
16335 arg4 = static_cast< byte >(val4);
16336 {
16337 PyThreadState* __tstate = wxPyBeginAllowThreads();
16338 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16343 return resultobj;
16344 fail:
16345 return NULL;
16346 }
16347
16348
16349 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16350 PyObject *resultobj = 0;
16351 wxImage *arg1 = (wxImage *) 0 ;
16352 wxString *arg2 = 0 ;
16353 wxString *arg3 = 0 ;
16354 void *argp1 = 0 ;
16355 int res1 = 0 ;
16356 bool temp2 = false ;
16357 bool temp3 = false ;
16358 PyObject * obj0 = 0 ;
16359 PyObject * obj1 = 0 ;
16360 PyObject * obj2 = 0 ;
16361 char * kwnames[] = {
16362 (char *) "self",(char *) "name",(char *) "value", NULL
16363 };
16364
16365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16367 if (!SWIG_IsOK(res1)) {
16368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16369 }
16370 arg1 = reinterpret_cast< wxImage * >(argp1);
16371 {
16372 arg2 = wxString_in_helper(obj1);
16373 if (arg2 == NULL) SWIG_fail;
16374 temp2 = true;
16375 }
16376 {
16377 arg3 = wxString_in_helper(obj2);
16378 if (arg3 == NULL) SWIG_fail;
16379 temp3 = true;
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16384 wxPyEndAllowThreads(__tstate);
16385 if (PyErr_Occurred()) SWIG_fail;
16386 }
16387 resultobj = SWIG_Py_Void();
16388 {
16389 if (temp2)
16390 delete arg2;
16391 }
16392 {
16393 if (temp3)
16394 delete arg3;
16395 }
16396 return resultobj;
16397 fail:
16398 {
16399 if (temp2)
16400 delete arg2;
16401 }
16402 {
16403 if (temp3)
16404 delete arg3;
16405 }
16406 return NULL;
16407 }
16408
16409
16410 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16411 PyObject *resultobj = 0;
16412 wxImage *arg1 = (wxImage *) 0 ;
16413 wxString *arg2 = 0 ;
16414 int arg3 ;
16415 void *argp1 = 0 ;
16416 int res1 = 0 ;
16417 bool temp2 = false ;
16418 int val3 ;
16419 int ecode3 = 0 ;
16420 PyObject * obj0 = 0 ;
16421 PyObject * obj1 = 0 ;
16422 PyObject * obj2 = 0 ;
16423 char * kwnames[] = {
16424 (char *) "self",(char *) "name",(char *) "value", NULL
16425 };
16426
16427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16429 if (!SWIG_IsOK(res1)) {
16430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16431 }
16432 arg1 = reinterpret_cast< wxImage * >(argp1);
16433 {
16434 arg2 = wxString_in_helper(obj1);
16435 if (arg2 == NULL) SWIG_fail;
16436 temp2 = true;
16437 }
16438 ecode3 = SWIG_AsVal_int(obj2, &val3);
16439 if (!SWIG_IsOK(ecode3)) {
16440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16441 }
16442 arg3 = static_cast< int >(val3);
16443 {
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 (arg1)->SetOption((wxString const &)*arg2,arg3);
16446 wxPyEndAllowThreads(__tstate);
16447 if (PyErr_Occurred()) SWIG_fail;
16448 }
16449 resultobj = SWIG_Py_Void();
16450 {
16451 if (temp2)
16452 delete arg2;
16453 }
16454 return resultobj;
16455 fail:
16456 {
16457 if (temp2)
16458 delete arg2;
16459 }
16460 return NULL;
16461 }
16462
16463
16464 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16465 PyObject *resultobj = 0;
16466 wxImage *arg1 = (wxImage *) 0 ;
16467 wxString *arg2 = 0 ;
16468 wxString result;
16469 void *argp1 = 0 ;
16470 int res1 = 0 ;
16471 bool temp2 = false ;
16472 PyObject * obj0 = 0 ;
16473 PyObject * obj1 = 0 ;
16474 char * kwnames[] = {
16475 (char *) "self",(char *) "name", NULL
16476 };
16477
16478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16480 if (!SWIG_IsOK(res1)) {
16481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16482 }
16483 arg1 = reinterpret_cast< wxImage * >(argp1);
16484 {
16485 arg2 = wxString_in_helper(obj1);
16486 if (arg2 == NULL) SWIG_fail;
16487 temp2 = true;
16488 }
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16492 wxPyEndAllowThreads(__tstate);
16493 if (PyErr_Occurred()) SWIG_fail;
16494 }
16495 {
16496 #if wxUSE_UNICODE
16497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16498 #else
16499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16500 #endif
16501 }
16502 {
16503 if (temp2)
16504 delete arg2;
16505 }
16506 return resultobj;
16507 fail:
16508 {
16509 if (temp2)
16510 delete arg2;
16511 }
16512 return NULL;
16513 }
16514
16515
16516 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16517 PyObject *resultobj = 0;
16518 wxImage *arg1 = (wxImage *) 0 ;
16519 wxString *arg2 = 0 ;
16520 int result;
16521 void *argp1 = 0 ;
16522 int res1 = 0 ;
16523 bool temp2 = false ;
16524 PyObject * obj0 = 0 ;
16525 PyObject * obj1 = 0 ;
16526 char * kwnames[] = {
16527 (char *) "self",(char *) "name", NULL
16528 };
16529
16530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16532 if (!SWIG_IsOK(res1)) {
16533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16534 }
16535 arg1 = reinterpret_cast< wxImage * >(argp1);
16536 {
16537 arg2 = wxString_in_helper(obj1);
16538 if (arg2 == NULL) SWIG_fail;
16539 temp2 = true;
16540 }
16541 {
16542 PyThreadState* __tstate = wxPyBeginAllowThreads();
16543 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16544 wxPyEndAllowThreads(__tstate);
16545 if (PyErr_Occurred()) SWIG_fail;
16546 }
16547 resultobj = SWIG_From_int(static_cast< int >(result));
16548 {
16549 if (temp2)
16550 delete arg2;
16551 }
16552 return resultobj;
16553 fail:
16554 {
16555 if (temp2)
16556 delete arg2;
16557 }
16558 return NULL;
16559 }
16560
16561
16562 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16563 PyObject *resultobj = 0;
16564 wxImage *arg1 = (wxImage *) 0 ;
16565 wxString *arg2 = 0 ;
16566 bool result;
16567 void *argp1 = 0 ;
16568 int res1 = 0 ;
16569 bool temp2 = false ;
16570 PyObject * obj0 = 0 ;
16571 PyObject * obj1 = 0 ;
16572 char * kwnames[] = {
16573 (char *) "self",(char *) "name", NULL
16574 };
16575
16576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16578 if (!SWIG_IsOK(res1)) {
16579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16580 }
16581 arg1 = reinterpret_cast< wxImage * >(argp1);
16582 {
16583 arg2 = wxString_in_helper(obj1);
16584 if (arg2 == NULL) SWIG_fail;
16585 temp2 = true;
16586 }
16587 {
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 {
16594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16595 }
16596 {
16597 if (temp2)
16598 delete arg2;
16599 }
16600 return resultobj;
16601 fail:
16602 {
16603 if (temp2)
16604 delete arg2;
16605 }
16606 return NULL;
16607 }
16608
16609
16610 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16611 PyObject *resultobj = 0;
16612 wxImage *arg1 = (wxImage *) 0 ;
16613 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16614 unsigned long result;
16615 void *argp1 = 0 ;
16616 int res1 = 0 ;
16617 unsigned long val2 ;
16618 int ecode2 = 0 ;
16619 PyObject * obj0 = 0 ;
16620 PyObject * obj1 = 0 ;
16621 char * kwnames[] = {
16622 (char *) "self",(char *) "stopafter", NULL
16623 };
16624
16625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16627 if (!SWIG_IsOK(res1)) {
16628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16629 }
16630 arg1 = reinterpret_cast< wxImage * >(argp1);
16631 if (obj1) {
16632 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16633 if (!SWIG_IsOK(ecode2)) {
16634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16635 }
16636 arg2 = static_cast< unsigned long >(val2);
16637 }
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 result = (unsigned long)(arg1)->CountColours(arg2);
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16652 PyObject *resultobj = 0;
16653 wxImage *arg1 = (wxImage *) 0 ;
16654 wxImageHistogram *arg2 = 0 ;
16655 unsigned long result;
16656 void *argp1 = 0 ;
16657 int res1 = 0 ;
16658 void *argp2 = 0 ;
16659 int res2 = 0 ;
16660 PyObject * obj0 = 0 ;
16661 PyObject * obj1 = 0 ;
16662 char * kwnames[] = {
16663 (char *) "self",(char *) "h", NULL
16664 };
16665
16666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16668 if (!SWIG_IsOK(res1)) {
16669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16670 }
16671 arg1 = reinterpret_cast< wxImage * >(argp1);
16672 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16673 if (!SWIG_IsOK(res2)) {
16674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16675 }
16676 if (!argp2) {
16677 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16678 }
16679 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16694 PyObject *resultobj = 0;
16695 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16696 void *argp1 = 0 ;
16697 int res1 = 0 ;
16698 PyObject * obj0 = 0 ;
16699 char * kwnames[] = {
16700 (char *) "handler", NULL
16701 };
16702
16703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16705 if (!SWIG_IsOK(res1)) {
16706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16707 }
16708 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 wxImage::AddHandler(arg1);
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_Py_Void();
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj = 0;
16724 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16725 void *argp1 = 0 ;
16726 int res1 = 0 ;
16727 PyObject * obj0 = 0 ;
16728 char * kwnames[] = {
16729 (char *) "handler", NULL
16730 };
16731
16732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16734 if (!SWIG_IsOK(res1)) {
16735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16736 }
16737 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16738 {
16739 PyThreadState* __tstate = wxPyBeginAllowThreads();
16740 wxImage::InsertHandler(arg1);
16741 wxPyEndAllowThreads(__tstate);
16742 if (PyErr_Occurred()) SWIG_fail;
16743 }
16744 resultobj = SWIG_Py_Void();
16745 return resultobj;
16746 fail:
16747 return NULL;
16748 }
16749
16750
16751 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16752 PyObject *resultobj = 0;
16753 wxString *arg1 = 0 ;
16754 bool result;
16755 bool temp1 = false ;
16756 PyObject * obj0 = 0 ;
16757 char * kwnames[] = {
16758 (char *) "name", NULL
16759 };
16760
16761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16762 {
16763 arg1 = wxString_in_helper(obj0);
16764 if (arg1 == NULL) SWIG_fail;
16765 temp1 = true;
16766 }
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 {
16774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16775 }
16776 {
16777 if (temp1)
16778 delete arg1;
16779 }
16780 return resultobj;
16781 fail:
16782 {
16783 if (temp1)
16784 delete arg1;
16785 }
16786 return NULL;
16787 }
16788
16789
16790 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16791 PyObject *resultobj = 0;
16792 PyObject *result = 0 ;
16793
16794 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16795 {
16796 PyThreadState* __tstate = wxPyBeginAllowThreads();
16797 result = (PyObject *)wxImage_GetHandlers();
16798 wxPyEndAllowThreads(__tstate);
16799 if (PyErr_Occurred()) SWIG_fail;
16800 }
16801 resultobj = result;
16802 return resultobj;
16803 fail:
16804 return NULL;
16805 }
16806
16807
16808 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16809 PyObject *resultobj = 0;
16810 wxString result;
16811
16812 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16813 {
16814 PyThreadState* __tstate = wxPyBeginAllowThreads();
16815 result = wxImage::GetImageExtWildcard();
16816 wxPyEndAllowThreads(__tstate);
16817 if (PyErr_Occurred()) SWIG_fail;
16818 }
16819 {
16820 #if wxUSE_UNICODE
16821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16822 #else
16823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16824 #endif
16825 }
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj = 0;
16834 wxImage *arg1 = (wxImage *) 0 ;
16835 int arg2 = (int) -1 ;
16836 wxBitmap result;
16837 void *argp1 = 0 ;
16838 int res1 = 0 ;
16839 int val2 ;
16840 int ecode2 = 0 ;
16841 PyObject * obj0 = 0 ;
16842 PyObject * obj1 = 0 ;
16843 char * kwnames[] = {
16844 (char *) "self",(char *) "depth", NULL
16845 };
16846
16847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16849 if (!SWIG_IsOK(res1)) {
16850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16851 }
16852 arg1 = reinterpret_cast< wxImage * >(argp1);
16853 if (obj1) {
16854 ecode2 = SWIG_AsVal_int(obj1, &val2);
16855 if (!SWIG_IsOK(ecode2)) {
16856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16857 }
16858 arg2 = static_cast< int >(val2);
16859 }
16860 {
16861 if (!wxPyCheckForApp()) SWIG_fail;
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 result = wxImage_ConvertToBitmap(arg1,arg2);
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj = 0;
16876 wxImage *arg1 = (wxImage *) 0 ;
16877 byte arg2 ;
16878 byte arg3 ;
16879 byte arg4 ;
16880 wxBitmap result;
16881 void *argp1 = 0 ;
16882 int res1 = 0 ;
16883 unsigned char val2 ;
16884 int ecode2 = 0 ;
16885 unsigned char val3 ;
16886 int ecode3 = 0 ;
16887 unsigned char val4 ;
16888 int ecode4 = 0 ;
16889 PyObject * obj0 = 0 ;
16890 PyObject * obj1 = 0 ;
16891 PyObject * obj2 = 0 ;
16892 PyObject * obj3 = 0 ;
16893 char * kwnames[] = {
16894 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16895 };
16896
16897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16899 if (!SWIG_IsOK(res1)) {
16900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16901 }
16902 arg1 = reinterpret_cast< wxImage * >(argp1);
16903 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16904 if (!SWIG_IsOK(ecode2)) {
16905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16906 }
16907 arg2 = static_cast< byte >(val2);
16908 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16909 if (!SWIG_IsOK(ecode3)) {
16910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16911 }
16912 arg3 = static_cast< byte >(val3);
16913 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16914 if (!SWIG_IsOK(ecode4)) {
16915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16916 }
16917 arg4 = static_cast< byte >(val4);
16918 {
16919 if (!wxPyCheckForApp()) SWIG_fail;
16920 PyThreadState* __tstate = wxPyBeginAllowThreads();
16921 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj = 0;
16934 wxImage *arg1 = (wxImage *) 0 ;
16935 double arg2 ;
16936 void *argp1 = 0 ;
16937 int res1 = 0 ;
16938 double val2 ;
16939 int ecode2 = 0 ;
16940 PyObject * obj0 = 0 ;
16941 PyObject * obj1 = 0 ;
16942 char * kwnames[] = {
16943 (char *) "self",(char *) "angle", NULL
16944 };
16945
16946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16948 if (!SWIG_IsOK(res1)) {
16949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16950 }
16951 arg1 = reinterpret_cast< wxImage * >(argp1);
16952 ecode2 = SWIG_AsVal_double(obj1, &val2);
16953 if (!SWIG_IsOK(ecode2)) {
16954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16955 }
16956 arg2 = static_cast< double >(val2);
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 (arg1)->RotateHue(arg2);
16960 wxPyEndAllowThreads(__tstate);
16961 if (PyErr_Occurred()) SWIG_fail;
16962 }
16963 resultobj = SWIG_Py_Void();
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16971 PyObject *resultobj = 0;
16972 wxImage_RGBValue arg1 ;
16973 wxImage_HSVValue result;
16974 void *argp1 ;
16975 int res1 = 0 ;
16976 PyObject * obj0 = 0 ;
16977 char * kwnames[] = {
16978 (char *) "rgb", NULL
16979 };
16980
16981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16982 {
16983 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16984 if (!SWIG_IsOK(res1)) {
16985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16986 }
16987 if (!argp1) {
16988 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16989 } else {
16990 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16991 arg1 = *temp;
16992 if (SWIG_IsNewObj(res1)) delete temp;
16993 }
16994 }
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 result = wxImage::RGBtoHSV(arg1);
16998 wxPyEndAllowThreads(__tstate);
16999 if (PyErr_Occurred()) SWIG_fail;
17000 }
17001 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17002 return resultobj;
17003 fail:
17004 return NULL;
17005 }
17006
17007
17008 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17009 PyObject *resultobj = 0;
17010 wxImage_HSVValue arg1 ;
17011 wxImage_RGBValue result;
17012 void *argp1 ;
17013 int res1 = 0 ;
17014 PyObject * obj0 = 0 ;
17015 char * kwnames[] = {
17016 (char *) "hsv", NULL
17017 };
17018
17019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17020 {
17021 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17022 if (!SWIG_IsOK(res1)) {
17023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17024 }
17025 if (!argp1) {
17026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17027 } else {
17028 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17029 arg1 = *temp;
17030 if (SWIG_IsNewObj(res1)) delete temp;
17031 }
17032 }
17033 {
17034 PyThreadState* __tstate = wxPyBeginAllowThreads();
17035 result = wxImage::HSVtoRGB(arg1);
17036 wxPyEndAllowThreads(__tstate);
17037 if (PyErr_Occurred()) SWIG_fail;
17038 }
17039 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17040 return resultobj;
17041 fail:
17042 return NULL;
17043 }
17044
17045
17046 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17047 PyObject *obj;
17048 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17049 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17050 return SWIG_Py_Void();
17051 }
17052
17053 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17054 return SWIG_Python_InitShadowInstance(args);
17055 }
17056
17057 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj = 0;
17059 int arg1 ;
17060 int arg2 ;
17061 buffer arg3 ;
17062 int arg4 ;
17063 buffer arg5 = (buffer) NULL ;
17064 int arg6 = (int) 0 ;
17065 wxImage *result = 0 ;
17066 int val1 ;
17067 int ecode1 = 0 ;
17068 int val2 ;
17069 int ecode2 = 0 ;
17070 Py_ssize_t temp3 ;
17071 Py_ssize_t temp5 ;
17072 PyObject * obj0 = 0 ;
17073 PyObject * obj1 = 0 ;
17074 PyObject * obj2 = 0 ;
17075 PyObject * obj3 = 0 ;
17076 char * kwnames[] = {
17077 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17078 };
17079
17080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17081 ecode1 = SWIG_AsVal_int(obj0, &val1);
17082 if (!SWIG_IsOK(ecode1)) {
17083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17084 }
17085 arg1 = static_cast< int >(val1);
17086 ecode2 = SWIG_AsVal_int(obj1, &val2);
17087 if (!SWIG_IsOK(ecode2)) {
17088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17089 }
17090 arg2 = static_cast< int >(val2);
17091 {
17092 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17093 arg4 = (int)temp3;
17094 }
17095 if (obj3) {
17096 {
17097 if (obj3 != Py_None) {
17098 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17099 arg6 = (int)temp5;
17100 }
17101 }
17102 }
17103 {
17104 PyThreadState* __tstate = wxPyBeginAllowThreads();
17105 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17106 wxPyEndAllowThreads(__tstate);
17107 if (PyErr_Occurred()) SWIG_fail;
17108 }
17109 {
17110 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17111 }
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 SWIGINTERN int NullImage_set(PyObject *) {
17119 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17120 return 1;
17121 }
17122
17123
17124 SWIGINTERN PyObject *NullImage_get(void) {
17125 PyObject *pyobj = 0;
17126
17127 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17128 return pyobj;
17129 }
17130
17131
17132 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17133 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17134 return 1;
17135 }
17136
17137
17138 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17139 PyObject *pyobj = 0;
17140
17141 {
17142 #if wxUSE_UNICODE
17143 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17144 #else
17145 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17146 #endif
17147 }
17148 return pyobj;
17149 }
17150
17151
17152 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17153 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17154 return 1;
17155 }
17156
17157
17158 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17159 PyObject *pyobj = 0;
17160
17161 {
17162 #if wxUSE_UNICODE
17163 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17164 #else
17165 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17166 #endif
17167 }
17168 return pyobj;
17169 }
17170
17171
17172 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17173 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17174 return 1;
17175 }
17176
17177
17178 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17179 PyObject *pyobj = 0;
17180
17181 {
17182 #if wxUSE_UNICODE
17183 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17184 #else
17185 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17186 #endif
17187 }
17188 return pyobj;
17189 }
17190
17191
17192 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17193 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17194 return 1;
17195 }
17196
17197
17198 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17199 PyObject *pyobj = 0;
17200
17201 {
17202 #if wxUSE_UNICODE
17203 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17204 #else
17205 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17206 #endif
17207 }
17208 return pyobj;
17209 }
17210
17211
17212 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17213 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17214 return 1;
17215 }
17216
17217
17218 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17219 PyObject *pyobj = 0;
17220
17221 {
17222 #if wxUSE_UNICODE
17223 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17224 #else
17225 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17226 #endif
17227 }
17228 return pyobj;
17229 }
17230
17231
17232 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17233 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17234 return 1;
17235 }
17236
17237
17238 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17239 PyObject *pyobj = 0;
17240
17241 {
17242 #if wxUSE_UNICODE
17243 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17244 #else
17245 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17246 #endif
17247 }
17248 return pyobj;
17249 }
17250
17251
17252 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17253 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17254 return 1;
17255 }
17256
17257
17258 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17259 PyObject *pyobj = 0;
17260
17261 {
17262 #if wxUSE_UNICODE
17263 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17264 #else
17265 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17266 #endif
17267 }
17268 return pyobj;
17269 }
17270
17271
17272 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17273 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17274 return 1;
17275 }
17276
17277
17278 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17279 PyObject *pyobj = 0;
17280
17281 {
17282 #if wxUSE_UNICODE
17283 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17284 #else
17285 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17286 #endif
17287 }
17288 return pyobj;
17289 }
17290
17291
17292 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17293 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17294 return 1;
17295 }
17296
17297
17298 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17299 PyObject *pyobj = 0;
17300
17301 {
17302 #if wxUSE_UNICODE
17303 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17304 #else
17305 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17306 #endif
17307 }
17308 return pyobj;
17309 }
17310
17311
17312 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17313 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17314 return 1;
17315 }
17316
17317
17318 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17319 PyObject *pyobj = 0;
17320
17321 {
17322 #if wxUSE_UNICODE
17323 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17324 #else
17325 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17326 #endif
17327 }
17328 return pyobj;
17329 }
17330
17331
17332 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17333 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17334 return 1;
17335 }
17336
17337
17338 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17339 PyObject *pyobj = 0;
17340
17341 {
17342 #if wxUSE_UNICODE
17343 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17344 #else
17345 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17346 #endif
17347 }
17348 return pyobj;
17349 }
17350
17351
17352 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17353 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17354 return 1;
17355 }
17356
17357
17358 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17359 PyObject *pyobj = 0;
17360
17361 {
17362 #if wxUSE_UNICODE
17363 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17364 #else
17365 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17366 #endif
17367 }
17368 return pyobj;
17369 }
17370
17371
17372 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17373 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17374 return 1;
17375 }
17376
17377
17378 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17379 PyObject *pyobj = 0;
17380
17381 {
17382 #if wxUSE_UNICODE
17383 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17384 #else
17385 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17386 #endif
17387 }
17388 return pyobj;
17389 }
17390
17391
17392 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17393 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17394 return 1;
17395 }
17396
17397
17398 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17399 PyObject *pyobj = 0;
17400
17401 {
17402 #if wxUSE_UNICODE
17403 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17404 #else
17405 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17406 #endif
17407 }
17408 return pyobj;
17409 }
17410
17411
17412 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17413 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17414 return 1;
17415 }
17416
17417
17418 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17419 PyObject *pyobj = 0;
17420
17421 {
17422 #if wxUSE_UNICODE
17423 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17424 #else
17425 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17426 #endif
17427 }
17428 return pyobj;
17429 }
17430
17431
17432 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17433 PyObject *resultobj = 0;
17434 wxBMPHandler *result = 0 ;
17435
17436 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17437 {
17438 PyThreadState* __tstate = wxPyBeginAllowThreads();
17439 result = (wxBMPHandler *)new wxBMPHandler();
17440 wxPyEndAllowThreads(__tstate);
17441 if (PyErr_Occurred()) SWIG_fail;
17442 }
17443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17444 return resultobj;
17445 fail:
17446 return NULL;
17447 }
17448
17449
17450 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17451 PyObject *obj;
17452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17453 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17454 return SWIG_Py_Void();
17455 }
17456
17457 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17458 return SWIG_Python_InitShadowInstance(args);
17459 }
17460
17461 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17462 PyObject *resultobj = 0;
17463 wxICOHandler *result = 0 ;
17464
17465 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17466 {
17467 PyThreadState* __tstate = wxPyBeginAllowThreads();
17468 result = (wxICOHandler *)new wxICOHandler();
17469 wxPyEndAllowThreads(__tstate);
17470 if (PyErr_Occurred()) SWIG_fail;
17471 }
17472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17473 return resultobj;
17474 fail:
17475 return NULL;
17476 }
17477
17478
17479 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17480 PyObject *obj;
17481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17482 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17483 return SWIG_Py_Void();
17484 }
17485
17486 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 return SWIG_Python_InitShadowInstance(args);
17488 }
17489
17490 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491 PyObject *resultobj = 0;
17492 wxCURHandler *result = 0 ;
17493
17494 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17495 {
17496 PyThreadState* __tstate = wxPyBeginAllowThreads();
17497 result = (wxCURHandler *)new wxCURHandler();
17498 wxPyEndAllowThreads(__tstate);
17499 if (PyErr_Occurred()) SWIG_fail;
17500 }
17501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17502 return resultobj;
17503 fail:
17504 return NULL;
17505 }
17506
17507
17508 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17509 PyObject *obj;
17510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17511 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17512 return SWIG_Py_Void();
17513 }
17514
17515 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17516 return SWIG_Python_InitShadowInstance(args);
17517 }
17518
17519 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17520 PyObject *resultobj = 0;
17521 wxANIHandler *result = 0 ;
17522
17523 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = (wxANIHandler *)new wxANIHandler();
17527 wxPyEndAllowThreads(__tstate);
17528 if (PyErr_Occurred()) SWIG_fail;
17529 }
17530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17538 PyObject *obj;
17539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17540 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17541 return SWIG_Py_Void();
17542 }
17543
17544 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17545 return SWIG_Python_InitShadowInstance(args);
17546 }
17547
17548 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17549 PyObject *resultobj = 0;
17550 wxPNGHandler *result = 0 ;
17551
17552 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (wxPNGHandler *)new wxPNGHandler();
17556 wxPyEndAllowThreads(__tstate);
17557 if (PyErr_Occurred()) SWIG_fail;
17558 }
17559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17560 return resultobj;
17561 fail:
17562 return NULL;
17563 }
17564
17565
17566 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17567 PyObject *obj;
17568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17569 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17570 return SWIG_Py_Void();
17571 }
17572
17573 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 return SWIG_Python_InitShadowInstance(args);
17575 }
17576
17577 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17578 PyObject *resultobj = 0;
17579 wxGIFHandler *result = 0 ;
17580
17581 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 result = (wxGIFHandler *)new wxGIFHandler();
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17589 return resultobj;
17590 fail:
17591 return NULL;
17592 }
17593
17594
17595 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17596 PyObject *obj;
17597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17598 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17599 return SWIG_Py_Void();
17600 }
17601
17602 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17603 return SWIG_Python_InitShadowInstance(args);
17604 }
17605
17606 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17607 PyObject *resultobj = 0;
17608 wxPCXHandler *result = 0 ;
17609
17610 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (wxPCXHandler *)new wxPCXHandler();
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17618 return resultobj;
17619 fail:
17620 return NULL;
17621 }
17622
17623
17624 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17625 PyObject *obj;
17626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17627 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17628 return SWIG_Py_Void();
17629 }
17630
17631 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17632 return SWIG_Python_InitShadowInstance(args);
17633 }
17634
17635 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17636 PyObject *resultobj = 0;
17637 wxJPEGHandler *result = 0 ;
17638
17639 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17640 {
17641 PyThreadState* __tstate = wxPyBeginAllowThreads();
17642 result = (wxJPEGHandler *)new wxJPEGHandler();
17643 wxPyEndAllowThreads(__tstate);
17644 if (PyErr_Occurred()) SWIG_fail;
17645 }
17646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17654 PyObject *obj;
17655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17656 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17657 return SWIG_Py_Void();
17658 }
17659
17660 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17661 return SWIG_Python_InitShadowInstance(args);
17662 }
17663
17664 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17665 PyObject *resultobj = 0;
17666 wxPNMHandler *result = 0 ;
17667
17668 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17669 {
17670 PyThreadState* __tstate = wxPyBeginAllowThreads();
17671 result = (wxPNMHandler *)new wxPNMHandler();
17672 wxPyEndAllowThreads(__tstate);
17673 if (PyErr_Occurred()) SWIG_fail;
17674 }
17675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17676 return resultobj;
17677 fail:
17678 return NULL;
17679 }
17680
17681
17682 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17683 PyObject *obj;
17684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17685 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17686 return SWIG_Py_Void();
17687 }
17688
17689 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 return SWIG_Python_InitShadowInstance(args);
17691 }
17692
17693 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17694 PyObject *resultobj = 0;
17695 wxXPMHandler *result = 0 ;
17696
17697 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 result = (wxXPMHandler *)new wxXPMHandler();
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17705 return resultobj;
17706 fail:
17707 return NULL;
17708 }
17709
17710
17711 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17712 PyObject *obj;
17713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17714 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17715 return SWIG_Py_Void();
17716 }
17717
17718 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17719 return SWIG_Python_InitShadowInstance(args);
17720 }
17721
17722 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17723 PyObject *resultobj = 0;
17724 wxTIFFHandler *result = 0 ;
17725
17726 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (wxTIFFHandler *)new wxTIFFHandler();
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17734 return resultobj;
17735 fail:
17736 return NULL;
17737 }
17738
17739
17740 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17741 PyObject *obj;
17742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17743 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17744 return SWIG_Py_Void();
17745 }
17746
17747 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17748 return SWIG_Python_InitShadowInstance(args);
17749 }
17750
17751 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj = 0;
17753 wxImage *arg1 = 0 ;
17754 wxImage *arg2 = 0 ;
17755 int arg3 = (int) 236 ;
17756 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17757 bool result;
17758 void *argp1 = 0 ;
17759 int res1 = 0 ;
17760 void *argp2 = 0 ;
17761 int res2 = 0 ;
17762 int val3 ;
17763 int ecode3 = 0 ;
17764 int val4 ;
17765 int ecode4 = 0 ;
17766 PyObject * obj0 = 0 ;
17767 PyObject * obj1 = 0 ;
17768 PyObject * obj2 = 0 ;
17769 PyObject * obj3 = 0 ;
17770 char * kwnames[] = {
17771 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17772 };
17773
17774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17775 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17776 if (!SWIG_IsOK(res1)) {
17777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17778 }
17779 if (!argp1) {
17780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17781 }
17782 arg1 = reinterpret_cast< wxImage * >(argp1);
17783 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17784 if (!SWIG_IsOK(res2)) {
17785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17786 }
17787 if (!argp2) {
17788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17789 }
17790 arg2 = reinterpret_cast< wxImage * >(argp2);
17791 if (obj2) {
17792 ecode3 = SWIG_AsVal_int(obj2, &val3);
17793 if (!SWIG_IsOK(ecode3)) {
17794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17795 }
17796 arg3 = static_cast< int >(val3);
17797 }
17798 if (obj3) {
17799 ecode4 = SWIG_AsVal_int(obj3, &val4);
17800 if (!SWIG_IsOK(ecode4)) {
17801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17802 }
17803 arg4 = static_cast< int >(val4);
17804 }
17805 {
17806 PyThreadState* __tstate = wxPyBeginAllowThreads();
17807 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17808 wxPyEndAllowThreads(__tstate);
17809 if (PyErr_Occurred()) SWIG_fail;
17810 }
17811 {
17812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17813 }
17814 return resultobj;
17815 fail:
17816 return NULL;
17817 }
17818
17819
17820 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17821 PyObject *obj;
17822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17823 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17824 return SWIG_Py_Void();
17825 }
17826
17827 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17828 PyObject *resultobj = 0;
17829 wxEvtHandler *result = 0 ;
17830
17831 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17832 {
17833 PyThreadState* __tstate = wxPyBeginAllowThreads();
17834 result = (wxEvtHandler *)new wxEvtHandler();
17835 wxPyEndAllowThreads(__tstate);
17836 if (PyErr_Occurred()) SWIG_fail;
17837 }
17838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17839 return resultobj;
17840 fail:
17841 return NULL;
17842 }
17843
17844
17845 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17846 PyObject *resultobj = 0;
17847 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17848 wxEvtHandler *result = 0 ;
17849 void *argp1 = 0 ;
17850 int res1 = 0 ;
17851 PyObject *swig_obj[1] ;
17852
17853 if (!args) SWIG_fail;
17854 swig_obj[0] = args;
17855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17856 if (!SWIG_IsOK(res1)) {
17857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17858 }
17859 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17860 {
17861 PyThreadState* __tstate = wxPyBeginAllowThreads();
17862 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17863 wxPyEndAllowThreads(__tstate);
17864 if (PyErr_Occurred()) SWIG_fail;
17865 }
17866 {
17867 resultobj = wxPyMake_wxObject(result, 0);
17868 }
17869 return resultobj;
17870 fail:
17871 return NULL;
17872 }
17873
17874
17875 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17876 PyObject *resultobj = 0;
17877 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17878 wxEvtHandler *result = 0 ;
17879 void *argp1 = 0 ;
17880 int res1 = 0 ;
17881 PyObject *swig_obj[1] ;
17882
17883 if (!args) SWIG_fail;
17884 swig_obj[0] = args;
17885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17886 if (!SWIG_IsOK(res1)) {
17887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17888 }
17889 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17890 {
17891 PyThreadState* __tstate = wxPyBeginAllowThreads();
17892 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 {
17897 resultobj = wxPyMake_wxObject(result, 0);
17898 }
17899 return resultobj;
17900 fail:
17901 return NULL;
17902 }
17903
17904
17905 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj = 0;
17907 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17908 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17909 void *argp1 = 0 ;
17910 int res1 = 0 ;
17911 void *argp2 = 0 ;
17912 int res2 = 0 ;
17913 PyObject * obj0 = 0 ;
17914 PyObject * obj1 = 0 ;
17915 char * kwnames[] = {
17916 (char *) "self",(char *) "handler", NULL
17917 };
17918
17919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17921 if (!SWIG_IsOK(res1)) {
17922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17923 }
17924 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17926 if (!SWIG_IsOK(res2)) {
17927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17928 }
17929 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 (arg1)->SetNextHandler(arg2);
17933 wxPyEndAllowThreads(__tstate);
17934 if (PyErr_Occurred()) SWIG_fail;
17935 }
17936 resultobj = SWIG_Py_Void();
17937 return resultobj;
17938 fail:
17939 return NULL;
17940 }
17941
17942
17943 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17944 PyObject *resultobj = 0;
17945 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17946 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17947 void *argp1 = 0 ;
17948 int res1 = 0 ;
17949 void *argp2 = 0 ;
17950 int res2 = 0 ;
17951 PyObject * obj0 = 0 ;
17952 PyObject * obj1 = 0 ;
17953 char * kwnames[] = {
17954 (char *) "self",(char *) "handler", NULL
17955 };
17956
17957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17959 if (!SWIG_IsOK(res1)) {
17960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17961 }
17962 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17963 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17964 if (!SWIG_IsOK(res2)) {
17965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17966 }
17967 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17968 {
17969 PyThreadState* __tstate = wxPyBeginAllowThreads();
17970 (arg1)->SetPreviousHandler(arg2);
17971 wxPyEndAllowThreads(__tstate);
17972 if (PyErr_Occurred()) SWIG_fail;
17973 }
17974 resultobj = SWIG_Py_Void();
17975 return resultobj;
17976 fail:
17977 return NULL;
17978 }
17979
17980
17981 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17982 PyObject *resultobj = 0;
17983 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17984 bool result;
17985 void *argp1 = 0 ;
17986 int res1 = 0 ;
17987 PyObject *swig_obj[1] ;
17988
17989 if (!args) SWIG_fail;
17990 swig_obj[0] = args;
17991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17992 if (!SWIG_IsOK(res1)) {
17993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17994 }
17995 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17996 {
17997 PyThreadState* __tstate = wxPyBeginAllowThreads();
17998 result = (bool)(arg1)->GetEvtHandlerEnabled();
17999 wxPyEndAllowThreads(__tstate);
18000 if (PyErr_Occurred()) SWIG_fail;
18001 }
18002 {
18003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18004 }
18005 return resultobj;
18006 fail:
18007 return NULL;
18008 }
18009
18010
18011 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18012 PyObject *resultobj = 0;
18013 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18014 bool arg2 ;
18015 void *argp1 = 0 ;
18016 int res1 = 0 ;
18017 bool val2 ;
18018 int ecode2 = 0 ;
18019 PyObject * obj0 = 0 ;
18020 PyObject * obj1 = 0 ;
18021 char * kwnames[] = {
18022 (char *) "self",(char *) "enabled", NULL
18023 };
18024
18025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18027 if (!SWIG_IsOK(res1)) {
18028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18029 }
18030 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18032 if (!SWIG_IsOK(ecode2)) {
18033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18034 }
18035 arg2 = static_cast< bool >(val2);
18036 {
18037 PyThreadState* __tstate = wxPyBeginAllowThreads();
18038 (arg1)->SetEvtHandlerEnabled(arg2);
18039 wxPyEndAllowThreads(__tstate);
18040 if (PyErr_Occurred()) SWIG_fail;
18041 }
18042 resultobj = SWIG_Py_Void();
18043 return resultobj;
18044 fail:
18045 return NULL;
18046 }
18047
18048
18049 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18050 PyObject *resultobj = 0;
18051 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18052 wxEvent *arg2 = 0 ;
18053 bool result;
18054 void *argp1 = 0 ;
18055 int res1 = 0 ;
18056 void *argp2 = 0 ;
18057 int res2 = 0 ;
18058 PyObject * obj0 = 0 ;
18059 PyObject * obj1 = 0 ;
18060 char * kwnames[] = {
18061 (char *) "self",(char *) "event", NULL
18062 };
18063
18064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18066 if (!SWIG_IsOK(res1)) {
18067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18068 }
18069 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18070 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18071 if (!SWIG_IsOK(res2)) {
18072 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18073 }
18074 if (!argp2) {
18075 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18076 }
18077 arg2 = reinterpret_cast< wxEvent * >(argp2);
18078 {
18079 PyThreadState* __tstate = wxPyBeginAllowThreads();
18080 result = (bool)(arg1)->ProcessEvent(*arg2);
18081 wxPyEndAllowThreads(__tstate);
18082 if (PyErr_Occurred()) SWIG_fail;
18083 }
18084 {
18085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18086 }
18087 return resultobj;
18088 fail:
18089 return NULL;
18090 }
18091
18092
18093 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18094 PyObject *resultobj = 0;
18095 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18096 wxEvent *arg2 = 0 ;
18097 void *argp1 = 0 ;
18098 int res1 = 0 ;
18099 void *argp2 = 0 ;
18100 int res2 = 0 ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 char * kwnames[] = {
18104 (char *) "self",(char *) "event", NULL
18105 };
18106
18107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18109 if (!SWIG_IsOK(res1)) {
18110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18111 }
18112 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18114 if (!SWIG_IsOK(res2)) {
18115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18116 }
18117 if (!argp2) {
18118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18119 }
18120 arg2 = reinterpret_cast< wxEvent * >(argp2);
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 (arg1)->AddPendingEvent(*arg2);
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 resultobj = SWIG_Py_Void();
18128 return resultobj;
18129 fail:
18130 return NULL;
18131 }
18132
18133
18134 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18135 PyObject *resultobj = 0;
18136 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18137 void *argp1 = 0 ;
18138 int res1 = 0 ;
18139 PyObject *swig_obj[1] ;
18140
18141 if (!args) SWIG_fail;
18142 swig_obj[0] = args;
18143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18144 if (!SWIG_IsOK(res1)) {
18145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18146 }
18147 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 (arg1)->ProcessPendingEvents();
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 resultobj = SWIG_Py_Void();
18155 return resultobj;
18156 fail:
18157 return NULL;
18158 }
18159
18160
18161 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18162 PyObject *resultobj = 0;
18163 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18164 int arg2 ;
18165 int arg3 ;
18166 int arg4 ;
18167 PyObject *arg5 = (PyObject *) 0 ;
18168 void *argp1 = 0 ;
18169 int res1 = 0 ;
18170 int val2 ;
18171 int ecode2 = 0 ;
18172 int val3 ;
18173 int ecode3 = 0 ;
18174 int val4 ;
18175 int ecode4 = 0 ;
18176 PyObject * obj0 = 0 ;
18177 PyObject * obj1 = 0 ;
18178 PyObject * obj2 = 0 ;
18179 PyObject * obj3 = 0 ;
18180 PyObject * obj4 = 0 ;
18181 char * kwnames[] = {
18182 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18183 };
18184
18185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18187 if (!SWIG_IsOK(res1)) {
18188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18189 }
18190 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18191 ecode2 = SWIG_AsVal_int(obj1, &val2);
18192 if (!SWIG_IsOK(ecode2)) {
18193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18194 }
18195 arg2 = static_cast< int >(val2);
18196 ecode3 = SWIG_AsVal_int(obj2, &val3);
18197 if (!SWIG_IsOK(ecode3)) {
18198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18199 }
18200 arg3 = static_cast< int >(val3);
18201 ecode4 = SWIG_AsVal_int(obj3, &val4);
18202 if (!SWIG_IsOK(ecode4)) {
18203 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18204 }
18205 arg4 = static_cast< int >(val4);
18206 arg5 = obj4;
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18210 wxPyEndAllowThreads(__tstate);
18211 if (PyErr_Occurred()) SWIG_fail;
18212 }
18213 resultobj = SWIG_Py_Void();
18214 return resultobj;
18215 fail:
18216 return NULL;
18217 }
18218
18219
18220 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18221 PyObject *resultobj = 0;
18222 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18223 int arg2 ;
18224 int arg3 = (int) -1 ;
18225 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18226 bool result;
18227 void *argp1 = 0 ;
18228 int res1 = 0 ;
18229 int val2 ;
18230 int ecode2 = 0 ;
18231 int val3 ;
18232 int ecode3 = 0 ;
18233 int val4 ;
18234 int ecode4 = 0 ;
18235 PyObject * obj0 = 0 ;
18236 PyObject * obj1 = 0 ;
18237 PyObject * obj2 = 0 ;
18238 PyObject * obj3 = 0 ;
18239 char * kwnames[] = {
18240 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18241 };
18242
18243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18249 ecode2 = SWIG_AsVal_int(obj1, &val2);
18250 if (!SWIG_IsOK(ecode2)) {
18251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18252 }
18253 arg2 = static_cast< int >(val2);
18254 if (obj2) {
18255 ecode3 = SWIG_AsVal_int(obj2, &val3);
18256 if (!SWIG_IsOK(ecode3)) {
18257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18258 }
18259 arg3 = static_cast< int >(val3);
18260 }
18261 if (obj3) {
18262 ecode4 = SWIG_AsVal_int(obj3, &val4);
18263 if (!SWIG_IsOK(ecode4)) {
18264 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18265 }
18266 arg4 = static_cast< wxEventType >(val4);
18267 }
18268 {
18269 PyThreadState* __tstate = wxPyBeginAllowThreads();
18270 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18271 wxPyEndAllowThreads(__tstate);
18272 if (PyErr_Occurred()) SWIG_fail;
18273 }
18274 {
18275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18276 }
18277 return resultobj;
18278 fail:
18279 return NULL;
18280 }
18281
18282
18283 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18284 PyObject *resultobj = 0;
18285 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18286 PyObject *arg2 = (PyObject *) 0 ;
18287 bool arg3 = (bool) true ;
18288 void *argp1 = 0 ;
18289 int res1 = 0 ;
18290 bool val3 ;
18291 int ecode3 = 0 ;
18292 PyObject * obj0 = 0 ;
18293 PyObject * obj1 = 0 ;
18294 PyObject * obj2 = 0 ;
18295 char * kwnames[] = {
18296 (char *) "self",(char *) "_self",(char *) "incref", NULL
18297 };
18298
18299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18301 if (!SWIG_IsOK(res1)) {
18302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18303 }
18304 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18305 arg2 = obj1;
18306 if (obj2) {
18307 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18308 if (!SWIG_IsOK(ecode3)) {
18309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18310 }
18311 arg3 = static_cast< bool >(val3);
18312 }
18313 {
18314 PyThreadState* __tstate = wxPyBeginAllowThreads();
18315 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18316 wxPyEndAllowThreads(__tstate);
18317 if (PyErr_Occurred()) SWIG_fail;
18318 }
18319 resultobj = SWIG_Py_Void();
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18327 PyObject *obj;
18328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18329 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18330 return SWIG_Py_Void();
18331 }
18332
18333 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18334 return SWIG_Python_InitShadowInstance(args);
18335 }
18336
18337 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18338 PyObject *resultobj = 0;
18339 wxEventType result;
18340
18341 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18342 {
18343 PyThreadState* __tstate = wxPyBeginAllowThreads();
18344 result = (wxEventType)wxNewEventType();
18345 wxPyEndAllowThreads(__tstate);
18346 if (PyErr_Occurred()) SWIG_fail;
18347 }
18348 resultobj = SWIG_From_int(static_cast< int >(result));
18349 return resultobj;
18350 fail:
18351 return NULL;
18352 }
18353
18354
18355 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18356 PyObject *resultobj = 0;
18357 wxEvent *arg1 = (wxEvent *) 0 ;
18358 void *argp1 = 0 ;
18359 int res1 = 0 ;
18360 PyObject *swig_obj[1] ;
18361
18362 if (!args) SWIG_fail;
18363 swig_obj[0] = args;
18364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18365 if (!SWIG_IsOK(res1)) {
18366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18367 }
18368 arg1 = reinterpret_cast< wxEvent * >(argp1);
18369 {
18370 PyThreadState* __tstate = wxPyBeginAllowThreads();
18371 delete arg1;
18372
18373 wxPyEndAllowThreads(__tstate);
18374 if (PyErr_Occurred()) SWIG_fail;
18375 }
18376 resultobj = SWIG_Py_Void();
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18384 PyObject *resultobj = 0;
18385 wxEvent *arg1 = (wxEvent *) 0 ;
18386 wxEventType arg2 ;
18387 void *argp1 = 0 ;
18388 int res1 = 0 ;
18389 int val2 ;
18390 int ecode2 = 0 ;
18391 PyObject * obj0 = 0 ;
18392 PyObject * obj1 = 0 ;
18393 char * kwnames[] = {
18394 (char *) "self",(char *) "typ", NULL
18395 };
18396
18397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18399 if (!SWIG_IsOK(res1)) {
18400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18401 }
18402 arg1 = reinterpret_cast< wxEvent * >(argp1);
18403 ecode2 = SWIG_AsVal_int(obj1, &val2);
18404 if (!SWIG_IsOK(ecode2)) {
18405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18406 }
18407 arg2 = static_cast< wxEventType >(val2);
18408 {
18409 PyThreadState* __tstate = wxPyBeginAllowThreads();
18410 (arg1)->SetEventType(arg2);
18411 wxPyEndAllowThreads(__tstate);
18412 if (PyErr_Occurred()) SWIG_fail;
18413 }
18414 resultobj = SWIG_Py_Void();
18415 return resultobj;
18416 fail:
18417 return NULL;
18418 }
18419
18420
18421 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18422 PyObject *resultobj = 0;
18423 wxEvent *arg1 = (wxEvent *) 0 ;
18424 wxEventType result;
18425 void *argp1 = 0 ;
18426 int res1 = 0 ;
18427 PyObject *swig_obj[1] ;
18428
18429 if (!args) SWIG_fail;
18430 swig_obj[0] = args;
18431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18432 if (!SWIG_IsOK(res1)) {
18433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18434 }
18435 arg1 = reinterpret_cast< wxEvent * >(argp1);
18436 {
18437 PyThreadState* __tstate = wxPyBeginAllowThreads();
18438 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18439 wxPyEndAllowThreads(__tstate);
18440 if (PyErr_Occurred()) SWIG_fail;
18441 }
18442 resultobj = SWIG_From_int(static_cast< int >(result));
18443 return resultobj;
18444 fail:
18445 return NULL;
18446 }
18447
18448
18449 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18450 PyObject *resultobj = 0;
18451 wxEvent *arg1 = (wxEvent *) 0 ;
18452 wxObject *result = 0 ;
18453 void *argp1 = 0 ;
18454 int res1 = 0 ;
18455 PyObject *swig_obj[1] ;
18456
18457 if (!args) SWIG_fail;
18458 swig_obj[0] = args;
18459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18460 if (!SWIG_IsOK(res1)) {
18461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18462 }
18463 arg1 = reinterpret_cast< wxEvent * >(argp1);
18464 {
18465 PyThreadState* __tstate = wxPyBeginAllowThreads();
18466 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18467 wxPyEndAllowThreads(__tstate);
18468 if (PyErr_Occurred()) SWIG_fail;
18469 }
18470 {
18471 resultobj = wxPyMake_wxObject(result, (bool)0);
18472 }
18473 return resultobj;
18474 fail:
18475 return NULL;
18476 }
18477
18478
18479 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18480 PyObject *resultobj = 0;
18481 wxEvent *arg1 = (wxEvent *) 0 ;
18482 wxObject *arg2 = (wxObject *) 0 ;
18483 void *argp1 = 0 ;
18484 int res1 = 0 ;
18485 void *argp2 = 0 ;
18486 int res2 = 0 ;
18487 PyObject * obj0 = 0 ;
18488 PyObject * obj1 = 0 ;
18489 char * kwnames[] = {
18490 (char *) "self",(char *) "obj", NULL
18491 };
18492
18493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18495 if (!SWIG_IsOK(res1)) {
18496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18497 }
18498 arg1 = reinterpret_cast< wxEvent * >(argp1);
18499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18500 if (!SWIG_IsOK(res2)) {
18501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18502 }
18503 arg2 = reinterpret_cast< wxObject * >(argp2);
18504 {
18505 PyThreadState* __tstate = wxPyBeginAllowThreads();
18506 (arg1)->SetEventObject(arg2);
18507 wxPyEndAllowThreads(__tstate);
18508 if (PyErr_Occurred()) SWIG_fail;
18509 }
18510 resultobj = SWIG_Py_Void();
18511 return resultobj;
18512 fail:
18513 return NULL;
18514 }
18515
18516
18517 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18518 PyObject *resultobj = 0;
18519 wxEvent *arg1 = (wxEvent *) 0 ;
18520 long result;
18521 void *argp1 = 0 ;
18522 int res1 = 0 ;
18523 PyObject *swig_obj[1] ;
18524
18525 if (!args) SWIG_fail;
18526 swig_obj[0] = args;
18527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18528 if (!SWIG_IsOK(res1)) {
18529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18530 }
18531 arg1 = reinterpret_cast< wxEvent * >(argp1);
18532 {
18533 PyThreadState* __tstate = wxPyBeginAllowThreads();
18534 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18535 wxPyEndAllowThreads(__tstate);
18536 if (PyErr_Occurred()) SWIG_fail;
18537 }
18538 resultobj = SWIG_From_long(static_cast< long >(result));
18539 return resultobj;
18540 fail:
18541 return NULL;
18542 }
18543
18544
18545 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18546 PyObject *resultobj = 0;
18547 wxEvent *arg1 = (wxEvent *) 0 ;
18548 long arg2 = (long) 0 ;
18549 void *argp1 = 0 ;
18550 int res1 = 0 ;
18551 long val2 ;
18552 int ecode2 = 0 ;
18553 PyObject * obj0 = 0 ;
18554 PyObject * obj1 = 0 ;
18555 char * kwnames[] = {
18556 (char *) "self",(char *) "ts", NULL
18557 };
18558
18559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18561 if (!SWIG_IsOK(res1)) {
18562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18563 }
18564 arg1 = reinterpret_cast< wxEvent * >(argp1);
18565 if (obj1) {
18566 ecode2 = SWIG_AsVal_long(obj1, &val2);
18567 if (!SWIG_IsOK(ecode2)) {
18568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18569 }
18570 arg2 = static_cast< long >(val2);
18571 }
18572 {
18573 PyThreadState* __tstate = wxPyBeginAllowThreads();
18574 (arg1)->SetTimestamp(arg2);
18575 wxPyEndAllowThreads(__tstate);
18576 if (PyErr_Occurred()) SWIG_fail;
18577 }
18578 resultobj = SWIG_Py_Void();
18579 return resultobj;
18580 fail:
18581 return NULL;
18582 }
18583
18584
18585 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18586 PyObject *resultobj = 0;
18587 wxEvent *arg1 = (wxEvent *) 0 ;
18588 int result;
18589 void *argp1 = 0 ;
18590 int res1 = 0 ;
18591 PyObject *swig_obj[1] ;
18592
18593 if (!args) SWIG_fail;
18594 swig_obj[0] = args;
18595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18596 if (!SWIG_IsOK(res1)) {
18597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18598 }
18599 arg1 = reinterpret_cast< wxEvent * >(argp1);
18600 {
18601 PyThreadState* __tstate = wxPyBeginAllowThreads();
18602 result = (int)((wxEvent const *)arg1)->GetId();
18603 wxPyEndAllowThreads(__tstate);
18604 if (PyErr_Occurred()) SWIG_fail;
18605 }
18606 resultobj = SWIG_From_int(static_cast< int >(result));
18607 return resultobj;
18608 fail:
18609 return NULL;
18610 }
18611
18612
18613 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18614 PyObject *resultobj = 0;
18615 wxEvent *arg1 = (wxEvent *) 0 ;
18616 int arg2 ;
18617 void *argp1 = 0 ;
18618 int res1 = 0 ;
18619 int val2 ;
18620 int ecode2 = 0 ;
18621 PyObject * obj0 = 0 ;
18622 PyObject * obj1 = 0 ;
18623 char * kwnames[] = {
18624 (char *) "self",(char *) "Id", NULL
18625 };
18626
18627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18629 if (!SWIG_IsOK(res1)) {
18630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18631 }
18632 arg1 = reinterpret_cast< wxEvent * >(argp1);
18633 ecode2 = SWIG_AsVal_int(obj1, &val2);
18634 if (!SWIG_IsOK(ecode2)) {
18635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18636 }
18637 arg2 = static_cast< int >(val2);
18638 {
18639 PyThreadState* __tstate = wxPyBeginAllowThreads();
18640 (arg1)->SetId(arg2);
18641 wxPyEndAllowThreads(__tstate);
18642 if (PyErr_Occurred()) SWIG_fail;
18643 }
18644 resultobj = SWIG_Py_Void();
18645 return resultobj;
18646 fail:
18647 return NULL;
18648 }
18649
18650
18651 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18652 PyObject *resultobj = 0;
18653 wxEvent *arg1 = (wxEvent *) 0 ;
18654 bool result;
18655 void *argp1 = 0 ;
18656 int res1 = 0 ;
18657 PyObject *swig_obj[1] ;
18658
18659 if (!args) SWIG_fail;
18660 swig_obj[0] = args;
18661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18662 if (!SWIG_IsOK(res1)) {
18663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18664 }
18665 arg1 = reinterpret_cast< wxEvent * >(argp1);
18666 {
18667 PyThreadState* __tstate = wxPyBeginAllowThreads();
18668 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18669 wxPyEndAllowThreads(__tstate);
18670 if (PyErr_Occurred()) SWIG_fail;
18671 }
18672 {
18673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18674 }
18675 return resultobj;
18676 fail:
18677 return NULL;
18678 }
18679
18680
18681 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18682 PyObject *resultobj = 0;
18683 wxEvent *arg1 = (wxEvent *) 0 ;
18684 bool arg2 = (bool) true ;
18685 void *argp1 = 0 ;
18686 int res1 = 0 ;
18687 bool val2 ;
18688 int ecode2 = 0 ;
18689 PyObject * obj0 = 0 ;
18690 PyObject * obj1 = 0 ;
18691 char * kwnames[] = {
18692 (char *) "self",(char *) "skip", NULL
18693 };
18694
18695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18697 if (!SWIG_IsOK(res1)) {
18698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18699 }
18700 arg1 = reinterpret_cast< wxEvent * >(argp1);
18701 if (obj1) {
18702 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18703 if (!SWIG_IsOK(ecode2)) {
18704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18705 }
18706 arg2 = static_cast< bool >(val2);
18707 }
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 (arg1)->Skip(arg2);
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 resultobj = SWIG_Py_Void();
18715 return resultobj;
18716 fail:
18717 return NULL;
18718 }
18719
18720
18721 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18722 PyObject *resultobj = 0;
18723 wxEvent *arg1 = (wxEvent *) 0 ;
18724 bool result;
18725 void *argp1 = 0 ;
18726 int res1 = 0 ;
18727 PyObject *swig_obj[1] ;
18728
18729 if (!args) SWIG_fail;
18730 swig_obj[0] = args;
18731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18732 if (!SWIG_IsOK(res1)) {
18733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18734 }
18735 arg1 = reinterpret_cast< wxEvent * >(argp1);
18736 {
18737 PyThreadState* __tstate = wxPyBeginAllowThreads();
18738 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 {
18743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18744 }
18745 return resultobj;
18746 fail:
18747 return NULL;
18748 }
18749
18750
18751 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18752 PyObject *resultobj = 0;
18753 wxEvent *arg1 = (wxEvent *) 0 ;
18754 bool 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_wxEvent, 0 | 0 );
18762 if (!SWIG_IsOK(res1)) {
18763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18764 }
18765 arg1 = reinterpret_cast< wxEvent * >(argp1);
18766 {
18767 PyThreadState* __tstate = wxPyBeginAllowThreads();
18768 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18769 wxPyEndAllowThreads(__tstate);
18770 if (PyErr_Occurred()) SWIG_fail;
18771 }
18772 {
18773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18774 }
18775 return resultobj;
18776 fail:
18777 return NULL;
18778 }
18779
18780
18781 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18782 PyObject *resultobj = 0;
18783 wxEvent *arg1 = (wxEvent *) 0 ;
18784 int result;
18785 void *argp1 = 0 ;
18786 int res1 = 0 ;
18787 PyObject *swig_obj[1] ;
18788
18789 if (!args) SWIG_fail;
18790 swig_obj[0] = args;
18791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18792 if (!SWIG_IsOK(res1)) {
18793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18794 }
18795 arg1 = reinterpret_cast< wxEvent * >(argp1);
18796 {
18797 PyThreadState* __tstate = wxPyBeginAllowThreads();
18798 result = (int)(arg1)->StopPropagation();
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 resultobj = SWIG_From_int(static_cast< int >(result));
18803 return resultobj;
18804 fail:
18805 return NULL;
18806 }
18807
18808
18809 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18810 PyObject *resultobj = 0;
18811 wxEvent *arg1 = (wxEvent *) 0 ;
18812 int arg2 ;
18813 void *argp1 = 0 ;
18814 int res1 = 0 ;
18815 int val2 ;
18816 int ecode2 = 0 ;
18817 PyObject * obj0 = 0 ;
18818 PyObject * obj1 = 0 ;
18819 char * kwnames[] = {
18820 (char *) "self",(char *) "propagationLevel", NULL
18821 };
18822
18823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18825 if (!SWIG_IsOK(res1)) {
18826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18827 }
18828 arg1 = reinterpret_cast< wxEvent * >(argp1);
18829 ecode2 = SWIG_AsVal_int(obj1, &val2);
18830 if (!SWIG_IsOK(ecode2)) {
18831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18832 }
18833 arg2 = static_cast< int >(val2);
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 (arg1)->ResumePropagation(arg2);
18837 wxPyEndAllowThreads(__tstate);
18838 if (PyErr_Occurred()) SWIG_fail;
18839 }
18840 resultobj = SWIG_Py_Void();
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18848 PyObject *resultobj = 0;
18849 wxEvent *arg1 = (wxEvent *) 0 ;
18850 wxEvent *result = 0 ;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 PyObject *swig_obj[1] ;
18854
18855 if (!args) SWIG_fail;
18856 swig_obj[0] = args;
18857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18858 if (!SWIG_IsOK(res1)) {
18859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18860 }
18861 arg1 = reinterpret_cast< wxEvent * >(argp1);
18862 {
18863 PyThreadState* __tstate = wxPyBeginAllowThreads();
18864 result = (wxEvent *)(arg1)->Clone();
18865 wxPyEndAllowThreads(__tstate);
18866 if (PyErr_Occurred()) SWIG_fail;
18867 }
18868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18869 return resultobj;
18870 fail:
18871 return NULL;
18872 }
18873
18874
18875 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18876 PyObject *obj;
18877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18878 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18879 return SWIG_Py_Void();
18880 }
18881
18882 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18883 PyObject *resultobj = 0;
18884 wxEvent *arg1 = 0 ;
18885 wxPropagationDisabler *result = 0 ;
18886 void *argp1 = 0 ;
18887 int res1 = 0 ;
18888 PyObject * obj0 = 0 ;
18889 char * kwnames[] = {
18890 (char *) "event", NULL
18891 };
18892
18893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18894 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18895 if (!SWIG_IsOK(res1)) {
18896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18897 }
18898 if (!argp1) {
18899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18900 }
18901 arg1 = reinterpret_cast< wxEvent * >(argp1);
18902 {
18903 PyThreadState* __tstate = wxPyBeginAllowThreads();
18904 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18905 wxPyEndAllowThreads(__tstate);
18906 if (PyErr_Occurred()) SWIG_fail;
18907 }
18908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18909 return resultobj;
18910 fail:
18911 return NULL;
18912 }
18913
18914
18915 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18916 PyObject *resultobj = 0;
18917 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18918 void *argp1 = 0 ;
18919 int res1 = 0 ;
18920 PyObject *swig_obj[1] ;
18921
18922 if (!args) SWIG_fail;
18923 swig_obj[0] = args;
18924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18925 if (!SWIG_IsOK(res1)) {
18926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18927 }
18928 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18929 {
18930 PyThreadState* __tstate = wxPyBeginAllowThreads();
18931 delete arg1;
18932
18933 wxPyEndAllowThreads(__tstate);
18934 if (PyErr_Occurred()) SWIG_fail;
18935 }
18936 resultobj = SWIG_Py_Void();
18937 return resultobj;
18938 fail:
18939 return NULL;
18940 }
18941
18942
18943 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18944 PyObject *obj;
18945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18946 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18947 return SWIG_Py_Void();
18948 }
18949
18950 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18951 return SWIG_Python_InitShadowInstance(args);
18952 }
18953
18954 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18955 PyObject *resultobj = 0;
18956 wxEvent *arg1 = 0 ;
18957 wxPropagateOnce *result = 0 ;
18958 void *argp1 = 0 ;
18959 int res1 = 0 ;
18960 PyObject * obj0 = 0 ;
18961 char * kwnames[] = {
18962 (char *) "event", NULL
18963 };
18964
18965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18966 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18967 if (!SWIG_IsOK(res1)) {
18968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18969 }
18970 if (!argp1) {
18971 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18972 }
18973 arg1 = reinterpret_cast< wxEvent * >(argp1);
18974 {
18975 PyThreadState* __tstate = wxPyBeginAllowThreads();
18976 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18977 wxPyEndAllowThreads(__tstate);
18978 if (PyErr_Occurred()) SWIG_fail;
18979 }
18980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18981 return resultobj;
18982 fail:
18983 return NULL;
18984 }
18985
18986
18987 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18988 PyObject *resultobj = 0;
18989 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18990 void *argp1 = 0 ;
18991 int res1 = 0 ;
18992 PyObject *swig_obj[1] ;
18993
18994 if (!args) SWIG_fail;
18995 swig_obj[0] = args;
18996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18997 if (!SWIG_IsOK(res1)) {
18998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18999 }
19000 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19001 {
19002 PyThreadState* __tstate = wxPyBeginAllowThreads();
19003 delete arg1;
19004
19005 wxPyEndAllowThreads(__tstate);
19006 if (PyErr_Occurred()) SWIG_fail;
19007 }
19008 resultobj = SWIG_Py_Void();
19009 return resultobj;
19010 fail:
19011 return NULL;
19012 }
19013
19014
19015 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19016 PyObject *obj;
19017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19018 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19019 return SWIG_Py_Void();
19020 }
19021
19022 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19023 return SWIG_Python_InitShadowInstance(args);
19024 }
19025
19026 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19027 PyObject *resultobj = 0;
19028 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19029 int arg2 = (int) 0 ;
19030 wxCommandEvent *result = 0 ;
19031 int val1 ;
19032 int ecode1 = 0 ;
19033 int val2 ;
19034 int ecode2 = 0 ;
19035 PyObject * obj0 = 0 ;
19036 PyObject * obj1 = 0 ;
19037 char * kwnames[] = {
19038 (char *) "commandType",(char *) "winid", NULL
19039 };
19040
19041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19042 if (obj0) {
19043 ecode1 = SWIG_AsVal_int(obj0, &val1);
19044 if (!SWIG_IsOK(ecode1)) {
19045 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19046 }
19047 arg1 = static_cast< wxEventType >(val1);
19048 }
19049 if (obj1) {
19050 ecode2 = SWIG_AsVal_int(obj1, &val2);
19051 if (!SWIG_IsOK(ecode2)) {
19052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19053 }
19054 arg2 = static_cast< int >(val2);
19055 }
19056 {
19057 PyThreadState* __tstate = wxPyBeginAllowThreads();
19058 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19059 wxPyEndAllowThreads(__tstate);
19060 if (PyErr_Occurred()) SWIG_fail;
19061 }
19062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19063 return resultobj;
19064 fail:
19065 return NULL;
19066 }
19067
19068
19069 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19070 PyObject *resultobj = 0;
19071 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19072 int result;
19073 void *argp1 = 0 ;
19074 int res1 = 0 ;
19075 PyObject *swig_obj[1] ;
19076
19077 if (!args) SWIG_fail;
19078 swig_obj[0] = args;
19079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19080 if (!SWIG_IsOK(res1)) {
19081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19082 }
19083 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19084 {
19085 PyThreadState* __tstate = wxPyBeginAllowThreads();
19086 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19087 wxPyEndAllowThreads(__tstate);
19088 if (PyErr_Occurred()) SWIG_fail;
19089 }
19090 resultobj = SWIG_From_int(static_cast< int >(result));
19091 return resultobj;
19092 fail:
19093 return NULL;
19094 }
19095
19096
19097 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19098 PyObject *resultobj = 0;
19099 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19100 wxString *arg2 = 0 ;
19101 void *argp1 = 0 ;
19102 int res1 = 0 ;
19103 bool temp2 = false ;
19104 PyObject * obj0 = 0 ;
19105 PyObject * obj1 = 0 ;
19106 char * kwnames[] = {
19107 (char *) "self",(char *) "s", NULL
19108 };
19109
19110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19112 if (!SWIG_IsOK(res1)) {
19113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19114 }
19115 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19116 {
19117 arg2 = wxString_in_helper(obj1);
19118 if (arg2 == NULL) SWIG_fail;
19119 temp2 = true;
19120 }
19121 {
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 (arg1)->SetString((wxString const &)*arg2);
19124 wxPyEndAllowThreads(__tstate);
19125 if (PyErr_Occurred()) SWIG_fail;
19126 }
19127 resultobj = SWIG_Py_Void();
19128 {
19129 if (temp2)
19130 delete arg2;
19131 }
19132 return resultobj;
19133 fail:
19134 {
19135 if (temp2)
19136 delete arg2;
19137 }
19138 return NULL;
19139 }
19140
19141
19142 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19143 PyObject *resultobj = 0;
19144 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19145 wxString result;
19146 void *argp1 = 0 ;
19147 int res1 = 0 ;
19148 PyObject *swig_obj[1] ;
19149
19150 if (!args) SWIG_fail;
19151 swig_obj[0] = args;
19152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19153 if (!SWIG_IsOK(res1)) {
19154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19155 }
19156 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19157 {
19158 PyThreadState* __tstate = wxPyBeginAllowThreads();
19159 result = ((wxCommandEvent const *)arg1)->GetString();
19160 wxPyEndAllowThreads(__tstate);
19161 if (PyErr_Occurred()) SWIG_fail;
19162 }
19163 {
19164 #if wxUSE_UNICODE
19165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19166 #else
19167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19168 #endif
19169 }
19170 return resultobj;
19171 fail:
19172 return NULL;
19173 }
19174
19175
19176 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19177 PyObject *resultobj = 0;
19178 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19179 bool result;
19180 void *argp1 = 0 ;
19181 int res1 = 0 ;
19182 PyObject *swig_obj[1] ;
19183
19184 if (!args) SWIG_fail;
19185 swig_obj[0] = args;
19186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19187 if (!SWIG_IsOK(res1)) {
19188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19189 }
19190 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19191 {
19192 PyThreadState* __tstate = wxPyBeginAllowThreads();
19193 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 {
19198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19199 }
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19207 PyObject *resultobj = 0;
19208 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19209 bool result;
19210 void *argp1 = 0 ;
19211 int res1 = 0 ;
19212 PyObject *swig_obj[1] ;
19213
19214 if (!args) SWIG_fail;
19215 swig_obj[0] = args;
19216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19217 if (!SWIG_IsOK(res1)) {
19218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19219 }
19220 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19221 {
19222 PyThreadState* __tstate = wxPyBeginAllowThreads();
19223 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19224 wxPyEndAllowThreads(__tstate);
19225 if (PyErr_Occurred()) SWIG_fail;
19226 }
19227 {
19228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19229 }
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19237 PyObject *resultobj = 0;
19238 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19239 long arg2 ;
19240 void *argp1 = 0 ;
19241 int res1 = 0 ;
19242 long val2 ;
19243 int ecode2 = 0 ;
19244 PyObject * obj0 = 0 ;
19245 PyObject * obj1 = 0 ;
19246 char * kwnames[] = {
19247 (char *) "self",(char *) "extraLong", NULL
19248 };
19249
19250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19252 if (!SWIG_IsOK(res1)) {
19253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19254 }
19255 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19256 ecode2 = SWIG_AsVal_long(obj1, &val2);
19257 if (!SWIG_IsOK(ecode2)) {
19258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19259 }
19260 arg2 = static_cast< long >(val2);
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 (arg1)->SetExtraLong(arg2);
19264 wxPyEndAllowThreads(__tstate);
19265 if (PyErr_Occurred()) SWIG_fail;
19266 }
19267 resultobj = SWIG_Py_Void();
19268 return resultobj;
19269 fail:
19270 return NULL;
19271 }
19272
19273
19274 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19275 PyObject *resultobj = 0;
19276 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19277 long result;
19278 void *argp1 = 0 ;
19279 int res1 = 0 ;
19280 PyObject *swig_obj[1] ;
19281
19282 if (!args) SWIG_fail;
19283 swig_obj[0] = args;
19284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19285 if (!SWIG_IsOK(res1)) {
19286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19287 }
19288 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19289 {
19290 PyThreadState* __tstate = wxPyBeginAllowThreads();
19291 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19292 wxPyEndAllowThreads(__tstate);
19293 if (PyErr_Occurred()) SWIG_fail;
19294 }
19295 resultobj = SWIG_From_long(static_cast< long >(result));
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj = 0;
19304 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19305 int arg2 ;
19306 void *argp1 = 0 ;
19307 int res1 = 0 ;
19308 int val2 ;
19309 int ecode2 = 0 ;
19310 PyObject * obj0 = 0 ;
19311 PyObject * obj1 = 0 ;
19312 char * kwnames[] = {
19313 (char *) "self",(char *) "i", NULL
19314 };
19315
19316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19318 if (!SWIG_IsOK(res1)) {
19319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19320 }
19321 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19322 ecode2 = SWIG_AsVal_int(obj1, &val2);
19323 if (!SWIG_IsOK(ecode2)) {
19324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19325 }
19326 arg2 = static_cast< int >(val2);
19327 {
19328 PyThreadState* __tstate = wxPyBeginAllowThreads();
19329 (arg1)->SetInt(arg2);
19330 wxPyEndAllowThreads(__tstate);
19331 if (PyErr_Occurred()) SWIG_fail;
19332 }
19333 resultobj = SWIG_Py_Void();
19334 return resultobj;
19335 fail:
19336 return NULL;
19337 }
19338
19339
19340 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19341 PyObject *resultobj = 0;
19342 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19343 int result;
19344 void *argp1 = 0 ;
19345 int res1 = 0 ;
19346 PyObject *swig_obj[1] ;
19347
19348 if (!args) SWIG_fail;
19349 swig_obj[0] = args;
19350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19351 if (!SWIG_IsOK(res1)) {
19352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19353 }
19354 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19355 {
19356 PyThreadState* __tstate = wxPyBeginAllowThreads();
19357 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 resultobj = SWIG_From_int(static_cast< int >(result));
19362 return resultobj;
19363 fail:
19364 return NULL;
19365 }
19366
19367
19368 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19369 PyObject *resultobj = 0;
19370 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19371 PyObject *result = 0 ;
19372 void *argp1 = 0 ;
19373 int res1 = 0 ;
19374 PyObject *swig_obj[1] ;
19375
19376 if (!args) SWIG_fail;
19377 swig_obj[0] = args;
19378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19379 if (!SWIG_IsOK(res1)) {
19380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19381 }
19382 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19383 {
19384 PyThreadState* __tstate = wxPyBeginAllowThreads();
19385 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19386 wxPyEndAllowThreads(__tstate);
19387 if (PyErr_Occurred()) SWIG_fail;
19388 }
19389 resultobj = result;
19390 return resultobj;
19391 fail:
19392 return NULL;
19393 }
19394
19395
19396 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19397 PyObject *resultobj = 0;
19398 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19399 PyObject *arg2 = (PyObject *) 0 ;
19400 void *argp1 = 0 ;
19401 int res1 = 0 ;
19402 PyObject * obj0 = 0 ;
19403 PyObject * obj1 = 0 ;
19404 char * kwnames[] = {
19405 (char *) "self",(char *) "clientData", NULL
19406 };
19407
19408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19410 if (!SWIG_IsOK(res1)) {
19411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19412 }
19413 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19414 arg2 = obj1;
19415 {
19416 PyThreadState* __tstate = wxPyBeginAllowThreads();
19417 wxCommandEvent_SetClientData(arg1,arg2);
19418 wxPyEndAllowThreads(__tstate);
19419 if (PyErr_Occurred()) SWIG_fail;
19420 }
19421 resultobj = SWIG_Py_Void();
19422 return resultobj;
19423 fail:
19424 return NULL;
19425 }
19426
19427
19428 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19429 PyObject *resultobj = 0;
19430 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19431 wxEvent *result = 0 ;
19432 void *argp1 = 0 ;
19433 int res1 = 0 ;
19434 PyObject *swig_obj[1] ;
19435
19436 if (!args) SWIG_fail;
19437 swig_obj[0] = args;
19438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19439 if (!SWIG_IsOK(res1)) {
19440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19441 }
19442 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19446 wxPyEndAllowThreads(__tstate);
19447 if (PyErr_Occurred()) SWIG_fail;
19448 }
19449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19457 PyObject *obj;
19458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19459 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19460 return SWIG_Py_Void();
19461 }
19462
19463 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19464 return SWIG_Python_InitShadowInstance(args);
19465 }
19466
19467 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj = 0;
19469 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19470 int arg2 = (int) 0 ;
19471 wxNotifyEvent *result = 0 ;
19472 int val1 ;
19473 int ecode1 = 0 ;
19474 int val2 ;
19475 int ecode2 = 0 ;
19476 PyObject * obj0 = 0 ;
19477 PyObject * obj1 = 0 ;
19478 char * kwnames[] = {
19479 (char *) "commandType",(char *) "winid", NULL
19480 };
19481
19482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19483 if (obj0) {
19484 ecode1 = SWIG_AsVal_int(obj0, &val1);
19485 if (!SWIG_IsOK(ecode1)) {
19486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19487 }
19488 arg1 = static_cast< wxEventType >(val1);
19489 }
19490 if (obj1) {
19491 ecode2 = SWIG_AsVal_int(obj1, &val2);
19492 if (!SWIG_IsOK(ecode2)) {
19493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19494 }
19495 arg2 = static_cast< int >(val2);
19496 }
19497 {
19498 PyThreadState* __tstate = wxPyBeginAllowThreads();
19499 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19500 wxPyEndAllowThreads(__tstate);
19501 if (PyErr_Occurred()) SWIG_fail;
19502 }
19503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19504 return resultobj;
19505 fail:
19506 return NULL;
19507 }
19508
19509
19510 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19511 PyObject *resultobj = 0;
19512 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19513 void *argp1 = 0 ;
19514 int res1 = 0 ;
19515 PyObject *swig_obj[1] ;
19516
19517 if (!args) SWIG_fail;
19518 swig_obj[0] = args;
19519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19520 if (!SWIG_IsOK(res1)) {
19521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19522 }
19523 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19524 {
19525 PyThreadState* __tstate = wxPyBeginAllowThreads();
19526 (arg1)->Veto();
19527 wxPyEndAllowThreads(__tstate);
19528 if (PyErr_Occurred()) SWIG_fail;
19529 }
19530 resultobj = SWIG_Py_Void();
19531 return resultobj;
19532 fail:
19533 return NULL;
19534 }
19535
19536
19537 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19538 PyObject *resultobj = 0;
19539 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19540 void *argp1 = 0 ;
19541 int res1 = 0 ;
19542 PyObject *swig_obj[1] ;
19543
19544 if (!args) SWIG_fail;
19545 swig_obj[0] = args;
19546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19547 if (!SWIG_IsOK(res1)) {
19548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19549 }
19550 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19551 {
19552 PyThreadState* __tstate = wxPyBeginAllowThreads();
19553 (arg1)->Allow();
19554 wxPyEndAllowThreads(__tstate);
19555 if (PyErr_Occurred()) SWIG_fail;
19556 }
19557 resultobj = SWIG_Py_Void();
19558 return resultobj;
19559 fail:
19560 return NULL;
19561 }
19562
19563
19564 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19565 PyObject *resultobj = 0;
19566 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19567 bool result;
19568 void *argp1 = 0 ;
19569 int res1 = 0 ;
19570 PyObject *swig_obj[1] ;
19571
19572 if (!args) SWIG_fail;
19573 swig_obj[0] = args;
19574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19575 if (!SWIG_IsOK(res1)) {
19576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19577 }
19578 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19579 {
19580 PyThreadState* __tstate = wxPyBeginAllowThreads();
19581 result = (bool)(arg1)->IsAllowed();
19582 wxPyEndAllowThreads(__tstate);
19583 if (PyErr_Occurred()) SWIG_fail;
19584 }
19585 {
19586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19587 }
19588 return resultobj;
19589 fail:
19590 return NULL;
19591 }
19592
19593
19594 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19595 PyObject *obj;
19596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19597 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19598 return SWIG_Py_Void();
19599 }
19600
19601 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19602 return SWIG_Python_InitShadowInstance(args);
19603 }
19604
19605 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19606 PyObject *resultobj = 0;
19607 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19608 int arg2 = (int) 0 ;
19609 int arg3 = (int) 0 ;
19610 int arg4 = (int) 0 ;
19611 wxScrollEvent *result = 0 ;
19612 int val1 ;
19613 int ecode1 = 0 ;
19614 int val2 ;
19615 int ecode2 = 0 ;
19616 int val3 ;
19617 int ecode3 = 0 ;
19618 int val4 ;
19619 int ecode4 = 0 ;
19620 PyObject * obj0 = 0 ;
19621 PyObject * obj1 = 0 ;
19622 PyObject * obj2 = 0 ;
19623 PyObject * obj3 = 0 ;
19624 char * kwnames[] = {
19625 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19626 };
19627
19628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19629 if (obj0) {
19630 ecode1 = SWIG_AsVal_int(obj0, &val1);
19631 if (!SWIG_IsOK(ecode1)) {
19632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19633 }
19634 arg1 = static_cast< wxEventType >(val1);
19635 }
19636 if (obj1) {
19637 ecode2 = SWIG_AsVal_int(obj1, &val2);
19638 if (!SWIG_IsOK(ecode2)) {
19639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19640 }
19641 arg2 = static_cast< int >(val2);
19642 }
19643 if (obj2) {
19644 ecode3 = SWIG_AsVal_int(obj2, &val3);
19645 if (!SWIG_IsOK(ecode3)) {
19646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19647 }
19648 arg3 = static_cast< int >(val3);
19649 }
19650 if (obj3) {
19651 ecode4 = SWIG_AsVal_int(obj3, &val4);
19652 if (!SWIG_IsOK(ecode4)) {
19653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19654 }
19655 arg4 = static_cast< int >(val4);
19656 }
19657 {
19658 PyThreadState* __tstate = wxPyBeginAllowThreads();
19659 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19660 wxPyEndAllowThreads(__tstate);
19661 if (PyErr_Occurred()) SWIG_fail;
19662 }
19663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19664 return resultobj;
19665 fail:
19666 return NULL;
19667 }
19668
19669
19670 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19671 PyObject *resultobj = 0;
19672 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19673 int result;
19674 void *argp1 = 0 ;
19675 int res1 = 0 ;
19676 PyObject *swig_obj[1] ;
19677
19678 if (!args) SWIG_fail;
19679 swig_obj[0] = args;
19680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19681 if (!SWIG_IsOK(res1)) {
19682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19683 }
19684 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 resultobj = SWIG_From_int(static_cast< int >(result));
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19699 PyObject *resultobj = 0;
19700 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19701 int result;
19702 void *argp1 = 0 ;
19703 int res1 = 0 ;
19704 PyObject *swig_obj[1] ;
19705
19706 if (!args) SWIG_fail;
19707 swig_obj[0] = args;
19708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19709 if (!SWIG_IsOK(res1)) {
19710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19711 }
19712 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19716 wxPyEndAllowThreads(__tstate);
19717 if (PyErr_Occurred()) SWIG_fail;
19718 }
19719 resultobj = SWIG_From_int(static_cast< int >(result));
19720 return resultobj;
19721 fail:
19722 return NULL;
19723 }
19724
19725
19726 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19727 PyObject *resultobj = 0;
19728 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19729 int arg2 ;
19730 void *argp1 = 0 ;
19731 int res1 = 0 ;
19732 int val2 ;
19733 int ecode2 = 0 ;
19734 PyObject * obj0 = 0 ;
19735 PyObject * obj1 = 0 ;
19736 char * kwnames[] = {
19737 (char *) "self",(char *) "orient", NULL
19738 };
19739
19740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19742 if (!SWIG_IsOK(res1)) {
19743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19744 }
19745 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19746 ecode2 = SWIG_AsVal_int(obj1, &val2);
19747 if (!SWIG_IsOK(ecode2)) {
19748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19749 }
19750 arg2 = static_cast< int >(val2);
19751 {
19752 PyThreadState* __tstate = wxPyBeginAllowThreads();
19753 (arg1)->SetOrientation(arg2);
19754 wxPyEndAllowThreads(__tstate);
19755 if (PyErr_Occurred()) SWIG_fail;
19756 }
19757 resultobj = SWIG_Py_Void();
19758 return resultobj;
19759 fail:
19760 return NULL;
19761 }
19762
19763
19764 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19765 PyObject *resultobj = 0;
19766 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19767 int arg2 ;
19768 void *argp1 = 0 ;
19769 int res1 = 0 ;
19770 int val2 ;
19771 int ecode2 = 0 ;
19772 PyObject * obj0 = 0 ;
19773 PyObject * obj1 = 0 ;
19774 char * kwnames[] = {
19775 (char *) "self",(char *) "pos", NULL
19776 };
19777
19778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19780 if (!SWIG_IsOK(res1)) {
19781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19782 }
19783 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19784 ecode2 = SWIG_AsVal_int(obj1, &val2);
19785 if (!SWIG_IsOK(ecode2)) {
19786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19787 }
19788 arg2 = static_cast< int >(val2);
19789 {
19790 PyThreadState* __tstate = wxPyBeginAllowThreads();
19791 (arg1)->SetPosition(arg2);
19792 wxPyEndAllowThreads(__tstate);
19793 if (PyErr_Occurred()) SWIG_fail;
19794 }
19795 resultobj = SWIG_Py_Void();
19796 return resultobj;
19797 fail:
19798 return NULL;
19799 }
19800
19801
19802 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19803 PyObject *obj;
19804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19805 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19806 return SWIG_Py_Void();
19807 }
19808
19809 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19810 return SWIG_Python_InitShadowInstance(args);
19811 }
19812
19813 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19814 PyObject *resultobj = 0;
19815 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19816 int arg2 = (int) 0 ;
19817 int arg3 = (int) 0 ;
19818 wxScrollWinEvent *result = 0 ;
19819 int val1 ;
19820 int ecode1 = 0 ;
19821 int val2 ;
19822 int ecode2 = 0 ;
19823 int val3 ;
19824 int ecode3 = 0 ;
19825 PyObject * obj0 = 0 ;
19826 PyObject * obj1 = 0 ;
19827 PyObject * obj2 = 0 ;
19828 char * kwnames[] = {
19829 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19830 };
19831
19832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19833 if (obj0) {
19834 ecode1 = SWIG_AsVal_int(obj0, &val1);
19835 if (!SWIG_IsOK(ecode1)) {
19836 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19837 }
19838 arg1 = static_cast< wxEventType >(val1);
19839 }
19840 if (obj1) {
19841 ecode2 = SWIG_AsVal_int(obj1, &val2);
19842 if (!SWIG_IsOK(ecode2)) {
19843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19844 }
19845 arg2 = static_cast< int >(val2);
19846 }
19847 if (obj2) {
19848 ecode3 = SWIG_AsVal_int(obj2, &val3);
19849 if (!SWIG_IsOK(ecode3)) {
19850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19851 }
19852 arg3 = static_cast< int >(val3);
19853 }
19854 {
19855 PyThreadState* __tstate = wxPyBeginAllowThreads();
19856 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19857 wxPyEndAllowThreads(__tstate);
19858 if (PyErr_Occurred()) SWIG_fail;
19859 }
19860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19861 return resultobj;
19862 fail:
19863 return NULL;
19864 }
19865
19866
19867 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19868 PyObject *resultobj = 0;
19869 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19870 int result;
19871 void *argp1 = 0 ;
19872 int res1 = 0 ;
19873 PyObject *swig_obj[1] ;
19874
19875 if (!args) SWIG_fail;
19876 swig_obj[0] = args;
19877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19878 if (!SWIG_IsOK(res1)) {
19879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19880 }
19881 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19882 {
19883 PyThreadState* __tstate = wxPyBeginAllowThreads();
19884 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19885 wxPyEndAllowThreads(__tstate);
19886 if (PyErr_Occurred()) SWIG_fail;
19887 }
19888 resultobj = SWIG_From_int(static_cast< int >(result));
19889 return resultobj;
19890 fail:
19891 return NULL;
19892 }
19893
19894
19895 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19896 PyObject *resultobj = 0;
19897 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19898 int result;
19899 void *argp1 = 0 ;
19900 int res1 = 0 ;
19901 PyObject *swig_obj[1] ;
19902
19903 if (!args) SWIG_fail;
19904 swig_obj[0] = args;
19905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19906 if (!SWIG_IsOK(res1)) {
19907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19908 }
19909 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19910 {
19911 PyThreadState* __tstate = wxPyBeginAllowThreads();
19912 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19913 wxPyEndAllowThreads(__tstate);
19914 if (PyErr_Occurred()) SWIG_fail;
19915 }
19916 resultobj = SWIG_From_int(static_cast< int >(result));
19917 return resultobj;
19918 fail:
19919 return NULL;
19920 }
19921
19922
19923 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19924 PyObject *resultobj = 0;
19925 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19926 int arg2 ;
19927 void *argp1 = 0 ;
19928 int res1 = 0 ;
19929 int val2 ;
19930 int ecode2 = 0 ;
19931 PyObject * obj0 = 0 ;
19932 PyObject * obj1 = 0 ;
19933 char * kwnames[] = {
19934 (char *) "self",(char *) "orient", NULL
19935 };
19936
19937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19939 if (!SWIG_IsOK(res1)) {
19940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19941 }
19942 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19943 ecode2 = SWIG_AsVal_int(obj1, &val2);
19944 if (!SWIG_IsOK(ecode2)) {
19945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19946 }
19947 arg2 = static_cast< int >(val2);
19948 {
19949 PyThreadState* __tstate = wxPyBeginAllowThreads();
19950 (arg1)->SetOrientation(arg2);
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 resultobj = SWIG_Py_Void();
19955 return resultobj;
19956 fail:
19957 return NULL;
19958 }
19959
19960
19961 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19962 PyObject *resultobj = 0;
19963 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19964 int arg2 ;
19965 void *argp1 = 0 ;
19966 int res1 = 0 ;
19967 int val2 ;
19968 int ecode2 = 0 ;
19969 PyObject * obj0 = 0 ;
19970 PyObject * obj1 = 0 ;
19971 char * kwnames[] = {
19972 (char *) "self",(char *) "pos", NULL
19973 };
19974
19975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19977 if (!SWIG_IsOK(res1)) {
19978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19979 }
19980 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19981 ecode2 = SWIG_AsVal_int(obj1, &val2);
19982 if (!SWIG_IsOK(ecode2)) {
19983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19984 }
19985 arg2 = static_cast< int >(val2);
19986 {
19987 PyThreadState* __tstate = wxPyBeginAllowThreads();
19988 (arg1)->SetPosition(arg2);
19989 wxPyEndAllowThreads(__tstate);
19990 if (PyErr_Occurred()) SWIG_fail;
19991 }
19992 resultobj = SWIG_Py_Void();
19993 return resultobj;
19994 fail:
19995 return NULL;
19996 }
19997
19998
19999 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20000 PyObject *obj;
20001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20002 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20003 return SWIG_Py_Void();
20004 }
20005
20006 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20007 return SWIG_Python_InitShadowInstance(args);
20008 }
20009
20010 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20011 PyObject *resultobj = 0;
20012 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20013 wxMouseEvent *result = 0 ;
20014 int val1 ;
20015 int ecode1 = 0 ;
20016 PyObject * obj0 = 0 ;
20017 char * kwnames[] = {
20018 (char *) "mouseType", NULL
20019 };
20020
20021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20022 if (obj0) {
20023 ecode1 = SWIG_AsVal_int(obj0, &val1);
20024 if (!SWIG_IsOK(ecode1)) {
20025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20026 }
20027 arg1 = static_cast< wxEventType >(val1);
20028 }
20029 {
20030 PyThreadState* __tstate = wxPyBeginAllowThreads();
20031 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20032 wxPyEndAllowThreads(__tstate);
20033 if (PyErr_Occurred()) SWIG_fail;
20034 }
20035 {
20036 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20037 }
20038 return resultobj;
20039 fail:
20040 return NULL;
20041 }
20042
20043
20044 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20045 PyObject *resultobj = 0;
20046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20047 bool result;
20048 void *argp1 = 0 ;
20049 int res1 = 0 ;
20050 PyObject *swig_obj[1] ;
20051
20052 if (!args) SWIG_fail;
20053 swig_obj[0] = args;
20054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20055 if (!SWIG_IsOK(res1)) {
20056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20057 }
20058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20059 {
20060 PyThreadState* __tstate = wxPyBeginAllowThreads();
20061 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20062 wxPyEndAllowThreads(__tstate);
20063 if (PyErr_Occurred()) SWIG_fail;
20064 }
20065 {
20066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20067 }
20068 return resultobj;
20069 fail:
20070 return NULL;
20071 }
20072
20073
20074 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20075 PyObject *resultobj = 0;
20076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20077 int arg2 = (int) wxMOUSE_BTN_ANY ;
20078 bool result;
20079 void *argp1 = 0 ;
20080 int res1 = 0 ;
20081 int val2 ;
20082 int ecode2 = 0 ;
20083 PyObject * obj0 = 0 ;
20084 PyObject * obj1 = 0 ;
20085 char * kwnames[] = {
20086 (char *) "self",(char *) "but", NULL
20087 };
20088
20089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20091 if (!SWIG_IsOK(res1)) {
20092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20093 }
20094 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20095 if (obj1) {
20096 ecode2 = SWIG_AsVal_int(obj1, &val2);
20097 if (!SWIG_IsOK(ecode2)) {
20098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20099 }
20100 arg2 = static_cast< int >(val2);
20101 }
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 {
20109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20110 }
20111 return resultobj;
20112 fail:
20113 return NULL;
20114 }
20115
20116
20117 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20118 PyObject *resultobj = 0;
20119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20120 int arg2 = (int) wxMOUSE_BTN_ANY ;
20121 bool result;
20122 void *argp1 = 0 ;
20123 int res1 = 0 ;
20124 int val2 ;
20125 int ecode2 = 0 ;
20126 PyObject * obj0 = 0 ;
20127 PyObject * obj1 = 0 ;
20128 char * kwnames[] = {
20129 (char *) "self",(char *) "but", NULL
20130 };
20131
20132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20134 if (!SWIG_IsOK(res1)) {
20135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20136 }
20137 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20138 if (obj1) {
20139 ecode2 = SWIG_AsVal_int(obj1, &val2);
20140 if (!SWIG_IsOK(ecode2)) {
20141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20142 }
20143 arg2 = static_cast< int >(val2);
20144 }
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 {
20152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20153 }
20154 return resultobj;
20155 fail:
20156 return NULL;
20157 }
20158
20159
20160 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20161 PyObject *resultobj = 0;
20162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20163 int arg2 = (int) wxMOUSE_BTN_ANY ;
20164 bool result;
20165 void *argp1 = 0 ;
20166 int res1 = 0 ;
20167 int val2 ;
20168 int ecode2 = 0 ;
20169 PyObject * obj0 = 0 ;
20170 PyObject * obj1 = 0 ;
20171 char * kwnames[] = {
20172 (char *) "self",(char *) "but", NULL
20173 };
20174
20175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20177 if (!SWIG_IsOK(res1)) {
20178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20179 }
20180 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20181 if (obj1) {
20182 ecode2 = SWIG_AsVal_int(obj1, &val2);
20183 if (!SWIG_IsOK(ecode2)) {
20184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20185 }
20186 arg2 = static_cast< int >(val2);
20187 }
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20191 wxPyEndAllowThreads(__tstate);
20192 if (PyErr_Occurred()) SWIG_fail;
20193 }
20194 {
20195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20196 }
20197 return resultobj;
20198 fail:
20199 return NULL;
20200 }
20201
20202
20203 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20204 PyObject *resultobj = 0;
20205 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20206 int arg2 ;
20207 bool result;
20208 void *argp1 = 0 ;
20209 int res1 = 0 ;
20210 int val2 ;
20211 int ecode2 = 0 ;
20212 PyObject * obj0 = 0 ;
20213 PyObject * obj1 = 0 ;
20214 char * kwnames[] = {
20215 (char *) "self",(char *) "button", NULL
20216 };
20217
20218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20222 }
20223 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20224 ecode2 = SWIG_AsVal_int(obj1, &val2);
20225 if (!SWIG_IsOK(ecode2)) {
20226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20227 }
20228 arg2 = static_cast< int >(val2);
20229 {
20230 PyThreadState* __tstate = wxPyBeginAllowThreads();
20231 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20232 wxPyEndAllowThreads(__tstate);
20233 if (PyErr_Occurred()) SWIG_fail;
20234 }
20235 {
20236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20237 }
20238 return resultobj;
20239 fail:
20240 return NULL;
20241 }
20242
20243
20244 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20245 PyObject *resultobj = 0;
20246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20247 int arg2 ;
20248 bool result;
20249 void *argp1 = 0 ;
20250 int res1 = 0 ;
20251 int val2 ;
20252 int ecode2 = 0 ;
20253 PyObject * obj0 = 0 ;
20254 PyObject * obj1 = 0 ;
20255 char * kwnames[] = {
20256 (char *) "self",(char *) "but", NULL
20257 };
20258
20259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20261 if (!SWIG_IsOK(res1)) {
20262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20263 }
20264 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20265 ecode2 = SWIG_AsVal_int(obj1, &val2);
20266 if (!SWIG_IsOK(ecode2)) {
20267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20268 }
20269 arg2 = static_cast< int >(val2);
20270 {
20271 PyThreadState* __tstate = wxPyBeginAllowThreads();
20272 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20273 wxPyEndAllowThreads(__tstate);
20274 if (PyErr_Occurred()) SWIG_fail;
20275 }
20276 {
20277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20278 }
20279 return resultobj;
20280 fail:
20281 return NULL;
20282 }
20283
20284
20285 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20286 PyObject *resultobj = 0;
20287 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20288 int result;
20289 void *argp1 = 0 ;
20290 int res1 = 0 ;
20291 PyObject *swig_obj[1] ;
20292
20293 if (!args) SWIG_fail;
20294 swig_obj[0] = args;
20295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20296 if (!SWIG_IsOK(res1)) {
20297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20298 }
20299 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20300 {
20301 PyThreadState* __tstate = wxPyBeginAllowThreads();
20302 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20303 wxPyEndAllowThreads(__tstate);
20304 if (PyErr_Occurred()) SWIG_fail;
20305 }
20306 resultobj = SWIG_From_int(static_cast< int >(result));
20307 return resultobj;
20308 fail:
20309 return NULL;
20310 }
20311
20312
20313 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20314 PyObject *resultobj = 0;
20315 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20316 bool result;
20317 void *argp1 = 0 ;
20318 int res1 = 0 ;
20319 PyObject *swig_obj[1] ;
20320
20321 if (!args) SWIG_fail;
20322 swig_obj[0] = args;
20323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20324 if (!SWIG_IsOK(res1)) {
20325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20326 }
20327 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20328 {
20329 PyThreadState* __tstate = wxPyBeginAllowThreads();
20330 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20331 wxPyEndAllowThreads(__tstate);
20332 if (PyErr_Occurred()) SWIG_fail;
20333 }
20334 {
20335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20336 }
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20344 PyObject *resultobj = 0;
20345 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20346 bool result;
20347 void *argp1 = 0 ;
20348 int res1 = 0 ;
20349 PyObject *swig_obj[1] ;
20350
20351 if (!args) SWIG_fail;
20352 swig_obj[0] = args;
20353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20354 if (!SWIG_IsOK(res1)) {
20355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20356 }
20357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 {
20365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20366 }
20367 return resultobj;
20368 fail:
20369 return NULL;
20370 }
20371
20372
20373 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20374 PyObject *resultobj = 0;
20375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20376 bool result;
20377 void *argp1 = 0 ;
20378 int res1 = 0 ;
20379 PyObject *swig_obj[1] ;
20380
20381 if (!args) SWIG_fail;
20382 swig_obj[0] = args;
20383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20384 if (!SWIG_IsOK(res1)) {
20385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20386 }
20387 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20388 {
20389 PyThreadState* __tstate = wxPyBeginAllowThreads();
20390 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20391 wxPyEndAllowThreads(__tstate);
20392 if (PyErr_Occurred()) SWIG_fail;
20393 }
20394 {
20395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20396 }
20397 return resultobj;
20398 fail:
20399 return NULL;
20400 }
20401
20402
20403 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20404 PyObject *resultobj = 0;
20405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20406 bool result;
20407 void *argp1 = 0 ;
20408 int res1 = 0 ;
20409 PyObject *swig_obj[1] ;
20410
20411 if (!args) SWIG_fail;
20412 swig_obj[0] = args;
20413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20414 if (!SWIG_IsOK(res1)) {
20415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20416 }
20417 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20421 wxPyEndAllowThreads(__tstate);
20422 if (PyErr_Occurred()) SWIG_fail;
20423 }
20424 {
20425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20426 }
20427 return resultobj;
20428 fail:
20429 return NULL;
20430 }
20431
20432
20433 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20434 PyObject *resultobj = 0;
20435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20436 bool result;
20437 void *argp1 = 0 ;
20438 int res1 = 0 ;
20439 PyObject *swig_obj[1] ;
20440
20441 if (!args) SWIG_fail;
20442 swig_obj[0] = args;
20443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20444 if (!SWIG_IsOK(res1)) {
20445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20446 }
20447 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20448 {
20449 PyThreadState* __tstate = wxPyBeginAllowThreads();
20450 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20451 wxPyEndAllowThreads(__tstate);
20452 if (PyErr_Occurred()) SWIG_fail;
20453 }
20454 {
20455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20456 }
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20464 PyObject *resultobj = 0;
20465 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20466 bool result;
20467 void *argp1 = 0 ;
20468 int res1 = 0 ;
20469 PyObject *swig_obj[1] ;
20470
20471 if (!args) SWIG_fail;
20472 swig_obj[0] = args;
20473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20474 if (!SWIG_IsOK(res1)) {
20475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20476 }
20477 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20478 {
20479 PyThreadState* __tstate = wxPyBeginAllowThreads();
20480 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20481 wxPyEndAllowThreads(__tstate);
20482 if (PyErr_Occurred()) SWIG_fail;
20483 }
20484 {
20485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20486 }
20487 return resultobj;
20488 fail:
20489 return NULL;
20490 }
20491
20492
20493 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20494 PyObject *resultobj = 0;
20495 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20496 bool result;
20497 void *argp1 = 0 ;
20498 int res1 = 0 ;
20499 PyObject *swig_obj[1] ;
20500
20501 if (!args) SWIG_fail;
20502 swig_obj[0] = args;
20503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20504 if (!SWIG_IsOK(res1)) {
20505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20506 }
20507 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 {
20515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20516 }
20517 return resultobj;
20518 fail:
20519 return NULL;
20520 }
20521
20522
20523 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20524 PyObject *resultobj = 0;
20525 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20526 bool result;
20527 void *argp1 = 0 ;
20528 int res1 = 0 ;
20529 PyObject *swig_obj[1] ;
20530
20531 if (!args) SWIG_fail;
20532 swig_obj[0] = args;
20533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20534 if (!SWIG_IsOK(res1)) {
20535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20536 }
20537 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20538 {
20539 PyThreadState* __tstate = wxPyBeginAllowThreads();
20540 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20541 wxPyEndAllowThreads(__tstate);
20542 if (PyErr_Occurred()) SWIG_fail;
20543 }
20544 {
20545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20546 }
20547 return resultobj;
20548 fail:
20549 return NULL;
20550 }
20551
20552
20553 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20554 PyObject *resultobj = 0;
20555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20556 bool result;
20557 void *argp1 = 0 ;
20558 int res1 = 0 ;
20559 PyObject *swig_obj[1] ;
20560
20561 if (!args) SWIG_fail;
20562 swig_obj[0] = args;
20563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20564 if (!SWIG_IsOK(res1)) {
20565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20566 }
20567 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20568 {
20569 PyThreadState* __tstate = wxPyBeginAllowThreads();
20570 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20571 wxPyEndAllowThreads(__tstate);
20572 if (PyErr_Occurred()) SWIG_fail;
20573 }
20574 {
20575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20576 }
20577 return resultobj;
20578 fail:
20579 return NULL;
20580 }
20581
20582
20583 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20584 PyObject *resultobj = 0;
20585 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20586 bool result;
20587 void *argp1 = 0 ;
20588 int res1 = 0 ;
20589 PyObject *swig_obj[1] ;
20590
20591 if (!args) SWIG_fail;
20592 swig_obj[0] = args;
20593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20594 if (!SWIG_IsOK(res1)) {
20595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20596 }
20597 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20598 {
20599 PyThreadState* __tstate = wxPyBeginAllowThreads();
20600 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 {
20605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20606 }
20607 return resultobj;
20608 fail:
20609 return NULL;
20610 }
20611
20612
20613 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20614 PyObject *resultobj = 0;
20615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20616 bool result;
20617 void *argp1 = 0 ;
20618 int res1 = 0 ;
20619 PyObject *swig_obj[1] ;
20620
20621 if (!args) SWIG_fail;
20622 swig_obj[0] = args;
20623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20624 if (!SWIG_IsOK(res1)) {
20625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20626 }
20627 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20628 {
20629 PyThreadState* __tstate = wxPyBeginAllowThreads();
20630 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20631 wxPyEndAllowThreads(__tstate);
20632 if (PyErr_Occurred()) SWIG_fail;
20633 }
20634 {
20635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20636 }
20637 return resultobj;
20638 fail:
20639 return NULL;
20640 }
20641
20642
20643 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20644 PyObject *resultobj = 0;
20645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20646 bool result;
20647 void *argp1 = 0 ;
20648 int res1 = 0 ;
20649 PyObject *swig_obj[1] ;
20650
20651 if (!args) SWIG_fail;
20652 swig_obj[0] = args;
20653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20654 if (!SWIG_IsOK(res1)) {
20655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20656 }
20657 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20658 {
20659 PyThreadState* __tstate = wxPyBeginAllowThreads();
20660 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20661 wxPyEndAllowThreads(__tstate);
20662 if (PyErr_Occurred()) SWIG_fail;
20663 }
20664 {
20665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20666 }
20667 return resultobj;
20668 fail:
20669 return NULL;
20670 }
20671
20672
20673 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20674 PyObject *resultobj = 0;
20675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20676 bool result;
20677 void *argp1 = 0 ;
20678 int res1 = 0 ;
20679 PyObject *swig_obj[1] ;
20680
20681 if (!args) SWIG_fail;
20682 swig_obj[0] = args;
20683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20684 if (!SWIG_IsOK(res1)) {
20685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20686 }
20687 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20688 {
20689 PyThreadState* __tstate = wxPyBeginAllowThreads();
20690 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20691 wxPyEndAllowThreads(__tstate);
20692 if (PyErr_Occurred()) SWIG_fail;
20693 }
20694 {
20695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20696 }
20697 return resultobj;
20698 fail:
20699 return NULL;
20700 }
20701
20702
20703 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20704 PyObject *resultobj = 0;
20705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20706 bool result;
20707 void *argp1 = 0 ;
20708 int res1 = 0 ;
20709 PyObject *swig_obj[1] ;
20710
20711 if (!args) SWIG_fail;
20712 swig_obj[0] = args;
20713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20714 if (!SWIG_IsOK(res1)) {
20715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20716 }
20717 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20718 {
20719 PyThreadState* __tstate = wxPyBeginAllowThreads();
20720 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20721 wxPyEndAllowThreads(__tstate);
20722 if (PyErr_Occurred()) SWIG_fail;
20723 }
20724 {
20725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20726 }
20727 return resultobj;
20728 fail:
20729 return NULL;
20730 }
20731
20732
20733 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20734 PyObject *resultobj = 0;
20735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20736 bool result;
20737 void *argp1 = 0 ;
20738 int res1 = 0 ;
20739 PyObject *swig_obj[1] ;
20740
20741 if (!args) SWIG_fail;
20742 swig_obj[0] = args;
20743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20744 if (!SWIG_IsOK(res1)) {
20745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20746 }
20747 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20748 {
20749 PyThreadState* __tstate = wxPyBeginAllowThreads();
20750 result = (bool)(arg1)->LeftIsDown();
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 {
20755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20756 }
20757 return resultobj;
20758 fail:
20759 return NULL;
20760 }
20761
20762
20763 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20764 PyObject *resultobj = 0;
20765 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20766 bool result;
20767 void *argp1 = 0 ;
20768 int res1 = 0 ;
20769 PyObject *swig_obj[1] ;
20770
20771 if (!args) SWIG_fail;
20772 swig_obj[0] = args;
20773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20774 if (!SWIG_IsOK(res1)) {
20775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20776 }
20777 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20778 {
20779 PyThreadState* __tstate = wxPyBeginAllowThreads();
20780 result = (bool)(arg1)->MiddleIsDown();
20781 wxPyEndAllowThreads(__tstate);
20782 if (PyErr_Occurred()) SWIG_fail;
20783 }
20784 {
20785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20786 }
20787 return resultobj;
20788 fail:
20789 return NULL;
20790 }
20791
20792
20793 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20794 PyObject *resultobj = 0;
20795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20796 bool result;
20797 void *argp1 = 0 ;
20798 int res1 = 0 ;
20799 PyObject *swig_obj[1] ;
20800
20801 if (!args) SWIG_fail;
20802 swig_obj[0] = args;
20803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20804 if (!SWIG_IsOK(res1)) {
20805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20806 }
20807 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20808 {
20809 PyThreadState* __tstate = wxPyBeginAllowThreads();
20810 result = (bool)(arg1)->RightIsDown();
20811 wxPyEndAllowThreads(__tstate);
20812 if (PyErr_Occurred()) SWIG_fail;
20813 }
20814 {
20815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20816 }
20817 return resultobj;
20818 fail:
20819 return NULL;
20820 }
20821
20822
20823 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20824 PyObject *resultobj = 0;
20825 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20826 bool result;
20827 void *argp1 = 0 ;
20828 int res1 = 0 ;
20829 PyObject *swig_obj[1] ;
20830
20831 if (!args) SWIG_fail;
20832 swig_obj[0] = args;
20833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20834 if (!SWIG_IsOK(res1)) {
20835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20836 }
20837 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20838 {
20839 PyThreadState* __tstate = wxPyBeginAllowThreads();
20840 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20841 wxPyEndAllowThreads(__tstate);
20842 if (PyErr_Occurred()) SWIG_fail;
20843 }
20844 {
20845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20846 }
20847 return resultobj;
20848 fail:
20849 return NULL;
20850 }
20851
20852
20853 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20854 PyObject *resultobj = 0;
20855 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20856 bool result;
20857 void *argp1 = 0 ;
20858 int res1 = 0 ;
20859 PyObject *swig_obj[1] ;
20860
20861 if (!args) SWIG_fail;
20862 swig_obj[0] = args;
20863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20864 if (!SWIG_IsOK(res1)) {
20865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20866 }
20867 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20868 {
20869 PyThreadState* __tstate = wxPyBeginAllowThreads();
20870 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20871 wxPyEndAllowThreads(__tstate);
20872 if (PyErr_Occurred()) SWIG_fail;
20873 }
20874 {
20875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20876 }
20877 return resultobj;
20878 fail:
20879 return NULL;
20880 }
20881
20882
20883 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20884 PyObject *resultobj = 0;
20885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20886 bool result;
20887 void *argp1 = 0 ;
20888 int res1 = 0 ;
20889 PyObject *swig_obj[1] ;
20890
20891 if (!args) SWIG_fail;
20892 swig_obj[0] = args;
20893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20894 if (!SWIG_IsOK(res1)) {
20895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20896 }
20897 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20898 {
20899 PyThreadState* __tstate = wxPyBeginAllowThreads();
20900 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20901 wxPyEndAllowThreads(__tstate);
20902 if (PyErr_Occurred()) SWIG_fail;
20903 }
20904 {
20905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20906 }
20907 return resultobj;
20908 fail:
20909 return NULL;
20910 }
20911
20912
20913 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20914 PyObject *resultobj = 0;
20915 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20916 bool result;
20917 void *argp1 = 0 ;
20918 int res1 = 0 ;
20919 PyObject *swig_obj[1] ;
20920
20921 if (!args) SWIG_fail;
20922 swig_obj[0] = args;
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_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20926 }
20927 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20928 {
20929 PyThreadState* __tstate = wxPyBeginAllowThreads();
20930 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20931 wxPyEndAllowThreads(__tstate);
20932 if (PyErr_Occurred()) SWIG_fail;
20933 }
20934 {
20935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20936 }
20937 return resultobj;
20938 fail:
20939 return NULL;
20940 }
20941
20942
20943 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20944 PyObject *resultobj = 0;
20945 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20946 wxPoint result;
20947 void *argp1 = 0 ;
20948 int res1 = 0 ;
20949 PyObject *swig_obj[1] ;
20950
20951 if (!args) SWIG_fail;
20952 swig_obj[0] = args;
20953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20954 if (!SWIG_IsOK(res1)) {
20955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20956 }
20957 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20958 {
20959 PyThreadState* __tstate = wxPyBeginAllowThreads();
20960 result = (arg1)->GetPosition();
20961 wxPyEndAllowThreads(__tstate);
20962 if (PyErr_Occurred()) SWIG_fail;
20963 }
20964 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20965 return resultobj;
20966 fail:
20967 return NULL;
20968 }
20969
20970
20971 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20972 PyObject *resultobj = 0;
20973 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20974 long *arg2 = (long *) 0 ;
20975 long *arg3 = (long *) 0 ;
20976 void *argp1 = 0 ;
20977 int res1 = 0 ;
20978 long temp2 ;
20979 int res2 = SWIG_TMPOBJ ;
20980 long temp3 ;
20981 int res3 = SWIG_TMPOBJ ;
20982 PyObject *swig_obj[1] ;
20983
20984 arg2 = &temp2;
20985 arg3 = &temp3;
20986 if (!args) SWIG_fail;
20987 swig_obj[0] = args;
20988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20989 if (!SWIG_IsOK(res1)) {
20990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20991 }
20992 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 (arg1)->GetPosition(arg2,arg3);
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 resultobj = SWIG_Py_Void();
21000 if (SWIG_IsTmpObj(res2)) {
21001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21002 } else {
21003 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21005 }
21006 if (SWIG_IsTmpObj(res3)) {
21007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21008 } else {
21009 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21011 }
21012 return resultobj;
21013 fail:
21014 return NULL;
21015 }
21016
21017
21018 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21019 PyObject *resultobj = 0;
21020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21021 wxDC *arg2 = 0 ;
21022 wxPoint result;
21023 void *argp1 = 0 ;
21024 int res1 = 0 ;
21025 void *argp2 = 0 ;
21026 int res2 = 0 ;
21027 PyObject * obj0 = 0 ;
21028 PyObject * obj1 = 0 ;
21029 char * kwnames[] = {
21030 (char *) "self",(char *) "dc", NULL
21031 };
21032
21033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21035 if (!SWIG_IsOK(res1)) {
21036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21037 }
21038 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21039 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21040 if (!SWIG_IsOK(res2)) {
21041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21042 }
21043 if (!argp2) {
21044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21045 }
21046 arg2 = reinterpret_cast< wxDC * >(argp2);
21047 {
21048 PyThreadState* __tstate = wxPyBeginAllowThreads();
21049 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21061 PyObject *resultobj = 0;
21062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21063 int result;
21064 void *argp1 = 0 ;
21065 int res1 = 0 ;
21066 PyObject *swig_obj[1] ;
21067
21068 if (!args) SWIG_fail;
21069 swig_obj[0] = args;
21070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21071 if (!SWIG_IsOK(res1)) {
21072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21073 }
21074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 result = (int)((wxMouseEvent const *)arg1)->GetX();
21078 wxPyEndAllowThreads(__tstate);
21079 if (PyErr_Occurred()) SWIG_fail;
21080 }
21081 resultobj = SWIG_From_int(static_cast< int >(result));
21082 return resultobj;
21083 fail:
21084 return NULL;
21085 }
21086
21087
21088 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21089 PyObject *resultobj = 0;
21090 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21091 int result;
21092 void *argp1 = 0 ;
21093 int res1 = 0 ;
21094 PyObject *swig_obj[1] ;
21095
21096 if (!args) SWIG_fail;
21097 swig_obj[0] = args;
21098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21099 if (!SWIG_IsOK(res1)) {
21100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21101 }
21102 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 result = (int)((wxMouseEvent const *)arg1)->GetY();
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 resultobj = SWIG_From_int(static_cast< int >(result));
21110 return resultobj;
21111 fail:
21112 return NULL;
21113 }
21114
21115
21116 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21117 PyObject *resultobj = 0;
21118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21119 int result;
21120 void *argp1 = 0 ;
21121 int res1 = 0 ;
21122 PyObject *swig_obj[1] ;
21123
21124 if (!args) SWIG_fail;
21125 swig_obj[0] = args;
21126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21127 if (!SWIG_IsOK(res1)) {
21128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21129 }
21130 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21131 {
21132 PyThreadState* __tstate = wxPyBeginAllowThreads();
21133 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 resultobj = SWIG_From_int(static_cast< int >(result));
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21145 PyObject *resultobj = 0;
21146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21147 int result;
21148 void *argp1 = 0 ;
21149 int res1 = 0 ;
21150 PyObject *swig_obj[1] ;
21151
21152 if (!args) SWIG_fail;
21153 swig_obj[0] = args;
21154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21155 if (!SWIG_IsOK(res1)) {
21156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21157 }
21158 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21162 wxPyEndAllowThreads(__tstate);
21163 if (PyErr_Occurred()) SWIG_fail;
21164 }
21165 resultobj = SWIG_From_int(static_cast< int >(result));
21166 return resultobj;
21167 fail:
21168 return NULL;
21169 }
21170
21171
21172 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21173 PyObject *resultobj = 0;
21174 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21175 int result;
21176 void *argp1 = 0 ;
21177 int res1 = 0 ;
21178 PyObject *swig_obj[1] ;
21179
21180 if (!args) SWIG_fail;
21181 swig_obj[0] = args;
21182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21183 if (!SWIG_IsOK(res1)) {
21184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21185 }
21186 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21190 wxPyEndAllowThreads(__tstate);
21191 if (PyErr_Occurred()) SWIG_fail;
21192 }
21193 resultobj = SWIG_From_int(static_cast< int >(result));
21194 return resultobj;
21195 fail:
21196 return NULL;
21197 }
21198
21199
21200 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21201 PyObject *resultobj = 0;
21202 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21203 bool result;
21204 void *argp1 = 0 ;
21205 int res1 = 0 ;
21206 PyObject *swig_obj[1] ;
21207
21208 if (!args) SWIG_fail;
21209 swig_obj[0] = args;
21210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21211 if (!SWIG_IsOK(res1)) {
21212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21213 }
21214 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21215 {
21216 PyThreadState* __tstate = wxPyBeginAllowThreads();
21217 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 {
21222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21223 }
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21231 PyObject *resultobj = 0;
21232 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21233 int arg2 ;
21234 void *argp1 = 0 ;
21235 int res1 = 0 ;
21236 int val2 ;
21237 int ecode2 = 0 ;
21238 PyObject *swig_obj[2] ;
21239
21240 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21242 if (!SWIG_IsOK(res1)) {
21243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21244 }
21245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21246 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21247 if (!SWIG_IsOK(ecode2)) {
21248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21249 }
21250 arg2 = static_cast< int >(val2);
21251 if (arg1) (arg1)->m_x = arg2;
21252
21253 resultobj = SWIG_Py_Void();
21254 return resultobj;
21255 fail:
21256 return NULL;
21257 }
21258
21259
21260 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21261 PyObject *resultobj = 0;
21262 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21263 int result;
21264 void *argp1 = 0 ;
21265 int res1 = 0 ;
21266 PyObject *swig_obj[1] ;
21267
21268 if (!args) SWIG_fail;
21269 swig_obj[0] = args;
21270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21271 if (!SWIG_IsOK(res1)) {
21272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21273 }
21274 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21275 result = (int) ((arg1)->m_x);
21276 resultobj = SWIG_From_int(static_cast< int >(result));
21277 return resultobj;
21278 fail:
21279 return NULL;
21280 }
21281
21282
21283 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21284 PyObject *resultobj = 0;
21285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21286 int arg2 ;
21287 void *argp1 = 0 ;
21288 int res1 = 0 ;
21289 int val2 ;
21290 int ecode2 = 0 ;
21291 PyObject *swig_obj[2] ;
21292
21293 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21295 if (!SWIG_IsOK(res1)) {
21296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21297 }
21298 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21299 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21300 if (!SWIG_IsOK(ecode2)) {
21301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21302 }
21303 arg2 = static_cast< int >(val2);
21304 if (arg1) (arg1)->m_y = arg2;
21305
21306 resultobj = SWIG_Py_Void();
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21314 PyObject *resultobj = 0;
21315 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21316 int result;
21317 void *argp1 = 0 ;
21318 int res1 = 0 ;
21319 PyObject *swig_obj[1] ;
21320
21321 if (!args) SWIG_fail;
21322 swig_obj[0] = args;
21323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21324 if (!SWIG_IsOK(res1)) {
21325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21326 }
21327 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21328 result = (int) ((arg1)->m_y);
21329 resultobj = SWIG_From_int(static_cast< int >(result));
21330 return resultobj;
21331 fail:
21332 return NULL;
21333 }
21334
21335
21336 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21337 PyObject *resultobj = 0;
21338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21339 bool arg2 ;
21340 void *argp1 = 0 ;
21341 int res1 = 0 ;
21342 bool val2 ;
21343 int ecode2 = 0 ;
21344 PyObject *swig_obj[2] ;
21345
21346 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21348 if (!SWIG_IsOK(res1)) {
21349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21350 }
21351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21352 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21353 if (!SWIG_IsOK(ecode2)) {
21354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21355 }
21356 arg2 = static_cast< bool >(val2);
21357 if (arg1) (arg1)->m_leftDown = arg2;
21358
21359 resultobj = SWIG_Py_Void();
21360 return resultobj;
21361 fail:
21362 return NULL;
21363 }
21364
21365
21366 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21367 PyObject *resultobj = 0;
21368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21369 bool result;
21370 void *argp1 = 0 ;
21371 int res1 = 0 ;
21372 PyObject *swig_obj[1] ;
21373
21374 if (!args) SWIG_fail;
21375 swig_obj[0] = args;
21376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21377 if (!SWIG_IsOK(res1)) {
21378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21379 }
21380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21381 result = (bool) ((arg1)->m_leftDown);
21382 {
21383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21384 }
21385 return resultobj;
21386 fail:
21387 return NULL;
21388 }
21389
21390
21391 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21392 PyObject *resultobj = 0;
21393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21394 bool arg2 ;
21395 void *argp1 = 0 ;
21396 int res1 = 0 ;
21397 bool val2 ;
21398 int ecode2 = 0 ;
21399 PyObject *swig_obj[2] ;
21400
21401 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21403 if (!SWIG_IsOK(res1)) {
21404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21405 }
21406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21407 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21408 if (!SWIG_IsOK(ecode2)) {
21409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21410 }
21411 arg2 = static_cast< bool >(val2);
21412 if (arg1) (arg1)->m_middleDown = arg2;
21413
21414 resultobj = SWIG_Py_Void();
21415 return resultobj;
21416 fail:
21417 return NULL;
21418 }
21419
21420
21421 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21422 PyObject *resultobj = 0;
21423 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21424 bool result;
21425 void *argp1 = 0 ;
21426 int res1 = 0 ;
21427 PyObject *swig_obj[1] ;
21428
21429 if (!args) SWIG_fail;
21430 swig_obj[0] = args;
21431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21432 if (!SWIG_IsOK(res1)) {
21433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21434 }
21435 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21436 result = (bool) ((arg1)->m_middleDown);
21437 {
21438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21439 }
21440 return resultobj;
21441 fail:
21442 return NULL;
21443 }
21444
21445
21446 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21447 PyObject *resultobj = 0;
21448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21449 bool arg2 ;
21450 void *argp1 = 0 ;
21451 int res1 = 0 ;
21452 bool val2 ;
21453 int ecode2 = 0 ;
21454 PyObject *swig_obj[2] ;
21455
21456 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21460 }
21461 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21462 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21463 if (!SWIG_IsOK(ecode2)) {
21464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21465 }
21466 arg2 = static_cast< bool >(val2);
21467 if (arg1) (arg1)->m_rightDown = arg2;
21468
21469 resultobj = SWIG_Py_Void();
21470 return resultobj;
21471 fail:
21472 return NULL;
21473 }
21474
21475
21476 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21477 PyObject *resultobj = 0;
21478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21479 bool result;
21480 void *argp1 = 0 ;
21481 int res1 = 0 ;
21482 PyObject *swig_obj[1] ;
21483
21484 if (!args) SWIG_fail;
21485 swig_obj[0] = args;
21486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21487 if (!SWIG_IsOK(res1)) {
21488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21489 }
21490 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21491 result = (bool) ((arg1)->m_rightDown);
21492 {
21493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21494 }
21495 return resultobj;
21496 fail:
21497 return NULL;
21498 }
21499
21500
21501 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21502 PyObject *resultobj = 0;
21503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21504 bool arg2 ;
21505 void *argp1 = 0 ;
21506 int res1 = 0 ;
21507 bool val2 ;
21508 int ecode2 = 0 ;
21509 PyObject *swig_obj[2] ;
21510
21511 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21513 if (!SWIG_IsOK(res1)) {
21514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21515 }
21516 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21517 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21518 if (!SWIG_IsOK(ecode2)) {
21519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21520 }
21521 arg2 = static_cast< bool >(val2);
21522 if (arg1) (arg1)->m_controlDown = arg2;
21523
21524 resultobj = SWIG_Py_Void();
21525 return resultobj;
21526 fail:
21527 return NULL;
21528 }
21529
21530
21531 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21532 PyObject *resultobj = 0;
21533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21534 bool result;
21535 void *argp1 = 0 ;
21536 int res1 = 0 ;
21537 PyObject *swig_obj[1] ;
21538
21539 if (!args) SWIG_fail;
21540 swig_obj[0] = args;
21541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21542 if (!SWIG_IsOK(res1)) {
21543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21544 }
21545 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21546 result = (bool) ((arg1)->m_controlDown);
21547 {
21548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21549 }
21550 return resultobj;
21551 fail:
21552 return NULL;
21553 }
21554
21555
21556 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21557 PyObject *resultobj = 0;
21558 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21559 bool arg2 ;
21560 void *argp1 = 0 ;
21561 int res1 = 0 ;
21562 bool val2 ;
21563 int ecode2 = 0 ;
21564 PyObject *swig_obj[2] ;
21565
21566 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21568 if (!SWIG_IsOK(res1)) {
21569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21570 }
21571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21572 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21573 if (!SWIG_IsOK(ecode2)) {
21574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21575 }
21576 arg2 = static_cast< bool >(val2);
21577 if (arg1) (arg1)->m_shiftDown = arg2;
21578
21579 resultobj = SWIG_Py_Void();
21580 return resultobj;
21581 fail:
21582 return NULL;
21583 }
21584
21585
21586 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21587 PyObject *resultobj = 0;
21588 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21589 bool result;
21590 void *argp1 = 0 ;
21591 int res1 = 0 ;
21592 PyObject *swig_obj[1] ;
21593
21594 if (!args) SWIG_fail;
21595 swig_obj[0] = args;
21596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21597 if (!SWIG_IsOK(res1)) {
21598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21599 }
21600 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21601 result = (bool) ((arg1)->m_shiftDown);
21602 {
21603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21604 }
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21612 PyObject *resultobj = 0;
21613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21614 bool arg2 ;
21615 void *argp1 = 0 ;
21616 int res1 = 0 ;
21617 bool val2 ;
21618 int ecode2 = 0 ;
21619 PyObject *swig_obj[2] ;
21620
21621 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21623 if (!SWIG_IsOK(res1)) {
21624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21625 }
21626 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21627 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21628 if (!SWIG_IsOK(ecode2)) {
21629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21630 }
21631 arg2 = static_cast< bool >(val2);
21632 if (arg1) (arg1)->m_altDown = arg2;
21633
21634 resultobj = SWIG_Py_Void();
21635 return resultobj;
21636 fail:
21637 return NULL;
21638 }
21639
21640
21641 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21642 PyObject *resultobj = 0;
21643 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21644 bool result;
21645 void *argp1 = 0 ;
21646 int res1 = 0 ;
21647 PyObject *swig_obj[1] ;
21648
21649 if (!args) SWIG_fail;
21650 swig_obj[0] = args;
21651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21652 if (!SWIG_IsOK(res1)) {
21653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21654 }
21655 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21656 result = (bool) ((arg1)->m_altDown);
21657 {
21658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21659 }
21660 return resultobj;
21661 fail:
21662 return NULL;
21663 }
21664
21665
21666 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21667 PyObject *resultobj = 0;
21668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21669 bool arg2 ;
21670 void *argp1 = 0 ;
21671 int res1 = 0 ;
21672 bool val2 ;
21673 int ecode2 = 0 ;
21674 PyObject *swig_obj[2] ;
21675
21676 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21678 if (!SWIG_IsOK(res1)) {
21679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21680 }
21681 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21682 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21683 if (!SWIG_IsOK(ecode2)) {
21684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21685 }
21686 arg2 = static_cast< bool >(val2);
21687 if (arg1) (arg1)->m_metaDown = arg2;
21688
21689 resultobj = SWIG_Py_Void();
21690 return resultobj;
21691 fail:
21692 return NULL;
21693 }
21694
21695
21696 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21697 PyObject *resultobj = 0;
21698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21699 bool result;
21700 void *argp1 = 0 ;
21701 int res1 = 0 ;
21702 PyObject *swig_obj[1] ;
21703
21704 if (!args) SWIG_fail;
21705 swig_obj[0] = args;
21706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21707 if (!SWIG_IsOK(res1)) {
21708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21709 }
21710 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21711 result = (bool) ((arg1)->m_metaDown);
21712 {
21713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21714 }
21715 return resultobj;
21716 fail:
21717 return NULL;
21718 }
21719
21720
21721 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21722 PyObject *resultobj = 0;
21723 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21724 int arg2 ;
21725 void *argp1 = 0 ;
21726 int res1 = 0 ;
21727 int val2 ;
21728 int ecode2 = 0 ;
21729 PyObject *swig_obj[2] ;
21730
21731 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21733 if (!SWIG_IsOK(res1)) {
21734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21735 }
21736 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21737 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21738 if (!SWIG_IsOK(ecode2)) {
21739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21740 }
21741 arg2 = static_cast< int >(val2);
21742 if (arg1) (arg1)->m_wheelRotation = arg2;
21743
21744 resultobj = SWIG_Py_Void();
21745 return resultobj;
21746 fail:
21747 return NULL;
21748 }
21749
21750
21751 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21752 PyObject *resultobj = 0;
21753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21754 int result;
21755 void *argp1 = 0 ;
21756 int res1 = 0 ;
21757 PyObject *swig_obj[1] ;
21758
21759 if (!args) SWIG_fail;
21760 swig_obj[0] = args;
21761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21762 if (!SWIG_IsOK(res1)) {
21763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21764 }
21765 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21766 result = (int) ((arg1)->m_wheelRotation);
21767 resultobj = SWIG_From_int(static_cast< int >(result));
21768 return resultobj;
21769 fail:
21770 return NULL;
21771 }
21772
21773
21774 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21775 PyObject *resultobj = 0;
21776 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21777 int arg2 ;
21778 void *argp1 = 0 ;
21779 int res1 = 0 ;
21780 int val2 ;
21781 int ecode2 = 0 ;
21782 PyObject *swig_obj[2] ;
21783
21784 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21786 if (!SWIG_IsOK(res1)) {
21787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21788 }
21789 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21790 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21791 if (!SWIG_IsOK(ecode2)) {
21792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21793 }
21794 arg2 = static_cast< int >(val2);
21795 if (arg1) (arg1)->m_wheelDelta = arg2;
21796
21797 resultobj = SWIG_Py_Void();
21798 return resultobj;
21799 fail:
21800 return NULL;
21801 }
21802
21803
21804 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21805 PyObject *resultobj = 0;
21806 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21807 int result;
21808 void *argp1 = 0 ;
21809 int res1 = 0 ;
21810 PyObject *swig_obj[1] ;
21811
21812 if (!args) SWIG_fail;
21813 swig_obj[0] = args;
21814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21815 if (!SWIG_IsOK(res1)) {
21816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21817 }
21818 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21819 result = (int) ((arg1)->m_wheelDelta);
21820 resultobj = SWIG_From_int(static_cast< int >(result));
21821 return resultobj;
21822 fail:
21823 return NULL;
21824 }
21825
21826
21827 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21828 PyObject *resultobj = 0;
21829 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21830 int arg2 ;
21831 void *argp1 = 0 ;
21832 int res1 = 0 ;
21833 int val2 ;
21834 int ecode2 = 0 ;
21835 PyObject *swig_obj[2] ;
21836
21837 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21839 if (!SWIG_IsOK(res1)) {
21840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21841 }
21842 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21843 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21844 if (!SWIG_IsOK(ecode2)) {
21845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21846 }
21847 arg2 = static_cast< int >(val2);
21848 if (arg1) (arg1)->m_linesPerAction = arg2;
21849
21850 resultobj = SWIG_Py_Void();
21851 return resultobj;
21852 fail:
21853 return NULL;
21854 }
21855
21856
21857 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21858 PyObject *resultobj = 0;
21859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21860 int result;
21861 void *argp1 = 0 ;
21862 int res1 = 0 ;
21863 PyObject *swig_obj[1] ;
21864
21865 if (!args) SWIG_fail;
21866 swig_obj[0] = args;
21867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21868 if (!SWIG_IsOK(res1)) {
21869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21870 }
21871 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21872 result = (int) ((arg1)->m_linesPerAction);
21873 resultobj = SWIG_From_int(static_cast< int >(result));
21874 return resultobj;
21875 fail:
21876 return NULL;
21877 }
21878
21879
21880 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21881 PyObject *obj;
21882 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21883 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21884 return SWIG_Py_Void();
21885 }
21886
21887 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21888 return SWIG_Python_InitShadowInstance(args);
21889 }
21890
21891 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21892 PyObject *resultobj = 0;
21893 int arg1 = (int) 0 ;
21894 int arg2 = (int) 0 ;
21895 wxSetCursorEvent *result = 0 ;
21896 int val1 ;
21897 int ecode1 = 0 ;
21898 int val2 ;
21899 int ecode2 = 0 ;
21900 PyObject * obj0 = 0 ;
21901 PyObject * obj1 = 0 ;
21902 char * kwnames[] = {
21903 (char *) "x",(char *) "y", NULL
21904 };
21905
21906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21907 if (obj0) {
21908 ecode1 = SWIG_AsVal_int(obj0, &val1);
21909 if (!SWIG_IsOK(ecode1)) {
21910 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21911 }
21912 arg1 = static_cast< int >(val1);
21913 }
21914 if (obj1) {
21915 ecode2 = SWIG_AsVal_int(obj1, &val2);
21916 if (!SWIG_IsOK(ecode2)) {
21917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21918 }
21919 arg2 = static_cast< int >(val2);
21920 }
21921 {
21922 PyThreadState* __tstate = wxPyBeginAllowThreads();
21923 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21924 wxPyEndAllowThreads(__tstate);
21925 if (PyErr_Occurred()) SWIG_fail;
21926 }
21927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21928 return resultobj;
21929 fail:
21930 return NULL;
21931 }
21932
21933
21934 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21935 PyObject *resultobj = 0;
21936 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21937 int result;
21938 void *argp1 = 0 ;
21939 int res1 = 0 ;
21940 PyObject *swig_obj[1] ;
21941
21942 if (!args) SWIG_fail;
21943 swig_obj[0] = args;
21944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21945 if (!SWIG_IsOK(res1)) {
21946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21947 }
21948 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21949 {
21950 PyThreadState* __tstate = wxPyBeginAllowThreads();
21951 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 resultobj = SWIG_From_int(static_cast< int >(result));
21956 return resultobj;
21957 fail:
21958 return NULL;
21959 }
21960
21961
21962 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21963 PyObject *resultobj = 0;
21964 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21965 int result;
21966 void *argp1 = 0 ;
21967 int res1 = 0 ;
21968 PyObject *swig_obj[1] ;
21969
21970 if (!args) SWIG_fail;
21971 swig_obj[0] = args;
21972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21973 if (!SWIG_IsOK(res1)) {
21974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21975 }
21976 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21977 {
21978 PyThreadState* __tstate = wxPyBeginAllowThreads();
21979 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21980 wxPyEndAllowThreads(__tstate);
21981 if (PyErr_Occurred()) SWIG_fail;
21982 }
21983 resultobj = SWIG_From_int(static_cast< int >(result));
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21991 PyObject *resultobj = 0;
21992 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21993 wxCursor *arg2 = 0 ;
21994 void *argp1 = 0 ;
21995 int res1 = 0 ;
21996 void *argp2 = 0 ;
21997 int res2 = 0 ;
21998 PyObject * obj0 = 0 ;
21999 PyObject * obj1 = 0 ;
22000 char * kwnames[] = {
22001 (char *) "self",(char *) "cursor", NULL
22002 };
22003
22004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22006 if (!SWIG_IsOK(res1)) {
22007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22008 }
22009 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22010 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22011 if (!SWIG_IsOK(res2)) {
22012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22013 }
22014 if (!argp2) {
22015 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22016 }
22017 arg2 = reinterpret_cast< wxCursor * >(argp2);
22018 {
22019 PyThreadState* __tstate = wxPyBeginAllowThreads();
22020 (arg1)->SetCursor((wxCursor const &)*arg2);
22021 wxPyEndAllowThreads(__tstate);
22022 if (PyErr_Occurred()) SWIG_fail;
22023 }
22024 resultobj = SWIG_Py_Void();
22025 return resultobj;
22026 fail:
22027 return NULL;
22028 }
22029
22030
22031 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22032 PyObject *resultobj = 0;
22033 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22034 wxCursor *result = 0 ;
22035 void *argp1 = 0 ;
22036 int res1 = 0 ;
22037 PyObject *swig_obj[1] ;
22038
22039 if (!args) SWIG_fail;
22040 swig_obj[0] = args;
22041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22042 if (!SWIG_IsOK(res1)) {
22043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22044 }
22045 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22046 {
22047 PyThreadState* __tstate = wxPyBeginAllowThreads();
22048 {
22049 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22050 result = (wxCursor *) &_result_ref;
22051 }
22052 wxPyEndAllowThreads(__tstate);
22053 if (PyErr_Occurred()) SWIG_fail;
22054 }
22055 {
22056 wxCursor* resultptr = new wxCursor(*result);
22057 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22058 }
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22066 PyObject *resultobj = 0;
22067 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22068 bool result;
22069 void *argp1 = 0 ;
22070 int res1 = 0 ;
22071 PyObject *swig_obj[1] ;
22072
22073 if (!args) SWIG_fail;
22074 swig_obj[0] = args;
22075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22076 if (!SWIG_IsOK(res1)) {
22077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22078 }
22079 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22080 {
22081 PyThreadState* __tstate = wxPyBeginAllowThreads();
22082 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
22086 {
22087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22088 }
22089 return resultobj;
22090 fail:
22091 return NULL;
22092 }
22093
22094
22095 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22096 PyObject *obj;
22097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22098 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22099 return SWIG_Py_Void();
22100 }
22101
22102 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22103 return SWIG_Python_InitShadowInstance(args);
22104 }
22105
22106 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22107 PyObject *resultobj = 0;
22108 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22109 wxKeyEvent *result = 0 ;
22110 int val1 ;
22111 int ecode1 = 0 ;
22112 PyObject * obj0 = 0 ;
22113 char * kwnames[] = {
22114 (char *) "eventType", NULL
22115 };
22116
22117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22118 if (obj0) {
22119 ecode1 = SWIG_AsVal_int(obj0, &val1);
22120 if (!SWIG_IsOK(ecode1)) {
22121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22122 }
22123 arg1 = static_cast< wxEventType >(val1);
22124 }
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22139 PyObject *resultobj = 0;
22140 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22141 int result;
22142 void *argp1 = 0 ;
22143 int res1 = 0 ;
22144 PyObject *swig_obj[1] ;
22145
22146 if (!args) SWIG_fail;
22147 swig_obj[0] = args;
22148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22149 if (!SWIG_IsOK(res1)) {
22150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22151 }
22152 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 resultobj = SWIG_From_int(static_cast< int >(result));
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22167 PyObject *resultobj = 0;
22168 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22169 bool result;
22170 void *argp1 = 0 ;
22171 int res1 = 0 ;
22172 PyObject *swig_obj[1] ;
22173
22174 if (!args) SWIG_fail;
22175 swig_obj[0] = args;
22176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22177 if (!SWIG_IsOK(res1)) {
22178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22179 }
22180 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22181 {
22182 PyThreadState* __tstate = wxPyBeginAllowThreads();
22183 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22184 wxPyEndAllowThreads(__tstate);
22185 if (PyErr_Occurred()) SWIG_fail;
22186 }
22187 {
22188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22189 }
22190 return resultobj;
22191 fail:
22192 return NULL;
22193 }
22194
22195
22196 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22197 PyObject *resultobj = 0;
22198 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22199 bool result;
22200 void *argp1 = 0 ;
22201 int res1 = 0 ;
22202 PyObject *swig_obj[1] ;
22203
22204 if (!args) SWIG_fail;
22205 swig_obj[0] = args;
22206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22207 if (!SWIG_IsOK(res1)) {
22208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22209 }
22210 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 {
22218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22219 }
22220 return resultobj;
22221 fail:
22222 return NULL;
22223 }
22224
22225
22226 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22227 PyObject *resultobj = 0;
22228 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22229 bool result;
22230 void *argp1 = 0 ;
22231 int res1 = 0 ;
22232 PyObject *swig_obj[1] ;
22233
22234 if (!args) SWIG_fail;
22235 swig_obj[0] = args;
22236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22237 if (!SWIG_IsOK(res1)) {
22238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22239 }
22240 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22241 {
22242 PyThreadState* __tstate = wxPyBeginAllowThreads();
22243 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22244 wxPyEndAllowThreads(__tstate);
22245 if (PyErr_Occurred()) SWIG_fail;
22246 }
22247 {
22248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22249 }
22250 return resultobj;
22251 fail:
22252 return NULL;
22253 }
22254
22255
22256 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22257 PyObject *resultobj = 0;
22258 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22259 bool result;
22260 void *argp1 = 0 ;
22261 int res1 = 0 ;
22262 PyObject *swig_obj[1] ;
22263
22264 if (!args) SWIG_fail;
22265 swig_obj[0] = args;
22266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22267 if (!SWIG_IsOK(res1)) {
22268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22269 }
22270 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22271 {
22272 PyThreadState* __tstate = wxPyBeginAllowThreads();
22273 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22274 wxPyEndAllowThreads(__tstate);
22275 if (PyErr_Occurred()) SWIG_fail;
22276 }
22277 {
22278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22279 }
22280 return resultobj;
22281 fail:
22282 return NULL;
22283 }
22284
22285
22286 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22287 PyObject *resultobj = 0;
22288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22289 bool result;
22290 void *argp1 = 0 ;
22291 int res1 = 0 ;
22292 PyObject *swig_obj[1] ;
22293
22294 if (!args) SWIG_fail;
22295 swig_obj[0] = args;
22296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22297 if (!SWIG_IsOK(res1)) {
22298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22299 }
22300 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22301 {
22302 PyThreadState* __tstate = wxPyBeginAllowThreads();
22303 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 {
22308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22309 }
22310 return resultobj;
22311 fail:
22312 return NULL;
22313 }
22314
22315
22316 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22317 PyObject *resultobj = 0;
22318 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22319 bool result;
22320 void *argp1 = 0 ;
22321 int res1 = 0 ;
22322 PyObject *swig_obj[1] ;
22323
22324 if (!args) SWIG_fail;
22325 swig_obj[0] = args;
22326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22327 if (!SWIG_IsOK(res1)) {
22328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22329 }
22330 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22331 {
22332 PyThreadState* __tstate = wxPyBeginAllowThreads();
22333 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22334 wxPyEndAllowThreads(__tstate);
22335 if (PyErr_Occurred()) SWIG_fail;
22336 }
22337 {
22338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22339 }
22340 return resultobj;
22341 fail:
22342 return NULL;
22343 }
22344
22345
22346 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22347 PyObject *resultobj = 0;
22348 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22349 int result;
22350 void *argp1 = 0 ;
22351 int res1 = 0 ;
22352 PyObject *swig_obj[1] ;
22353
22354 if (!args) SWIG_fail;
22355 swig_obj[0] = args;
22356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22357 if (!SWIG_IsOK(res1)) {
22358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22359 }
22360 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22361 {
22362 PyThreadState* __tstate = wxPyBeginAllowThreads();
22363 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22364 wxPyEndAllowThreads(__tstate);
22365 if (PyErr_Occurred()) SWIG_fail;
22366 }
22367 resultobj = SWIG_From_int(static_cast< int >(result));
22368 return resultobj;
22369 fail:
22370 return NULL;
22371 }
22372
22373
22374 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22375 PyObject *resultobj = 0;
22376 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22377 int result;
22378 void *argp1 = 0 ;
22379 int res1 = 0 ;
22380 PyObject *swig_obj[1] ;
22381
22382 if (!args) SWIG_fail;
22383 swig_obj[0] = args;
22384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22385 if (!SWIG_IsOK(res1)) {
22386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22387 }
22388 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 resultobj = SWIG_From_int(static_cast< int >(result));
22396 return resultobj;
22397 fail:
22398 return NULL;
22399 }
22400
22401
22402 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22403 PyObject *resultobj = 0;
22404 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22405 int arg2 ;
22406 void *argp1 = 0 ;
22407 int res1 = 0 ;
22408 int val2 ;
22409 int ecode2 = 0 ;
22410 PyObject * obj0 = 0 ;
22411 PyObject * obj1 = 0 ;
22412 char * kwnames[] = {
22413 (char *) "self",(char *) "uniChar", NULL
22414 };
22415
22416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22418 if (!SWIG_IsOK(res1)) {
22419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22420 }
22421 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22422 ecode2 = SWIG_AsVal_int(obj1, &val2);
22423 if (!SWIG_IsOK(ecode2)) {
22424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22425 }
22426 arg2 = static_cast< int >(val2);
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 resultobj = SWIG_Py_Void();
22434 return resultobj;
22435 fail:
22436 return NULL;
22437 }
22438
22439
22440 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22441 PyObject *resultobj = 0;
22442 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22443 unsigned int result;
22444 void *argp1 = 0 ;
22445 int res1 = 0 ;
22446 PyObject *swig_obj[1] ;
22447
22448 if (!args) SWIG_fail;
22449 swig_obj[0] = args;
22450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22451 if (!SWIG_IsOK(res1)) {
22452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22453 }
22454 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22455 {
22456 PyThreadState* __tstate = wxPyBeginAllowThreads();
22457 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22458 wxPyEndAllowThreads(__tstate);
22459 if (PyErr_Occurred()) SWIG_fail;
22460 }
22461 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22462 return resultobj;
22463 fail:
22464 return NULL;
22465 }
22466
22467
22468 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22469 PyObject *resultobj = 0;
22470 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22471 unsigned int result;
22472 void *argp1 = 0 ;
22473 int res1 = 0 ;
22474 PyObject *swig_obj[1] ;
22475
22476 if (!args) SWIG_fail;
22477 swig_obj[0] = args;
22478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22479 if (!SWIG_IsOK(res1)) {
22480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22481 }
22482 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22483 {
22484 PyThreadState* __tstate = wxPyBeginAllowThreads();
22485 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22486 wxPyEndAllowThreads(__tstate);
22487 if (PyErr_Occurred()) SWIG_fail;
22488 }
22489 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22490 return resultobj;
22491 fail:
22492 return NULL;
22493 }
22494
22495
22496 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22497 PyObject *resultobj = 0;
22498 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22499 wxPoint result;
22500 void *argp1 = 0 ;
22501 int res1 = 0 ;
22502 PyObject *swig_obj[1] ;
22503
22504 if (!args) SWIG_fail;
22505 swig_obj[0] = args;
22506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22507 if (!SWIG_IsOK(res1)) {
22508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22509 }
22510 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22511 {
22512 PyThreadState* __tstate = wxPyBeginAllowThreads();
22513 result = (arg1)->GetPosition();
22514 wxPyEndAllowThreads(__tstate);
22515 if (PyErr_Occurred()) SWIG_fail;
22516 }
22517 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22525 PyObject *resultobj = 0;
22526 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22527 long *arg2 = (long *) 0 ;
22528 long *arg3 = (long *) 0 ;
22529 void *argp1 = 0 ;
22530 int res1 = 0 ;
22531 long temp2 ;
22532 int res2 = SWIG_TMPOBJ ;
22533 long temp3 ;
22534 int res3 = SWIG_TMPOBJ ;
22535 PyObject *swig_obj[1] ;
22536
22537 arg2 = &temp2;
22538 arg3 = &temp3;
22539 if (!args) SWIG_fail;
22540 swig_obj[0] = args;
22541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22542 if (!SWIG_IsOK(res1)) {
22543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22544 }
22545 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22546 {
22547 PyThreadState* __tstate = wxPyBeginAllowThreads();
22548 (arg1)->GetPosition(arg2,arg3);
22549 wxPyEndAllowThreads(__tstate);
22550 if (PyErr_Occurred()) SWIG_fail;
22551 }
22552 resultobj = SWIG_Py_Void();
22553 if (SWIG_IsTmpObj(res2)) {
22554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22555 } else {
22556 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22558 }
22559 if (SWIG_IsTmpObj(res3)) {
22560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22561 } else {
22562 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22564 }
22565 return resultobj;
22566 fail:
22567 return NULL;
22568 }
22569
22570
22571 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22572 PyObject *resultobj = 0;
22573 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22574 int result;
22575 void *argp1 = 0 ;
22576 int res1 = 0 ;
22577 PyObject *swig_obj[1] ;
22578
22579 if (!args) SWIG_fail;
22580 swig_obj[0] = args;
22581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22582 if (!SWIG_IsOK(res1)) {
22583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22584 }
22585 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22586 {
22587 PyThreadState* __tstate = wxPyBeginAllowThreads();
22588 result = (int)((wxKeyEvent const *)arg1)->GetX();
22589 wxPyEndAllowThreads(__tstate);
22590 if (PyErr_Occurred()) SWIG_fail;
22591 }
22592 resultobj = SWIG_From_int(static_cast< int >(result));
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22600 PyObject *resultobj = 0;
22601 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22602 int result;
22603 void *argp1 = 0 ;
22604 int res1 = 0 ;
22605 PyObject *swig_obj[1] ;
22606
22607 if (!args) SWIG_fail;
22608 swig_obj[0] = args;
22609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22610 if (!SWIG_IsOK(res1)) {
22611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22612 }
22613 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22614 {
22615 PyThreadState* __tstate = wxPyBeginAllowThreads();
22616 result = (int)((wxKeyEvent const *)arg1)->GetY();
22617 wxPyEndAllowThreads(__tstate);
22618 if (PyErr_Occurred()) SWIG_fail;
22619 }
22620 resultobj = SWIG_From_int(static_cast< int >(result));
22621 return resultobj;
22622 fail:
22623 return NULL;
22624 }
22625
22626
22627 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22628 PyObject *resultobj = 0;
22629 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22630 int arg2 ;
22631 void *argp1 = 0 ;
22632 int res1 = 0 ;
22633 int val2 ;
22634 int ecode2 = 0 ;
22635 PyObject *swig_obj[2] ;
22636
22637 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22639 if (!SWIG_IsOK(res1)) {
22640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22641 }
22642 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22643 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22644 if (!SWIG_IsOK(ecode2)) {
22645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22646 }
22647 arg2 = static_cast< int >(val2);
22648 if (arg1) (arg1)->m_x = arg2;
22649
22650 resultobj = SWIG_Py_Void();
22651 return resultobj;
22652 fail:
22653 return NULL;
22654 }
22655
22656
22657 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22658 PyObject *resultobj = 0;
22659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22660 int result;
22661 void *argp1 = 0 ;
22662 int res1 = 0 ;
22663 PyObject *swig_obj[1] ;
22664
22665 if (!args) SWIG_fail;
22666 swig_obj[0] = args;
22667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22668 if (!SWIG_IsOK(res1)) {
22669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22670 }
22671 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22672 result = (int) ((arg1)->m_x);
22673 resultobj = SWIG_From_int(static_cast< int >(result));
22674 return resultobj;
22675 fail:
22676 return NULL;
22677 }
22678
22679
22680 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22681 PyObject *resultobj = 0;
22682 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22683 int arg2 ;
22684 void *argp1 = 0 ;
22685 int res1 = 0 ;
22686 int val2 ;
22687 int ecode2 = 0 ;
22688 PyObject *swig_obj[2] ;
22689
22690 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22692 if (!SWIG_IsOK(res1)) {
22693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22694 }
22695 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22696 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22697 if (!SWIG_IsOK(ecode2)) {
22698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22699 }
22700 arg2 = static_cast< int >(val2);
22701 if (arg1) (arg1)->m_y = arg2;
22702
22703 resultobj = SWIG_Py_Void();
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22711 PyObject *resultobj = 0;
22712 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22713 int result;
22714 void *argp1 = 0 ;
22715 int res1 = 0 ;
22716 PyObject *swig_obj[1] ;
22717
22718 if (!args) SWIG_fail;
22719 swig_obj[0] = args;
22720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22721 if (!SWIG_IsOK(res1)) {
22722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22723 }
22724 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22725 result = (int) ((arg1)->m_y);
22726 resultobj = SWIG_From_int(static_cast< int >(result));
22727 return resultobj;
22728 fail:
22729 return NULL;
22730 }
22731
22732
22733 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22734 PyObject *resultobj = 0;
22735 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22736 long arg2 ;
22737 void *argp1 = 0 ;
22738 int res1 = 0 ;
22739 long val2 ;
22740 int ecode2 = 0 ;
22741 PyObject *swig_obj[2] ;
22742
22743 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22745 if (!SWIG_IsOK(res1)) {
22746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22747 }
22748 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22749 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22750 if (!SWIG_IsOK(ecode2)) {
22751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22752 }
22753 arg2 = static_cast< long >(val2);
22754 if (arg1) (arg1)->m_keyCode = arg2;
22755
22756 resultobj = SWIG_Py_Void();
22757 return resultobj;
22758 fail:
22759 return NULL;
22760 }
22761
22762
22763 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22764 PyObject *resultobj = 0;
22765 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22766 long result;
22767 void *argp1 = 0 ;
22768 int res1 = 0 ;
22769 PyObject *swig_obj[1] ;
22770
22771 if (!args) SWIG_fail;
22772 swig_obj[0] = args;
22773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22774 if (!SWIG_IsOK(res1)) {
22775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22776 }
22777 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22778 result = (long) ((arg1)->m_keyCode);
22779 resultobj = SWIG_From_long(static_cast< long >(result));
22780 return resultobj;
22781 fail:
22782 return NULL;
22783 }
22784
22785
22786 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22787 PyObject *resultobj = 0;
22788 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22789 bool arg2 ;
22790 void *argp1 = 0 ;
22791 int res1 = 0 ;
22792 bool val2 ;
22793 int ecode2 = 0 ;
22794 PyObject *swig_obj[2] ;
22795
22796 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22798 if (!SWIG_IsOK(res1)) {
22799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22800 }
22801 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22802 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22803 if (!SWIG_IsOK(ecode2)) {
22804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22805 }
22806 arg2 = static_cast< bool >(val2);
22807 if (arg1) (arg1)->m_controlDown = arg2;
22808
22809 resultobj = SWIG_Py_Void();
22810 return resultobj;
22811 fail:
22812 return NULL;
22813 }
22814
22815
22816 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22817 PyObject *resultobj = 0;
22818 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22819 bool result;
22820 void *argp1 = 0 ;
22821 int res1 = 0 ;
22822 PyObject *swig_obj[1] ;
22823
22824 if (!args) SWIG_fail;
22825 swig_obj[0] = args;
22826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22827 if (!SWIG_IsOK(res1)) {
22828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22829 }
22830 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22831 result = (bool) ((arg1)->m_controlDown);
22832 {
22833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22834 }
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22842 PyObject *resultobj = 0;
22843 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22844 bool arg2 ;
22845 void *argp1 = 0 ;
22846 int res1 = 0 ;
22847 bool val2 ;
22848 int ecode2 = 0 ;
22849 PyObject *swig_obj[2] ;
22850
22851 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22853 if (!SWIG_IsOK(res1)) {
22854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22855 }
22856 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22857 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22858 if (!SWIG_IsOK(ecode2)) {
22859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22860 }
22861 arg2 = static_cast< bool >(val2);
22862 if (arg1) (arg1)->m_shiftDown = arg2;
22863
22864 resultobj = SWIG_Py_Void();
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22872 PyObject *resultobj = 0;
22873 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22874 bool result;
22875 void *argp1 = 0 ;
22876 int res1 = 0 ;
22877 PyObject *swig_obj[1] ;
22878
22879 if (!args) SWIG_fail;
22880 swig_obj[0] = args;
22881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22882 if (!SWIG_IsOK(res1)) {
22883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22884 }
22885 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22886 result = (bool) ((arg1)->m_shiftDown);
22887 {
22888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22889 }
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22897 PyObject *resultobj = 0;
22898 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22899 bool arg2 ;
22900 void *argp1 = 0 ;
22901 int res1 = 0 ;
22902 bool val2 ;
22903 int ecode2 = 0 ;
22904 PyObject *swig_obj[2] ;
22905
22906 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22910 }
22911 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22912 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22913 if (!SWIG_IsOK(ecode2)) {
22914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22915 }
22916 arg2 = static_cast< bool >(val2);
22917 if (arg1) (arg1)->m_altDown = arg2;
22918
22919 resultobj = SWIG_Py_Void();
22920 return resultobj;
22921 fail:
22922 return NULL;
22923 }
22924
22925
22926 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22927 PyObject *resultobj = 0;
22928 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22929 bool result;
22930 void *argp1 = 0 ;
22931 int res1 = 0 ;
22932 PyObject *swig_obj[1] ;
22933
22934 if (!args) SWIG_fail;
22935 swig_obj[0] = args;
22936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22937 if (!SWIG_IsOK(res1)) {
22938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22939 }
22940 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22941 result = (bool) ((arg1)->m_altDown);
22942 {
22943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22944 }
22945 return resultobj;
22946 fail:
22947 return NULL;
22948 }
22949
22950
22951 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22952 PyObject *resultobj = 0;
22953 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22954 bool arg2 ;
22955 void *argp1 = 0 ;
22956 int res1 = 0 ;
22957 bool val2 ;
22958 int ecode2 = 0 ;
22959 PyObject *swig_obj[2] ;
22960
22961 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22963 if (!SWIG_IsOK(res1)) {
22964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22965 }
22966 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22967 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22968 if (!SWIG_IsOK(ecode2)) {
22969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22970 }
22971 arg2 = static_cast< bool >(val2);
22972 if (arg1) (arg1)->m_metaDown = arg2;
22973
22974 resultobj = SWIG_Py_Void();
22975 return resultobj;
22976 fail:
22977 return NULL;
22978 }
22979
22980
22981 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22982 PyObject *resultobj = 0;
22983 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22984 bool result;
22985 void *argp1 = 0 ;
22986 int res1 = 0 ;
22987 PyObject *swig_obj[1] ;
22988
22989 if (!args) SWIG_fail;
22990 swig_obj[0] = args;
22991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22992 if (!SWIG_IsOK(res1)) {
22993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22994 }
22995 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22996 result = (bool) ((arg1)->m_metaDown);
22997 {
22998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22999 }
23000 return resultobj;
23001 fail:
23002 return NULL;
23003 }
23004
23005
23006 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23007 PyObject *resultobj = 0;
23008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23009 bool arg2 ;
23010 void *argp1 = 0 ;
23011 int res1 = 0 ;
23012 bool val2 ;
23013 int ecode2 = 0 ;
23014 PyObject *swig_obj[2] ;
23015
23016 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23018 if (!SWIG_IsOK(res1)) {
23019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23020 }
23021 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23022 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23023 if (!SWIG_IsOK(ecode2)) {
23024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23025 }
23026 arg2 = static_cast< bool >(val2);
23027 if (arg1) (arg1)->m_scanCode = arg2;
23028
23029 resultobj = SWIG_Py_Void();
23030 return resultobj;
23031 fail:
23032 return NULL;
23033 }
23034
23035
23036 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23037 PyObject *resultobj = 0;
23038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23039 bool result;
23040 void *argp1 = 0 ;
23041 int res1 = 0 ;
23042 PyObject *swig_obj[1] ;
23043
23044 if (!args) SWIG_fail;
23045 swig_obj[0] = args;
23046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23047 if (!SWIG_IsOK(res1)) {
23048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23049 }
23050 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23051 result = (bool) ((arg1)->m_scanCode);
23052 {
23053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23054 }
23055 return resultobj;
23056 fail:
23057 return NULL;
23058 }
23059
23060
23061 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23062 PyObject *resultobj = 0;
23063 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23064 unsigned int arg2 ;
23065 void *argp1 = 0 ;
23066 int res1 = 0 ;
23067 unsigned int val2 ;
23068 int ecode2 = 0 ;
23069 PyObject *swig_obj[2] ;
23070
23071 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23073 if (!SWIG_IsOK(res1)) {
23074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23075 }
23076 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23077 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23078 if (!SWIG_IsOK(ecode2)) {
23079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23080 }
23081 arg2 = static_cast< unsigned int >(val2);
23082 if (arg1) (arg1)->m_rawCode = arg2;
23083
23084 resultobj = SWIG_Py_Void();
23085 return resultobj;
23086 fail:
23087 return NULL;
23088 }
23089
23090
23091 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23092 PyObject *resultobj = 0;
23093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23094 unsigned int result;
23095 void *argp1 = 0 ;
23096 int res1 = 0 ;
23097 PyObject *swig_obj[1] ;
23098
23099 if (!args) SWIG_fail;
23100 swig_obj[0] = args;
23101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23102 if (!SWIG_IsOK(res1)) {
23103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23104 }
23105 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23106 result = (unsigned int) ((arg1)->m_rawCode);
23107 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23108 return resultobj;
23109 fail:
23110 return NULL;
23111 }
23112
23113
23114 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23115 PyObject *resultobj = 0;
23116 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23117 unsigned int arg2 ;
23118 void *argp1 = 0 ;
23119 int res1 = 0 ;
23120 unsigned int val2 ;
23121 int ecode2 = 0 ;
23122 PyObject *swig_obj[2] ;
23123
23124 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23126 if (!SWIG_IsOK(res1)) {
23127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23128 }
23129 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23130 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23131 if (!SWIG_IsOK(ecode2)) {
23132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23133 }
23134 arg2 = static_cast< unsigned int >(val2);
23135 if (arg1) (arg1)->m_rawFlags = arg2;
23136
23137 resultobj = SWIG_Py_Void();
23138 return resultobj;
23139 fail:
23140 return NULL;
23141 }
23142
23143
23144 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23145 PyObject *resultobj = 0;
23146 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23147 unsigned int result;
23148 void *argp1 = 0 ;
23149 int res1 = 0 ;
23150 PyObject *swig_obj[1] ;
23151
23152 if (!args) SWIG_fail;
23153 swig_obj[0] = args;
23154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23155 if (!SWIG_IsOK(res1)) {
23156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23157 }
23158 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23159 result = (unsigned int) ((arg1)->m_rawFlags);
23160 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23168 PyObject *obj;
23169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23170 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23171 return SWIG_Py_Void();
23172 }
23173
23174 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23175 return SWIG_Python_InitShadowInstance(args);
23176 }
23177
23178 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23179 PyObject *resultobj = 0;
23180 wxSize const &arg1_defvalue = wxDefaultSize ;
23181 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23182 int arg2 = (int) 0 ;
23183 wxSizeEvent *result = 0 ;
23184 wxSize temp1 ;
23185 int val2 ;
23186 int ecode2 = 0 ;
23187 PyObject * obj0 = 0 ;
23188 PyObject * obj1 = 0 ;
23189 char * kwnames[] = {
23190 (char *) "sz",(char *) "winid", NULL
23191 };
23192
23193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23194 if (obj0) {
23195 {
23196 arg1 = &temp1;
23197 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23198 }
23199 }
23200 if (obj1) {
23201 ecode2 = SWIG_AsVal_int(obj1, &val2);
23202 if (!SWIG_IsOK(ecode2)) {
23203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23204 }
23205 arg2 = static_cast< int >(val2);
23206 }
23207 {
23208 PyThreadState* __tstate = wxPyBeginAllowThreads();
23209 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23221 PyObject *resultobj = 0;
23222 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23223 wxSize result;
23224 void *argp1 = 0 ;
23225 int res1 = 0 ;
23226 PyObject *swig_obj[1] ;
23227
23228 if (!args) SWIG_fail;
23229 swig_obj[0] = args;
23230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23231 if (!SWIG_IsOK(res1)) {
23232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23233 }
23234 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23235 {
23236 PyThreadState* __tstate = wxPyBeginAllowThreads();
23237 result = ((wxSizeEvent const *)arg1)->GetSize();
23238 wxPyEndAllowThreads(__tstate);
23239 if (PyErr_Occurred()) SWIG_fail;
23240 }
23241 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23242 return resultobj;
23243 fail:
23244 return NULL;
23245 }
23246
23247
23248 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23249 PyObject *resultobj = 0;
23250 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23251 wxRect result;
23252 void *argp1 = 0 ;
23253 int res1 = 0 ;
23254 PyObject *swig_obj[1] ;
23255
23256 if (!args) SWIG_fail;
23257 swig_obj[0] = args;
23258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23259 if (!SWIG_IsOK(res1)) {
23260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23261 }
23262 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23263 {
23264 PyThreadState* __tstate = wxPyBeginAllowThreads();
23265 result = ((wxSizeEvent const *)arg1)->GetRect();
23266 wxPyEndAllowThreads(__tstate);
23267 if (PyErr_Occurred()) SWIG_fail;
23268 }
23269 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23270 return resultobj;
23271 fail:
23272 return NULL;
23273 }
23274
23275
23276 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23277 PyObject *resultobj = 0;
23278 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23279 wxRect arg2 ;
23280 void *argp1 = 0 ;
23281 int res1 = 0 ;
23282 void *argp2 ;
23283 int res2 = 0 ;
23284 PyObject * obj0 = 0 ;
23285 PyObject * obj1 = 0 ;
23286 char * kwnames[] = {
23287 (char *) "self",(char *) "rect", NULL
23288 };
23289
23290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23292 if (!SWIG_IsOK(res1)) {
23293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23294 }
23295 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23296 {
23297 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23298 if (!SWIG_IsOK(res2)) {
23299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23300 }
23301 if (!argp2) {
23302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23303 } else {
23304 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23305 arg2 = *temp;
23306 if (SWIG_IsNewObj(res2)) delete temp;
23307 }
23308 }
23309 {
23310 PyThreadState* __tstate = wxPyBeginAllowThreads();
23311 (arg1)->SetRect(arg2);
23312 wxPyEndAllowThreads(__tstate);
23313 if (PyErr_Occurred()) SWIG_fail;
23314 }
23315 resultobj = SWIG_Py_Void();
23316 return resultobj;
23317 fail:
23318 return NULL;
23319 }
23320
23321
23322 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23323 PyObject *resultobj = 0;
23324 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23325 wxSize arg2 ;
23326 void *argp1 = 0 ;
23327 int res1 = 0 ;
23328 void *argp2 ;
23329 int res2 = 0 ;
23330 PyObject * obj0 = 0 ;
23331 PyObject * obj1 = 0 ;
23332 char * kwnames[] = {
23333 (char *) "self",(char *) "size", NULL
23334 };
23335
23336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23338 if (!SWIG_IsOK(res1)) {
23339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23340 }
23341 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23342 {
23343 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23344 if (!SWIG_IsOK(res2)) {
23345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23346 }
23347 if (!argp2) {
23348 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23349 } else {
23350 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23351 arg2 = *temp;
23352 if (SWIG_IsNewObj(res2)) delete temp;
23353 }
23354 }
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 wxSizeEvent_SetSize(arg1,arg2);
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 resultobj = SWIG_Py_Void();
23362 return resultobj;
23363 fail:
23364 return NULL;
23365 }
23366
23367
23368 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23369 PyObject *resultobj = 0;
23370 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23371 wxSize *arg2 = (wxSize *) 0 ;
23372 void *argp1 = 0 ;
23373 int res1 = 0 ;
23374 void *argp2 = 0 ;
23375 int res2 = 0 ;
23376 PyObject *swig_obj[2] ;
23377
23378 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23380 if (!SWIG_IsOK(res1)) {
23381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23382 }
23383 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23384 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23385 if (!SWIG_IsOK(res2)) {
23386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23387 }
23388 arg2 = reinterpret_cast< wxSize * >(argp2);
23389 if (arg1) (arg1)->m_size = *arg2;
23390
23391 resultobj = SWIG_Py_Void();
23392 return resultobj;
23393 fail:
23394 return NULL;
23395 }
23396
23397
23398 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23399 PyObject *resultobj = 0;
23400 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23401 wxSize *result = 0 ;
23402 void *argp1 = 0 ;
23403 int res1 = 0 ;
23404 PyObject *swig_obj[1] ;
23405
23406 if (!args) SWIG_fail;
23407 swig_obj[0] = args;
23408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23409 if (!SWIG_IsOK(res1)) {
23410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23411 }
23412 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23413 result = (wxSize *)& ((arg1)->m_size);
23414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23415 return resultobj;
23416 fail:
23417 return NULL;
23418 }
23419
23420
23421 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23422 PyObject *resultobj = 0;
23423 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23424 wxRect *arg2 = (wxRect *) 0 ;
23425 void *argp1 = 0 ;
23426 int res1 = 0 ;
23427 void *argp2 = 0 ;
23428 int res2 = 0 ;
23429 PyObject *swig_obj[2] ;
23430
23431 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23433 if (!SWIG_IsOK(res1)) {
23434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23435 }
23436 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23437 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23438 if (!SWIG_IsOK(res2)) {
23439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23440 }
23441 arg2 = reinterpret_cast< wxRect * >(argp2);
23442 if (arg1) (arg1)->m_rect = *arg2;
23443
23444 resultobj = SWIG_Py_Void();
23445 return resultobj;
23446 fail:
23447 return NULL;
23448 }
23449
23450
23451 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23452 PyObject *resultobj = 0;
23453 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23454 wxRect *result = 0 ;
23455 void *argp1 = 0 ;
23456 int res1 = 0 ;
23457 PyObject *swig_obj[1] ;
23458
23459 if (!args) SWIG_fail;
23460 swig_obj[0] = args;
23461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23462 if (!SWIG_IsOK(res1)) {
23463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23464 }
23465 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23466 result = (wxRect *)& ((arg1)->m_rect);
23467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23468 return resultobj;
23469 fail:
23470 return NULL;
23471 }
23472
23473
23474 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23475 PyObject *obj;
23476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23477 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23478 return SWIG_Py_Void();
23479 }
23480
23481 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23482 return SWIG_Python_InitShadowInstance(args);
23483 }
23484
23485 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj = 0;
23487 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23488 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23489 int arg2 = (int) 0 ;
23490 wxMoveEvent *result = 0 ;
23491 wxPoint temp1 ;
23492 int val2 ;
23493 int ecode2 = 0 ;
23494 PyObject * obj0 = 0 ;
23495 PyObject * obj1 = 0 ;
23496 char * kwnames[] = {
23497 (char *) "pos",(char *) "winid", NULL
23498 };
23499
23500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23501 if (obj0) {
23502 {
23503 arg1 = &temp1;
23504 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23505 }
23506 }
23507 if (obj1) {
23508 ecode2 = SWIG_AsVal_int(obj1, &val2);
23509 if (!SWIG_IsOK(ecode2)) {
23510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23511 }
23512 arg2 = static_cast< int >(val2);
23513 }
23514 {
23515 PyThreadState* __tstate = wxPyBeginAllowThreads();
23516 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23517 wxPyEndAllowThreads(__tstate);
23518 if (PyErr_Occurred()) SWIG_fail;
23519 }
23520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23528 PyObject *resultobj = 0;
23529 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23530 wxPoint result;
23531 void *argp1 = 0 ;
23532 int res1 = 0 ;
23533 PyObject *swig_obj[1] ;
23534
23535 if (!args) SWIG_fail;
23536 swig_obj[0] = args;
23537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23538 if (!SWIG_IsOK(res1)) {
23539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23540 }
23541 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 result = ((wxMoveEvent const *)arg1)->GetPosition();
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23549 return resultobj;
23550 fail:
23551 return NULL;
23552 }
23553
23554
23555 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23556 PyObject *resultobj = 0;
23557 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23558 wxRect result;
23559 void *argp1 = 0 ;
23560 int res1 = 0 ;
23561 PyObject *swig_obj[1] ;
23562
23563 if (!args) SWIG_fail;
23564 swig_obj[0] = args;
23565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23566 if (!SWIG_IsOK(res1)) {
23567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23568 }
23569 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23570 {
23571 PyThreadState* __tstate = wxPyBeginAllowThreads();
23572 result = ((wxMoveEvent const *)arg1)->GetRect();
23573 wxPyEndAllowThreads(__tstate);
23574 if (PyErr_Occurred()) SWIG_fail;
23575 }
23576 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23584 PyObject *resultobj = 0;
23585 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23586 wxRect *arg2 = 0 ;
23587 void *argp1 = 0 ;
23588 int res1 = 0 ;
23589 wxRect temp2 ;
23590 PyObject * obj0 = 0 ;
23591 PyObject * obj1 = 0 ;
23592 char * kwnames[] = {
23593 (char *) "self",(char *) "rect", NULL
23594 };
23595
23596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23598 if (!SWIG_IsOK(res1)) {
23599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23600 }
23601 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23602 {
23603 arg2 = &temp2;
23604 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23605 }
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 (arg1)->SetRect((wxRect const &)*arg2);
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 resultobj = SWIG_Py_Void();
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23620 PyObject *resultobj = 0;
23621 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23622 wxPoint *arg2 = 0 ;
23623 void *argp1 = 0 ;
23624 int res1 = 0 ;
23625 wxPoint temp2 ;
23626 PyObject * obj0 = 0 ;
23627 PyObject * obj1 = 0 ;
23628 char * kwnames[] = {
23629 (char *) "self",(char *) "pos", NULL
23630 };
23631
23632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23634 if (!SWIG_IsOK(res1)) {
23635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23636 }
23637 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23638 {
23639 arg2 = &temp2;
23640 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23641 }
23642 {
23643 PyThreadState* __tstate = wxPyBeginAllowThreads();
23644 (arg1)->SetPosition((wxPoint const &)*arg2);
23645 wxPyEndAllowThreads(__tstate);
23646 if (PyErr_Occurred()) SWIG_fail;
23647 }
23648 resultobj = SWIG_Py_Void();
23649 return resultobj;
23650 fail:
23651 return NULL;
23652 }
23653
23654
23655 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23656 PyObject *obj;
23657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23658 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23659 return SWIG_Py_Void();
23660 }
23661
23662 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23663 return SWIG_Python_InitShadowInstance(args);
23664 }
23665
23666 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23667 PyObject *resultobj = 0;
23668 int arg1 = (int) 0 ;
23669 wxPaintEvent *result = 0 ;
23670 int val1 ;
23671 int ecode1 = 0 ;
23672 PyObject * obj0 = 0 ;
23673 char * kwnames[] = {
23674 (char *) "Id", NULL
23675 };
23676
23677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23678 if (obj0) {
23679 ecode1 = SWIG_AsVal_int(obj0, &val1);
23680 if (!SWIG_IsOK(ecode1)) {
23681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23682 }
23683 arg1 = static_cast< int >(val1);
23684 }
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23688 wxPyEndAllowThreads(__tstate);
23689 if (PyErr_Occurred()) SWIG_fail;
23690 }
23691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23692 return resultobj;
23693 fail:
23694 return NULL;
23695 }
23696
23697
23698 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23699 PyObject *obj;
23700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23701 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23702 return SWIG_Py_Void();
23703 }
23704
23705 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23706 return SWIG_Python_InitShadowInstance(args);
23707 }
23708
23709 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23710 PyObject *resultobj = 0;
23711 int arg1 = (int) 0 ;
23712 wxNcPaintEvent *result = 0 ;
23713 int val1 ;
23714 int ecode1 = 0 ;
23715 PyObject * obj0 = 0 ;
23716 char * kwnames[] = {
23717 (char *) "winid", NULL
23718 };
23719
23720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23721 if (obj0) {
23722 ecode1 = SWIG_AsVal_int(obj0, &val1);
23723 if (!SWIG_IsOK(ecode1)) {
23724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23725 }
23726 arg1 = static_cast< int >(val1);
23727 }
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23742 PyObject *obj;
23743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23744 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23745 return SWIG_Py_Void();
23746 }
23747
23748 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23749 return SWIG_Python_InitShadowInstance(args);
23750 }
23751
23752 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23753 PyObject *resultobj = 0;
23754 int arg1 = (int) 0 ;
23755 wxDC *arg2 = (wxDC *) NULL ;
23756 wxEraseEvent *result = 0 ;
23757 int val1 ;
23758 int ecode1 = 0 ;
23759 void *argp2 = 0 ;
23760 int res2 = 0 ;
23761 PyObject * obj0 = 0 ;
23762 PyObject * obj1 = 0 ;
23763 char * kwnames[] = {
23764 (char *) "Id",(char *) "dc", NULL
23765 };
23766
23767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23768 if (obj0) {
23769 ecode1 = SWIG_AsVal_int(obj0, &val1);
23770 if (!SWIG_IsOK(ecode1)) {
23771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23772 }
23773 arg1 = static_cast< int >(val1);
23774 }
23775 if (obj1) {
23776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23777 if (!SWIG_IsOK(res2)) {
23778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23779 }
23780 arg2 = reinterpret_cast< wxDC * >(argp2);
23781 }
23782 {
23783 PyThreadState* __tstate = wxPyBeginAllowThreads();
23784 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23796 PyObject *resultobj = 0;
23797 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23798 wxDC *result = 0 ;
23799 void *argp1 = 0 ;
23800 int res1 = 0 ;
23801 PyObject *swig_obj[1] ;
23802
23803 if (!args) SWIG_fail;
23804 swig_obj[0] = args;
23805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23806 if (!SWIG_IsOK(res1)) {
23807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23808 }
23809 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23810 {
23811 PyThreadState* __tstate = wxPyBeginAllowThreads();
23812 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 {
23817 resultobj = wxPyMake_wxObject(result, (bool)0);
23818 }
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 PyObject *obj;
23827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23828 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23829 return SWIG_Py_Void();
23830 }
23831
23832 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23833 return SWIG_Python_InitShadowInstance(args);
23834 }
23835
23836 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj = 0;
23838 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23839 int arg2 = (int) 0 ;
23840 wxFocusEvent *result = 0 ;
23841 int val1 ;
23842 int ecode1 = 0 ;
23843 int val2 ;
23844 int ecode2 = 0 ;
23845 PyObject * obj0 = 0 ;
23846 PyObject * obj1 = 0 ;
23847 char * kwnames[] = {
23848 (char *) "type",(char *) "winid", NULL
23849 };
23850
23851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23852 if (obj0) {
23853 ecode1 = SWIG_AsVal_int(obj0, &val1);
23854 if (!SWIG_IsOK(ecode1)) {
23855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23856 }
23857 arg1 = static_cast< wxEventType >(val1);
23858 }
23859 if (obj1) {
23860 ecode2 = SWIG_AsVal_int(obj1, &val2);
23861 if (!SWIG_IsOK(ecode2)) {
23862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23863 }
23864 arg2 = static_cast< int >(val2);
23865 }
23866 {
23867 PyThreadState* __tstate = wxPyBeginAllowThreads();
23868 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23873 return resultobj;
23874 fail:
23875 return NULL;
23876 }
23877
23878
23879 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23880 PyObject *resultobj = 0;
23881 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23882 wxWindow *result = 0 ;
23883 void *argp1 = 0 ;
23884 int res1 = 0 ;
23885 PyObject *swig_obj[1] ;
23886
23887 if (!args) SWIG_fail;
23888 swig_obj[0] = args;
23889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23890 if (!SWIG_IsOK(res1)) {
23891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23892 }
23893 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23894 {
23895 PyThreadState* __tstate = wxPyBeginAllowThreads();
23896 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23897 wxPyEndAllowThreads(__tstate);
23898 if (PyErr_Occurred()) SWIG_fail;
23899 }
23900 {
23901 resultobj = wxPyMake_wxObject(result, (bool)0);
23902 }
23903 return resultobj;
23904 fail:
23905 return NULL;
23906 }
23907
23908
23909 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23910 PyObject *resultobj = 0;
23911 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23912 wxWindow *arg2 = (wxWindow *) 0 ;
23913 void *argp1 = 0 ;
23914 int res1 = 0 ;
23915 void *argp2 = 0 ;
23916 int res2 = 0 ;
23917 PyObject * obj0 = 0 ;
23918 PyObject * obj1 = 0 ;
23919 char * kwnames[] = {
23920 (char *) "self",(char *) "win", NULL
23921 };
23922
23923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23925 if (!SWIG_IsOK(res1)) {
23926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23927 }
23928 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23929 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23930 if (!SWIG_IsOK(res2)) {
23931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23932 }
23933 arg2 = reinterpret_cast< wxWindow * >(argp2);
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 (arg1)->SetWindow(arg2);
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 resultobj = SWIG_Py_Void();
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948 PyObject *obj;
23949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23950 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23951 return SWIG_Py_Void();
23952 }
23953
23954 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23955 return SWIG_Python_InitShadowInstance(args);
23956 }
23957
23958 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23959 PyObject *resultobj = 0;
23960 wxWindow *arg1 = (wxWindow *) NULL ;
23961 wxChildFocusEvent *result = 0 ;
23962 void *argp1 = 0 ;
23963 int res1 = 0 ;
23964 PyObject * obj0 = 0 ;
23965 char * kwnames[] = {
23966 (char *) "win", NULL
23967 };
23968
23969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23970 if (obj0) {
23971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23972 if (!SWIG_IsOK(res1)) {
23973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23974 }
23975 arg1 = reinterpret_cast< wxWindow * >(argp1);
23976 }
23977 {
23978 PyThreadState* __tstate = wxPyBeginAllowThreads();
23979 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23980 wxPyEndAllowThreads(__tstate);
23981 if (PyErr_Occurred()) SWIG_fail;
23982 }
23983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23984 return resultobj;
23985 fail:
23986 return NULL;
23987 }
23988
23989
23990 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23991 PyObject *resultobj = 0;
23992 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23993 wxWindow *result = 0 ;
23994 void *argp1 = 0 ;
23995 int res1 = 0 ;
23996 PyObject *swig_obj[1] ;
23997
23998 if (!args) SWIG_fail;
23999 swig_obj[0] = args;
24000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24001 if (!SWIG_IsOK(res1)) {
24002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24003 }
24004 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24005 {
24006 PyThreadState* __tstate = wxPyBeginAllowThreads();
24007 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24008 wxPyEndAllowThreads(__tstate);
24009 if (PyErr_Occurred()) SWIG_fail;
24010 }
24011 {
24012 resultobj = wxPyMake_wxObject(result, (bool)0);
24013 }
24014 return resultobj;
24015 fail:
24016 return NULL;
24017 }
24018
24019
24020 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24021 PyObject *obj;
24022 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24023 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24024 return SWIG_Py_Void();
24025 }
24026
24027 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24028 return SWIG_Python_InitShadowInstance(args);
24029 }
24030
24031 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24032 PyObject *resultobj = 0;
24033 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24034 bool arg2 = (bool) true ;
24035 int arg3 = (int) 0 ;
24036 wxActivateEvent *result = 0 ;
24037 int val1 ;
24038 int ecode1 = 0 ;
24039 bool val2 ;
24040 int ecode2 = 0 ;
24041 int val3 ;
24042 int ecode3 = 0 ;
24043 PyObject * obj0 = 0 ;
24044 PyObject * obj1 = 0 ;
24045 PyObject * obj2 = 0 ;
24046 char * kwnames[] = {
24047 (char *) "type",(char *) "active",(char *) "Id", NULL
24048 };
24049
24050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24051 if (obj0) {
24052 ecode1 = SWIG_AsVal_int(obj0, &val1);
24053 if (!SWIG_IsOK(ecode1)) {
24054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24055 }
24056 arg1 = static_cast< wxEventType >(val1);
24057 }
24058 if (obj1) {
24059 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24060 if (!SWIG_IsOK(ecode2)) {
24061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24062 }
24063 arg2 = static_cast< bool >(val2);
24064 }
24065 if (obj2) {
24066 ecode3 = SWIG_AsVal_int(obj2, &val3);
24067 if (!SWIG_IsOK(ecode3)) {
24068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24069 }
24070 arg3 = static_cast< int >(val3);
24071 }
24072 {
24073 PyThreadState* __tstate = wxPyBeginAllowThreads();
24074 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24079 return resultobj;
24080 fail:
24081 return NULL;
24082 }
24083
24084
24085 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24086 PyObject *resultobj = 0;
24087 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24088 bool result;
24089 void *argp1 = 0 ;
24090 int res1 = 0 ;
24091 PyObject *swig_obj[1] ;
24092
24093 if (!args) SWIG_fail;
24094 swig_obj[0] = args;
24095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24096 if (!SWIG_IsOK(res1)) {
24097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24098 }
24099 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 {
24107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24108 }
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 PyObject *obj;
24117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24118 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24119 return SWIG_Py_Void();
24120 }
24121
24122 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24123 return SWIG_Python_InitShadowInstance(args);
24124 }
24125
24126 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24127 PyObject *resultobj = 0;
24128 int arg1 = (int) 0 ;
24129 wxInitDialogEvent *result = 0 ;
24130 int val1 ;
24131 int ecode1 = 0 ;
24132 PyObject * obj0 = 0 ;
24133 char * kwnames[] = {
24134 (char *) "Id", NULL
24135 };
24136
24137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24138 if (obj0) {
24139 ecode1 = SWIG_AsVal_int(obj0, &val1);
24140 if (!SWIG_IsOK(ecode1)) {
24141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24142 }
24143 arg1 = static_cast< int >(val1);
24144 }
24145 {
24146 PyThreadState* __tstate = wxPyBeginAllowThreads();
24147 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24148 wxPyEndAllowThreads(__tstate);
24149 if (PyErr_Occurred()) SWIG_fail;
24150 }
24151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24152 return resultobj;
24153 fail:
24154 return NULL;
24155 }
24156
24157
24158 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24159 PyObject *obj;
24160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24161 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24162 return SWIG_Py_Void();
24163 }
24164
24165 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24166 return SWIG_Python_InitShadowInstance(args);
24167 }
24168
24169 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24170 PyObject *resultobj = 0;
24171 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24172 int arg2 = (int) 0 ;
24173 wxMenu *arg3 = (wxMenu *) NULL ;
24174 wxMenuEvent *result = 0 ;
24175 int val1 ;
24176 int ecode1 = 0 ;
24177 int val2 ;
24178 int ecode2 = 0 ;
24179 void *argp3 = 0 ;
24180 int res3 = 0 ;
24181 PyObject * obj0 = 0 ;
24182 PyObject * obj1 = 0 ;
24183 PyObject * obj2 = 0 ;
24184 char * kwnames[] = {
24185 (char *) "type",(char *) "winid",(char *) "menu", NULL
24186 };
24187
24188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24189 if (obj0) {
24190 ecode1 = SWIG_AsVal_int(obj0, &val1);
24191 if (!SWIG_IsOK(ecode1)) {
24192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24193 }
24194 arg1 = static_cast< wxEventType >(val1);
24195 }
24196 if (obj1) {
24197 ecode2 = SWIG_AsVal_int(obj1, &val2);
24198 if (!SWIG_IsOK(ecode2)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24200 }
24201 arg2 = static_cast< int >(val2);
24202 }
24203 if (obj2) {
24204 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24205 if (!SWIG_IsOK(res3)) {
24206 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24207 }
24208 arg3 = reinterpret_cast< wxMenu * >(argp3);
24209 }
24210 {
24211 PyThreadState* __tstate = wxPyBeginAllowThreads();
24212 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24213 wxPyEndAllowThreads(__tstate);
24214 if (PyErr_Occurred()) SWIG_fail;
24215 }
24216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24224 PyObject *resultobj = 0;
24225 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24226 int result;
24227 void *argp1 = 0 ;
24228 int res1 = 0 ;
24229 PyObject *swig_obj[1] ;
24230
24231 if (!args) SWIG_fail;
24232 swig_obj[0] = args;
24233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24234 if (!SWIG_IsOK(res1)) {
24235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24236 }
24237 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24238 {
24239 PyThreadState* __tstate = wxPyBeginAllowThreads();
24240 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24241 wxPyEndAllowThreads(__tstate);
24242 if (PyErr_Occurred()) SWIG_fail;
24243 }
24244 resultobj = SWIG_From_int(static_cast< int >(result));
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24252 PyObject *resultobj = 0;
24253 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24254 bool result;
24255 void *argp1 = 0 ;
24256 int res1 = 0 ;
24257 PyObject *swig_obj[1] ;
24258
24259 if (!args) SWIG_fail;
24260 swig_obj[0] = args;
24261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24262 if (!SWIG_IsOK(res1)) {
24263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24264 }
24265 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24266 {
24267 PyThreadState* __tstate = wxPyBeginAllowThreads();
24268 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24269 wxPyEndAllowThreads(__tstate);
24270 if (PyErr_Occurred()) SWIG_fail;
24271 }
24272 {
24273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24274 }
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *resultobj = 0;
24283 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24284 wxMenu *result = 0 ;
24285 void *argp1 = 0 ;
24286 int res1 = 0 ;
24287 PyObject *swig_obj[1] ;
24288
24289 if (!args) SWIG_fail;
24290 swig_obj[0] = args;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24294 }
24295 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 {
24303 resultobj = wxPyMake_wxObject(result, (bool)0);
24304 }
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24312 PyObject *obj;
24313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24314 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24315 return SWIG_Py_Void();
24316 }
24317
24318 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24319 return SWIG_Python_InitShadowInstance(args);
24320 }
24321
24322 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24323 PyObject *resultobj = 0;
24324 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24325 int arg2 = (int) 0 ;
24326 wxCloseEvent *result = 0 ;
24327 int val1 ;
24328 int ecode1 = 0 ;
24329 int val2 ;
24330 int ecode2 = 0 ;
24331 PyObject * obj0 = 0 ;
24332 PyObject * obj1 = 0 ;
24333 char * kwnames[] = {
24334 (char *) "type",(char *) "winid", NULL
24335 };
24336
24337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24338 if (obj0) {
24339 ecode1 = SWIG_AsVal_int(obj0, &val1);
24340 if (!SWIG_IsOK(ecode1)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24342 }
24343 arg1 = static_cast< wxEventType >(val1);
24344 }
24345 if (obj1) {
24346 ecode2 = SWIG_AsVal_int(obj1, &val2);
24347 if (!SWIG_IsOK(ecode2)) {
24348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24349 }
24350 arg2 = static_cast< int >(val2);
24351 }
24352 {
24353 PyThreadState* __tstate = wxPyBeginAllowThreads();
24354 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24355 wxPyEndAllowThreads(__tstate);
24356 if (PyErr_Occurred()) SWIG_fail;
24357 }
24358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24366 PyObject *resultobj = 0;
24367 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24368 bool arg2 ;
24369 void *argp1 = 0 ;
24370 int res1 = 0 ;
24371 bool val2 ;
24372 int ecode2 = 0 ;
24373 PyObject * obj0 = 0 ;
24374 PyObject * obj1 = 0 ;
24375 char * kwnames[] = {
24376 (char *) "self",(char *) "logOff", NULL
24377 };
24378
24379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24381 if (!SWIG_IsOK(res1)) {
24382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24383 }
24384 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24385 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24386 if (!SWIG_IsOK(ecode2)) {
24387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24388 }
24389 arg2 = static_cast< bool >(val2);
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 (arg1)->SetLoggingOff(arg2);
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 resultobj = SWIG_Py_Void();
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24404 PyObject *resultobj = 0;
24405 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24406 bool result;
24407 void *argp1 = 0 ;
24408 int res1 = 0 ;
24409 PyObject *swig_obj[1] ;
24410
24411 if (!args) SWIG_fail;
24412 swig_obj[0] = args;
24413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24414 if (!SWIG_IsOK(res1)) {
24415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24416 }
24417 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24421 wxPyEndAllowThreads(__tstate);
24422 if (PyErr_Occurred()) SWIG_fail;
24423 }
24424 {
24425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24426 }
24427 return resultobj;
24428 fail:
24429 return NULL;
24430 }
24431
24432
24433 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24434 PyObject *resultobj = 0;
24435 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24436 bool arg2 = (bool) true ;
24437 void *argp1 = 0 ;
24438 int res1 = 0 ;
24439 bool val2 ;
24440 int ecode2 = 0 ;
24441 PyObject * obj0 = 0 ;
24442 PyObject * obj1 = 0 ;
24443 char * kwnames[] = {
24444 (char *) "self",(char *) "veto", NULL
24445 };
24446
24447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24449 if (!SWIG_IsOK(res1)) {
24450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24451 }
24452 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24453 if (obj1) {
24454 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24455 if (!SWIG_IsOK(ecode2)) {
24456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24457 }
24458 arg2 = static_cast< bool >(val2);
24459 }
24460 {
24461 PyThreadState* __tstate = wxPyBeginAllowThreads();
24462 (arg1)->Veto(arg2);
24463 wxPyEndAllowThreads(__tstate);
24464 if (PyErr_Occurred()) SWIG_fail;
24465 }
24466 resultobj = SWIG_Py_Void();
24467 return resultobj;
24468 fail:
24469 return NULL;
24470 }
24471
24472
24473 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24474 PyObject *resultobj = 0;
24475 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24476 bool result;
24477 void *argp1 = 0 ;
24478 int res1 = 0 ;
24479 PyObject *swig_obj[1] ;
24480
24481 if (!args) SWIG_fail;
24482 swig_obj[0] = args;
24483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24484 if (!SWIG_IsOK(res1)) {
24485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24486 }
24487 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24491 wxPyEndAllowThreads(__tstate);
24492 if (PyErr_Occurred()) SWIG_fail;
24493 }
24494 {
24495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24496 }
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24504 PyObject *resultobj = 0;
24505 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24506 bool arg2 ;
24507 void *argp1 = 0 ;
24508 int res1 = 0 ;
24509 bool val2 ;
24510 int ecode2 = 0 ;
24511 PyObject * obj0 = 0 ;
24512 PyObject * obj1 = 0 ;
24513 char * kwnames[] = {
24514 (char *) "self",(char *) "canVeto", NULL
24515 };
24516
24517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24519 if (!SWIG_IsOK(res1)) {
24520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24521 }
24522 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24523 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24524 if (!SWIG_IsOK(ecode2)) {
24525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24526 }
24527 arg2 = static_cast< bool >(val2);
24528 {
24529 PyThreadState* __tstate = wxPyBeginAllowThreads();
24530 (arg1)->SetCanVeto(arg2);
24531 wxPyEndAllowThreads(__tstate);
24532 if (PyErr_Occurred()) SWIG_fail;
24533 }
24534 resultobj = SWIG_Py_Void();
24535 return resultobj;
24536 fail:
24537 return NULL;
24538 }
24539
24540
24541 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24542 PyObject *resultobj = 0;
24543 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24544 bool result;
24545 void *argp1 = 0 ;
24546 int res1 = 0 ;
24547 PyObject *swig_obj[1] ;
24548
24549 if (!args) SWIG_fail;
24550 swig_obj[0] = args;
24551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24552 if (!SWIG_IsOK(res1)) {
24553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24554 }
24555 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24556 {
24557 PyThreadState* __tstate = wxPyBeginAllowThreads();
24558 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 {
24563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24564 }
24565 return resultobj;
24566 fail:
24567 return NULL;
24568 }
24569
24570
24571 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24572 PyObject *obj;
24573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24574 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24575 return SWIG_Py_Void();
24576 }
24577
24578 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24579 return SWIG_Python_InitShadowInstance(args);
24580 }
24581
24582 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24583 PyObject *resultobj = 0;
24584 int arg1 = (int) 0 ;
24585 bool arg2 = (bool) false ;
24586 wxShowEvent *result = 0 ;
24587 int val1 ;
24588 int ecode1 = 0 ;
24589 bool val2 ;
24590 int ecode2 = 0 ;
24591 PyObject * obj0 = 0 ;
24592 PyObject * obj1 = 0 ;
24593 char * kwnames[] = {
24594 (char *) "winid",(char *) "show", NULL
24595 };
24596
24597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24598 if (obj0) {
24599 ecode1 = SWIG_AsVal_int(obj0, &val1);
24600 if (!SWIG_IsOK(ecode1)) {
24601 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24602 }
24603 arg1 = static_cast< int >(val1);
24604 }
24605 if (obj1) {
24606 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24607 if (!SWIG_IsOK(ecode2)) {
24608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24609 }
24610 arg2 = static_cast< bool >(val2);
24611 }
24612 {
24613 PyThreadState* __tstate = wxPyBeginAllowThreads();
24614 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24615 wxPyEndAllowThreads(__tstate);
24616 if (PyErr_Occurred()) SWIG_fail;
24617 }
24618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24619 return resultobj;
24620 fail:
24621 return NULL;
24622 }
24623
24624
24625 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24626 PyObject *resultobj = 0;
24627 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24628 bool arg2 ;
24629 void *argp1 = 0 ;
24630 int res1 = 0 ;
24631 bool val2 ;
24632 int ecode2 = 0 ;
24633 PyObject * obj0 = 0 ;
24634 PyObject * obj1 = 0 ;
24635 char * kwnames[] = {
24636 (char *) "self",(char *) "show", NULL
24637 };
24638
24639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24641 if (!SWIG_IsOK(res1)) {
24642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24643 }
24644 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24645 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24646 if (!SWIG_IsOK(ecode2)) {
24647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24648 }
24649 arg2 = static_cast< bool >(val2);
24650 {
24651 PyThreadState* __tstate = wxPyBeginAllowThreads();
24652 (arg1)->SetShow(arg2);
24653 wxPyEndAllowThreads(__tstate);
24654 if (PyErr_Occurred()) SWIG_fail;
24655 }
24656 resultobj = SWIG_Py_Void();
24657 return resultobj;
24658 fail:
24659 return NULL;
24660 }
24661
24662
24663 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24664 PyObject *resultobj = 0;
24665 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24666 bool result;
24667 void *argp1 = 0 ;
24668 int res1 = 0 ;
24669 PyObject *swig_obj[1] ;
24670
24671 if (!args) SWIG_fail;
24672 swig_obj[0] = args;
24673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24674 if (!SWIG_IsOK(res1)) {
24675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24676 }
24677 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24678 {
24679 PyThreadState* __tstate = wxPyBeginAllowThreads();
24680 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24681 wxPyEndAllowThreads(__tstate);
24682 if (PyErr_Occurred()) SWIG_fail;
24683 }
24684 {
24685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24686 }
24687 return resultobj;
24688 fail:
24689 return NULL;
24690 }
24691
24692
24693 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24694 PyObject *obj;
24695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24696 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24697 return SWIG_Py_Void();
24698 }
24699
24700 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24701 return SWIG_Python_InitShadowInstance(args);
24702 }
24703
24704 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24705 PyObject *resultobj = 0;
24706 int arg1 = (int) 0 ;
24707 bool arg2 = (bool) true ;
24708 wxIconizeEvent *result = 0 ;
24709 int val1 ;
24710 int ecode1 = 0 ;
24711 bool val2 ;
24712 int ecode2 = 0 ;
24713 PyObject * obj0 = 0 ;
24714 PyObject * obj1 = 0 ;
24715 char * kwnames[] = {
24716 (char *) "id",(char *) "iconized", NULL
24717 };
24718
24719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24720 if (obj0) {
24721 ecode1 = SWIG_AsVal_int(obj0, &val1);
24722 if (!SWIG_IsOK(ecode1)) {
24723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24724 }
24725 arg1 = static_cast< int >(val1);
24726 }
24727 if (obj1) {
24728 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24729 if (!SWIG_IsOK(ecode2)) {
24730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24731 }
24732 arg2 = static_cast< bool >(val2);
24733 }
24734 {
24735 PyThreadState* __tstate = wxPyBeginAllowThreads();
24736 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24737 wxPyEndAllowThreads(__tstate);
24738 if (PyErr_Occurred()) SWIG_fail;
24739 }
24740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24748 PyObject *resultobj = 0;
24749 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24750 bool result;
24751 void *argp1 = 0 ;
24752 int res1 = 0 ;
24753 PyObject *swig_obj[1] ;
24754
24755 if (!args) SWIG_fail;
24756 swig_obj[0] = args;
24757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24758 if (!SWIG_IsOK(res1)) {
24759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24760 }
24761 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24762 {
24763 PyThreadState* __tstate = wxPyBeginAllowThreads();
24764 result = (bool)(arg1)->Iconized();
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 {
24769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24770 }
24771 return resultobj;
24772 fail:
24773 return NULL;
24774 }
24775
24776
24777 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24778 PyObject *obj;
24779 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24780 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24781 return SWIG_Py_Void();
24782 }
24783
24784 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24785 return SWIG_Python_InitShadowInstance(args);
24786 }
24787
24788 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj = 0;
24790 int arg1 = (int) 0 ;
24791 wxMaximizeEvent *result = 0 ;
24792 int val1 ;
24793 int ecode1 = 0 ;
24794 PyObject * obj0 = 0 ;
24795 char * kwnames[] = {
24796 (char *) "id", NULL
24797 };
24798
24799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24800 if (obj0) {
24801 ecode1 = SWIG_AsVal_int(obj0, &val1);
24802 if (!SWIG_IsOK(ecode1)) {
24803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24804 }
24805 arg1 = static_cast< int >(val1);
24806 }
24807 {
24808 PyThreadState* __tstate = wxPyBeginAllowThreads();
24809 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24810 wxPyEndAllowThreads(__tstate);
24811 if (PyErr_Occurred()) SWIG_fail;
24812 }
24813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24821 PyObject *obj;
24822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24823 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24824 return SWIG_Py_Void();
24825 }
24826
24827 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24828 return SWIG_Python_InitShadowInstance(args);
24829 }
24830
24831 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24832 PyObject *resultobj = 0;
24833 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24834 wxPoint result;
24835 void *argp1 = 0 ;
24836 int res1 = 0 ;
24837 PyObject *swig_obj[1] ;
24838
24839 if (!args) SWIG_fail;
24840 swig_obj[0] = args;
24841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24842 if (!SWIG_IsOK(res1)) {
24843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24844 }
24845 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24846 {
24847 PyThreadState* __tstate = wxPyBeginAllowThreads();
24848 result = (arg1)->GetPosition();
24849 wxPyEndAllowThreads(__tstate);
24850 if (PyErr_Occurred()) SWIG_fail;
24851 }
24852 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24853 return resultobj;
24854 fail:
24855 return NULL;
24856 }
24857
24858
24859 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24860 PyObject *resultobj = 0;
24861 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24862 int result;
24863 void *argp1 = 0 ;
24864 int res1 = 0 ;
24865 PyObject *swig_obj[1] ;
24866
24867 if (!args) SWIG_fail;
24868 swig_obj[0] = args;
24869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24870 if (!SWIG_IsOK(res1)) {
24871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24872 }
24873 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24874 {
24875 PyThreadState* __tstate = wxPyBeginAllowThreads();
24876 result = (int)(arg1)->GetNumberOfFiles();
24877 wxPyEndAllowThreads(__tstate);
24878 if (PyErr_Occurred()) SWIG_fail;
24879 }
24880 resultobj = SWIG_From_int(static_cast< int >(result));
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24888 PyObject *resultobj = 0;
24889 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24890 PyObject *result = 0 ;
24891 void *argp1 = 0 ;
24892 int res1 = 0 ;
24893 PyObject *swig_obj[1] ;
24894
24895 if (!args) SWIG_fail;
24896 swig_obj[0] = args;
24897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24898 if (!SWIG_IsOK(res1)) {
24899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24900 }
24901 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24902 {
24903 PyThreadState* __tstate = wxPyBeginAllowThreads();
24904 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24905 wxPyEndAllowThreads(__tstate);
24906 if (PyErr_Occurred()) SWIG_fail;
24907 }
24908 resultobj = result;
24909 return resultobj;
24910 fail:
24911 return NULL;
24912 }
24913
24914
24915 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24916 PyObject *obj;
24917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24918 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24919 return SWIG_Py_Void();
24920 }
24921
24922 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24923 PyObject *resultobj = 0;
24924 int arg1 = (int) 0 ;
24925 wxUpdateUIEvent *result = 0 ;
24926 int val1 ;
24927 int ecode1 = 0 ;
24928 PyObject * obj0 = 0 ;
24929 char * kwnames[] = {
24930 (char *) "commandId", NULL
24931 };
24932
24933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24934 if (obj0) {
24935 ecode1 = SWIG_AsVal_int(obj0, &val1);
24936 if (!SWIG_IsOK(ecode1)) {
24937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24938 }
24939 arg1 = static_cast< int >(val1);
24940 }
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24944 wxPyEndAllowThreads(__tstate);
24945 if (PyErr_Occurred()) SWIG_fail;
24946 }
24947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24948 return resultobj;
24949 fail:
24950 return NULL;
24951 }
24952
24953
24954 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24955 PyObject *resultobj = 0;
24956 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24957 bool result;
24958 void *argp1 = 0 ;
24959 int res1 = 0 ;
24960 PyObject *swig_obj[1] ;
24961
24962 if (!args) SWIG_fail;
24963 swig_obj[0] = args;
24964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24965 if (!SWIG_IsOK(res1)) {
24966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24967 }
24968 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 {
24976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24977 }
24978 return resultobj;
24979 fail:
24980 return NULL;
24981 }
24982
24983
24984 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24985 PyObject *resultobj = 0;
24986 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24987 bool result;
24988 void *argp1 = 0 ;
24989 int res1 = 0 ;
24990 PyObject *swig_obj[1] ;
24991
24992 if (!args) SWIG_fail;
24993 swig_obj[0] = args;
24994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24995 if (!SWIG_IsOK(res1)) {
24996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24997 }
24998 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24999 {
25000 PyThreadState* __tstate = wxPyBeginAllowThreads();
25001 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25002 wxPyEndAllowThreads(__tstate);
25003 if (PyErr_Occurred()) SWIG_fail;
25004 }
25005 {
25006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25007 }
25008 return resultobj;
25009 fail:
25010 return NULL;
25011 }
25012
25013
25014 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25015 PyObject *resultobj = 0;
25016 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25017 bool result;
25018 void *argp1 = 0 ;
25019 int res1 = 0 ;
25020 PyObject *swig_obj[1] ;
25021
25022 if (!args) SWIG_fail;
25023 swig_obj[0] = args;
25024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25025 if (!SWIG_IsOK(res1)) {
25026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25027 }
25028 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25029 {
25030 PyThreadState* __tstate = wxPyBeginAllowThreads();
25031 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25032 wxPyEndAllowThreads(__tstate);
25033 if (PyErr_Occurred()) SWIG_fail;
25034 }
25035 {
25036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25037 }
25038 return resultobj;
25039 fail:
25040 return NULL;
25041 }
25042
25043
25044 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25045 PyObject *resultobj = 0;
25046 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25047 wxString result;
25048 void *argp1 = 0 ;
25049 int res1 = 0 ;
25050 PyObject *swig_obj[1] ;
25051
25052 if (!args) SWIG_fail;
25053 swig_obj[0] = args;
25054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25055 if (!SWIG_IsOK(res1)) {
25056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25057 }
25058 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 {
25066 #if wxUSE_UNICODE
25067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25068 #else
25069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25070 #endif
25071 }
25072 return resultobj;
25073 fail:
25074 return NULL;
25075 }
25076
25077
25078 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25079 PyObject *resultobj = 0;
25080 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25081 bool result;
25082 void *argp1 = 0 ;
25083 int res1 = 0 ;
25084 PyObject *swig_obj[1] ;
25085
25086 if (!args) SWIG_fail;
25087 swig_obj[0] = args;
25088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25089 if (!SWIG_IsOK(res1)) {
25090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25091 }
25092 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25096 wxPyEndAllowThreads(__tstate);
25097 if (PyErr_Occurred()) SWIG_fail;
25098 }
25099 {
25100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25101 }
25102 return resultobj;
25103 fail:
25104 return NULL;
25105 }
25106
25107
25108 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25109 PyObject *resultobj = 0;
25110 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25111 bool result;
25112 void *argp1 = 0 ;
25113 int res1 = 0 ;
25114 PyObject *swig_obj[1] ;
25115
25116 if (!args) SWIG_fail;
25117 swig_obj[0] = args;
25118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25119 if (!SWIG_IsOK(res1)) {
25120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25121 }
25122 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25126 wxPyEndAllowThreads(__tstate);
25127 if (PyErr_Occurred()) SWIG_fail;
25128 }
25129 {
25130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25131 }
25132 return resultobj;
25133 fail:
25134 return NULL;
25135 }
25136
25137
25138 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25139 PyObject *resultobj = 0;
25140 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25141 bool result;
25142 void *argp1 = 0 ;
25143 int res1 = 0 ;
25144 PyObject *swig_obj[1] ;
25145
25146 if (!args) SWIG_fail;
25147 swig_obj[0] = args;
25148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25149 if (!SWIG_IsOK(res1)) {
25150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25151 }
25152 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25153 {
25154 PyThreadState* __tstate = wxPyBeginAllowThreads();
25155 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 {
25160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25161 }
25162 return resultobj;
25163 fail:
25164 return NULL;
25165 }
25166
25167
25168 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25169 PyObject *resultobj = 0;
25170 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25171 bool result;
25172 void *argp1 = 0 ;
25173 int res1 = 0 ;
25174 PyObject *swig_obj[1] ;
25175
25176 if (!args) SWIG_fail;
25177 swig_obj[0] = args;
25178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25179 if (!SWIG_IsOK(res1)) {
25180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25181 }
25182 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25183 {
25184 PyThreadState* __tstate = wxPyBeginAllowThreads();
25185 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 {
25190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25191 }
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj = 0;
25200 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25201 bool arg2 ;
25202 void *argp1 = 0 ;
25203 int res1 = 0 ;
25204 bool val2 ;
25205 int ecode2 = 0 ;
25206 PyObject * obj0 = 0 ;
25207 PyObject * obj1 = 0 ;
25208 char * kwnames[] = {
25209 (char *) "self",(char *) "check", NULL
25210 };
25211
25212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25214 if (!SWIG_IsOK(res1)) {
25215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25216 }
25217 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25218 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25219 if (!SWIG_IsOK(ecode2)) {
25220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25221 }
25222 arg2 = static_cast< bool >(val2);
25223 {
25224 PyThreadState* __tstate = wxPyBeginAllowThreads();
25225 (arg1)->Check(arg2);
25226 wxPyEndAllowThreads(__tstate);
25227 if (PyErr_Occurred()) SWIG_fail;
25228 }
25229 resultobj = SWIG_Py_Void();
25230 return resultobj;
25231 fail:
25232 return NULL;
25233 }
25234
25235
25236 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25237 PyObject *resultobj = 0;
25238 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25239 bool arg2 ;
25240 void *argp1 = 0 ;
25241 int res1 = 0 ;
25242 bool val2 ;
25243 int ecode2 = 0 ;
25244 PyObject * obj0 = 0 ;
25245 PyObject * obj1 = 0 ;
25246 char * kwnames[] = {
25247 (char *) "self",(char *) "enable", NULL
25248 };
25249
25250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25252 if (!SWIG_IsOK(res1)) {
25253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25254 }
25255 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25256 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25257 if (!SWIG_IsOK(ecode2)) {
25258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25259 }
25260 arg2 = static_cast< bool >(val2);
25261 {
25262 PyThreadState* __tstate = wxPyBeginAllowThreads();
25263 (arg1)->Enable(arg2);
25264 wxPyEndAllowThreads(__tstate);
25265 if (PyErr_Occurred()) SWIG_fail;
25266 }
25267 resultobj = SWIG_Py_Void();
25268 return resultobj;
25269 fail:
25270 return NULL;
25271 }
25272
25273
25274 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25275 PyObject *resultobj = 0;
25276 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25277 bool arg2 ;
25278 void *argp1 = 0 ;
25279 int res1 = 0 ;
25280 bool val2 ;
25281 int ecode2 = 0 ;
25282 PyObject * obj0 = 0 ;
25283 PyObject * obj1 = 0 ;
25284 char * kwnames[] = {
25285 (char *) "self",(char *) "show", NULL
25286 };
25287
25288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25290 if (!SWIG_IsOK(res1)) {
25291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25292 }
25293 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25294 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25295 if (!SWIG_IsOK(ecode2)) {
25296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25297 }
25298 arg2 = static_cast< bool >(val2);
25299 {
25300 PyThreadState* __tstate = wxPyBeginAllowThreads();
25301 (arg1)->Show(arg2);
25302 wxPyEndAllowThreads(__tstate);
25303 if (PyErr_Occurred()) SWIG_fail;
25304 }
25305 resultobj = SWIG_Py_Void();
25306 return resultobj;
25307 fail:
25308 return NULL;
25309 }
25310
25311
25312 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25313 PyObject *resultobj = 0;
25314 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25315 wxString *arg2 = 0 ;
25316 void *argp1 = 0 ;
25317 int res1 = 0 ;
25318 bool temp2 = false ;
25319 PyObject * obj0 = 0 ;
25320 PyObject * obj1 = 0 ;
25321 char * kwnames[] = {
25322 (char *) "self",(char *) "text", NULL
25323 };
25324
25325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25327 if (!SWIG_IsOK(res1)) {
25328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25329 }
25330 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25331 {
25332 arg2 = wxString_in_helper(obj1);
25333 if (arg2 == NULL) SWIG_fail;
25334 temp2 = true;
25335 }
25336 {
25337 PyThreadState* __tstate = wxPyBeginAllowThreads();
25338 (arg1)->SetText((wxString const &)*arg2);
25339 wxPyEndAllowThreads(__tstate);
25340 if (PyErr_Occurred()) SWIG_fail;
25341 }
25342 resultobj = SWIG_Py_Void();
25343 {
25344 if (temp2)
25345 delete arg2;
25346 }
25347 return resultobj;
25348 fail:
25349 {
25350 if (temp2)
25351 delete arg2;
25352 }
25353 return NULL;
25354 }
25355
25356
25357 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25358 PyObject *resultobj = 0;
25359 long arg1 ;
25360 long val1 ;
25361 int ecode1 = 0 ;
25362 PyObject * obj0 = 0 ;
25363 char * kwnames[] = {
25364 (char *) "updateInterval", NULL
25365 };
25366
25367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25368 ecode1 = SWIG_AsVal_long(obj0, &val1);
25369 if (!SWIG_IsOK(ecode1)) {
25370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25371 }
25372 arg1 = static_cast< long >(val1);
25373 {
25374 PyThreadState* __tstate = wxPyBeginAllowThreads();
25375 wxUpdateUIEvent::SetUpdateInterval(arg1);
25376 wxPyEndAllowThreads(__tstate);
25377 if (PyErr_Occurred()) SWIG_fail;
25378 }
25379 resultobj = SWIG_Py_Void();
25380 return resultobj;
25381 fail:
25382 return NULL;
25383 }
25384
25385
25386 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25387 PyObject *resultobj = 0;
25388 long result;
25389
25390 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25391 {
25392 PyThreadState* __tstate = wxPyBeginAllowThreads();
25393 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25394 wxPyEndAllowThreads(__tstate);
25395 if (PyErr_Occurred()) SWIG_fail;
25396 }
25397 resultobj = SWIG_From_long(static_cast< long >(result));
25398 return resultobj;
25399 fail:
25400 return NULL;
25401 }
25402
25403
25404 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25405 PyObject *resultobj = 0;
25406 wxWindow *arg1 = (wxWindow *) 0 ;
25407 bool result;
25408 void *argp1 = 0 ;
25409 int res1 = 0 ;
25410 PyObject * obj0 = 0 ;
25411 char * kwnames[] = {
25412 (char *) "win", NULL
25413 };
25414
25415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25417 if (!SWIG_IsOK(res1)) {
25418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25419 }
25420 arg1 = reinterpret_cast< wxWindow * >(argp1);
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25424 wxPyEndAllowThreads(__tstate);
25425 if (PyErr_Occurred()) SWIG_fail;
25426 }
25427 {
25428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25429 }
25430 return resultobj;
25431 fail:
25432 return NULL;
25433 }
25434
25435
25436 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25437 PyObject *resultobj = 0;
25438
25439 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25440 {
25441 PyThreadState* __tstate = wxPyBeginAllowThreads();
25442 wxUpdateUIEvent::ResetUpdateTime();
25443 wxPyEndAllowThreads(__tstate);
25444 if (PyErr_Occurred()) SWIG_fail;
25445 }
25446 resultobj = SWIG_Py_Void();
25447 return resultobj;
25448 fail:
25449 return NULL;
25450 }
25451
25452
25453 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25454 PyObject *resultobj = 0;
25455 wxUpdateUIMode arg1 ;
25456 int val1 ;
25457 int ecode1 = 0 ;
25458 PyObject * obj0 = 0 ;
25459 char * kwnames[] = {
25460 (char *) "mode", NULL
25461 };
25462
25463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25464 ecode1 = SWIG_AsVal_int(obj0, &val1);
25465 if (!SWIG_IsOK(ecode1)) {
25466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25467 }
25468 arg1 = static_cast< wxUpdateUIMode >(val1);
25469 {
25470 PyThreadState* __tstate = wxPyBeginAllowThreads();
25471 wxUpdateUIEvent::SetMode(arg1);
25472 wxPyEndAllowThreads(__tstate);
25473 if (PyErr_Occurred()) SWIG_fail;
25474 }
25475 resultobj = SWIG_Py_Void();
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25483 PyObject *resultobj = 0;
25484 wxUpdateUIMode result;
25485
25486 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25487 {
25488 PyThreadState* __tstate = wxPyBeginAllowThreads();
25489 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25490 wxPyEndAllowThreads(__tstate);
25491 if (PyErr_Occurred()) SWIG_fail;
25492 }
25493 resultobj = SWIG_From_int(static_cast< int >(result));
25494 return resultobj;
25495 fail:
25496 return NULL;
25497 }
25498
25499
25500 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25501 PyObject *obj;
25502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25503 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25504 return SWIG_Py_Void();
25505 }
25506
25507 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25508 return SWIG_Python_InitShadowInstance(args);
25509 }
25510
25511 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25512 PyObject *resultobj = 0;
25513 wxSysColourChangedEvent *result = 0 ;
25514
25515 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25516 {
25517 PyThreadState* __tstate = wxPyBeginAllowThreads();
25518 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25519 wxPyEndAllowThreads(__tstate);
25520 if (PyErr_Occurred()) SWIG_fail;
25521 }
25522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25523 return resultobj;
25524 fail:
25525 return NULL;
25526 }
25527
25528
25529 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25530 PyObject *obj;
25531 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25532 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25533 return SWIG_Py_Void();
25534 }
25535
25536 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25537 return SWIG_Python_InitShadowInstance(args);
25538 }
25539
25540 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25541 PyObject *resultobj = 0;
25542 int arg1 = (int) 0 ;
25543 wxWindow *arg2 = (wxWindow *) NULL ;
25544 wxMouseCaptureChangedEvent *result = 0 ;
25545 int val1 ;
25546 int ecode1 = 0 ;
25547 void *argp2 = 0 ;
25548 int res2 = 0 ;
25549 PyObject * obj0 = 0 ;
25550 PyObject * obj1 = 0 ;
25551 char * kwnames[] = {
25552 (char *) "winid",(char *) "gainedCapture", NULL
25553 };
25554
25555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25556 if (obj0) {
25557 ecode1 = SWIG_AsVal_int(obj0, &val1);
25558 if (!SWIG_IsOK(ecode1)) {
25559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25560 }
25561 arg1 = static_cast< int >(val1);
25562 }
25563 if (obj1) {
25564 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25565 if (!SWIG_IsOK(res2)) {
25566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25567 }
25568 arg2 = reinterpret_cast< wxWindow * >(argp2);
25569 }
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25573 wxPyEndAllowThreads(__tstate);
25574 if (PyErr_Occurred()) SWIG_fail;
25575 }
25576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584 PyObject *resultobj = 0;
25585 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25586 wxWindow *result = 0 ;
25587 void *argp1 = 0 ;
25588 int res1 = 0 ;
25589 PyObject *swig_obj[1] ;
25590
25591 if (!args) SWIG_fail;
25592 swig_obj[0] = args;
25593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25594 if (!SWIG_IsOK(res1)) {
25595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25596 }
25597 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25598 {
25599 PyThreadState* __tstate = wxPyBeginAllowThreads();
25600 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25601 wxPyEndAllowThreads(__tstate);
25602 if (PyErr_Occurred()) SWIG_fail;
25603 }
25604 {
25605 resultobj = wxPyMake_wxObject(result, (bool)0);
25606 }
25607 return resultobj;
25608 fail:
25609 return NULL;
25610 }
25611
25612
25613 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25614 PyObject *obj;
25615 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25616 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25617 return SWIG_Py_Void();
25618 }
25619
25620 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25621 return SWIG_Python_InitShadowInstance(args);
25622 }
25623
25624 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25625 PyObject *resultobj = 0;
25626 int arg1 = (int) 0 ;
25627 wxMouseCaptureLostEvent *result = 0 ;
25628 int val1 ;
25629 int ecode1 = 0 ;
25630 PyObject * obj0 = 0 ;
25631 char * kwnames[] = {
25632 (char *) "winid", NULL
25633 };
25634
25635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25636 if (obj0) {
25637 ecode1 = SWIG_AsVal_int(obj0, &val1);
25638 if (!SWIG_IsOK(ecode1)) {
25639 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25640 }
25641 arg1 = static_cast< int >(val1);
25642 }
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25657 PyObject *obj;
25658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25659 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25660 return SWIG_Py_Void();
25661 }
25662
25663 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25664 return SWIG_Python_InitShadowInstance(args);
25665 }
25666
25667 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25668 PyObject *resultobj = 0;
25669 wxDisplayChangedEvent *result = 0 ;
25670
25671 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25686 PyObject *obj;
25687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25688 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25689 return SWIG_Py_Void();
25690 }
25691
25692 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25693 return SWIG_Python_InitShadowInstance(args);
25694 }
25695
25696 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25697 PyObject *resultobj = 0;
25698 int arg1 = (int) 0 ;
25699 wxPaletteChangedEvent *result = 0 ;
25700 int val1 ;
25701 int ecode1 = 0 ;
25702 PyObject * obj0 = 0 ;
25703 char * kwnames[] = {
25704 (char *) "id", NULL
25705 };
25706
25707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25708 if (obj0) {
25709 ecode1 = SWIG_AsVal_int(obj0, &val1);
25710 if (!SWIG_IsOK(ecode1)) {
25711 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25712 }
25713 arg1 = static_cast< int >(val1);
25714 }
25715 {
25716 PyThreadState* __tstate = wxPyBeginAllowThreads();
25717 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25718 wxPyEndAllowThreads(__tstate);
25719 if (PyErr_Occurred()) SWIG_fail;
25720 }
25721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25722 return resultobj;
25723 fail:
25724 return NULL;
25725 }
25726
25727
25728 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25729 PyObject *resultobj = 0;
25730 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25731 wxWindow *arg2 = (wxWindow *) 0 ;
25732 void *argp1 = 0 ;
25733 int res1 = 0 ;
25734 void *argp2 = 0 ;
25735 int res2 = 0 ;
25736 PyObject * obj0 = 0 ;
25737 PyObject * obj1 = 0 ;
25738 char * kwnames[] = {
25739 (char *) "self",(char *) "win", NULL
25740 };
25741
25742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25744 if (!SWIG_IsOK(res1)) {
25745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25746 }
25747 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25748 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25749 if (!SWIG_IsOK(res2)) {
25750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25751 }
25752 arg2 = reinterpret_cast< wxWindow * >(argp2);
25753 {
25754 PyThreadState* __tstate = wxPyBeginAllowThreads();
25755 (arg1)->SetChangedWindow(arg2);
25756 wxPyEndAllowThreads(__tstate);
25757 if (PyErr_Occurred()) SWIG_fail;
25758 }
25759 resultobj = SWIG_Py_Void();
25760 return resultobj;
25761 fail:
25762 return NULL;
25763 }
25764
25765
25766 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25767 PyObject *resultobj = 0;
25768 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25769 wxWindow *result = 0 ;
25770 void *argp1 = 0 ;
25771 int res1 = 0 ;
25772 PyObject *swig_obj[1] ;
25773
25774 if (!args) SWIG_fail;
25775 swig_obj[0] = args;
25776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25777 if (!SWIG_IsOK(res1)) {
25778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25779 }
25780 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25781 {
25782 PyThreadState* __tstate = wxPyBeginAllowThreads();
25783 result = (wxWindow *)(arg1)->GetChangedWindow();
25784 wxPyEndAllowThreads(__tstate);
25785 if (PyErr_Occurred()) SWIG_fail;
25786 }
25787 {
25788 resultobj = wxPyMake_wxObject(result, (bool)0);
25789 }
25790 return resultobj;
25791 fail:
25792 return NULL;
25793 }
25794
25795
25796 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25797 PyObject *obj;
25798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25799 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25800 return SWIG_Py_Void();
25801 }
25802
25803 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25804 return SWIG_Python_InitShadowInstance(args);
25805 }
25806
25807 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25808 PyObject *resultobj = 0;
25809 int arg1 = (int) 0 ;
25810 wxQueryNewPaletteEvent *result = 0 ;
25811 int val1 ;
25812 int ecode1 = 0 ;
25813 PyObject * obj0 = 0 ;
25814 char * kwnames[] = {
25815 (char *) "winid", NULL
25816 };
25817
25818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25819 if (obj0) {
25820 ecode1 = SWIG_AsVal_int(obj0, &val1);
25821 if (!SWIG_IsOK(ecode1)) {
25822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25823 }
25824 arg1 = static_cast< int >(val1);
25825 }
25826 {
25827 PyThreadState* __tstate = wxPyBeginAllowThreads();
25828 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25829 wxPyEndAllowThreads(__tstate);
25830 if (PyErr_Occurred()) SWIG_fail;
25831 }
25832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25833 return resultobj;
25834 fail:
25835 return NULL;
25836 }
25837
25838
25839 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25840 PyObject *resultobj = 0;
25841 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25842 bool arg2 ;
25843 void *argp1 = 0 ;
25844 int res1 = 0 ;
25845 bool val2 ;
25846 int ecode2 = 0 ;
25847 PyObject * obj0 = 0 ;
25848 PyObject * obj1 = 0 ;
25849 char * kwnames[] = {
25850 (char *) "self",(char *) "realized", NULL
25851 };
25852
25853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25855 if (!SWIG_IsOK(res1)) {
25856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25857 }
25858 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25859 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25860 if (!SWIG_IsOK(ecode2)) {
25861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25862 }
25863 arg2 = static_cast< bool >(val2);
25864 {
25865 PyThreadState* __tstate = wxPyBeginAllowThreads();
25866 (arg1)->SetPaletteRealized(arg2);
25867 wxPyEndAllowThreads(__tstate);
25868 if (PyErr_Occurred()) SWIG_fail;
25869 }
25870 resultobj = SWIG_Py_Void();
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25878 PyObject *resultobj = 0;
25879 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25880 bool result;
25881 void *argp1 = 0 ;
25882 int res1 = 0 ;
25883 PyObject *swig_obj[1] ;
25884
25885 if (!args) SWIG_fail;
25886 swig_obj[0] = args;
25887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25888 if (!SWIG_IsOK(res1)) {
25889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25890 }
25891 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25892 {
25893 PyThreadState* __tstate = wxPyBeginAllowThreads();
25894 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25895 wxPyEndAllowThreads(__tstate);
25896 if (PyErr_Occurred()) SWIG_fail;
25897 }
25898 {
25899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25900 }
25901 return resultobj;
25902 fail:
25903 return NULL;
25904 }
25905
25906
25907 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25908 PyObject *obj;
25909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25910 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25911 return SWIG_Py_Void();
25912 }
25913
25914 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25915 return SWIG_Python_InitShadowInstance(args);
25916 }
25917
25918 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25919 PyObject *resultobj = 0;
25920 wxNavigationKeyEvent *result = 0 ;
25921
25922 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25923 {
25924 PyThreadState* __tstate = wxPyBeginAllowThreads();
25925 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25926 wxPyEndAllowThreads(__tstate);
25927 if (PyErr_Occurred()) SWIG_fail;
25928 }
25929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25930 return resultobj;
25931 fail:
25932 return NULL;
25933 }
25934
25935
25936 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25937 PyObject *resultobj = 0;
25938 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25939 bool result;
25940 void *argp1 = 0 ;
25941 int res1 = 0 ;
25942 PyObject *swig_obj[1] ;
25943
25944 if (!args) SWIG_fail;
25945 swig_obj[0] = args;
25946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25947 if (!SWIG_IsOK(res1)) {
25948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25949 }
25950 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25951 {
25952 PyThreadState* __tstate = wxPyBeginAllowThreads();
25953 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 {
25958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25959 }
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25967 PyObject *resultobj = 0;
25968 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25969 bool arg2 ;
25970 void *argp1 = 0 ;
25971 int res1 = 0 ;
25972 bool val2 ;
25973 int ecode2 = 0 ;
25974 PyObject * obj0 = 0 ;
25975 PyObject * obj1 = 0 ;
25976 char * kwnames[] = {
25977 (char *) "self",(char *) "forward", NULL
25978 };
25979
25980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25982 if (!SWIG_IsOK(res1)) {
25983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25984 }
25985 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25987 if (!SWIG_IsOK(ecode2)) {
25988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25989 }
25990 arg2 = static_cast< bool >(val2);
25991 {
25992 PyThreadState* __tstate = wxPyBeginAllowThreads();
25993 (arg1)->SetDirection(arg2);
25994 wxPyEndAllowThreads(__tstate);
25995 if (PyErr_Occurred()) SWIG_fail;
25996 }
25997 resultobj = SWIG_Py_Void();
25998 return resultobj;
25999 fail:
26000 return NULL;
26001 }
26002
26003
26004 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26005 PyObject *resultobj = 0;
26006 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26007 bool result;
26008 void *argp1 = 0 ;
26009 int res1 = 0 ;
26010 PyObject *swig_obj[1] ;
26011
26012 if (!args) SWIG_fail;
26013 swig_obj[0] = args;
26014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26015 if (!SWIG_IsOK(res1)) {
26016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26017 }
26018 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26019 {
26020 PyThreadState* __tstate = wxPyBeginAllowThreads();
26021 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26022 wxPyEndAllowThreads(__tstate);
26023 if (PyErr_Occurred()) SWIG_fail;
26024 }
26025 {
26026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26027 }
26028 return resultobj;
26029 fail:
26030 return NULL;
26031 }
26032
26033
26034 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26035 PyObject *resultobj = 0;
26036 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26037 bool arg2 ;
26038 void *argp1 = 0 ;
26039 int res1 = 0 ;
26040 bool val2 ;
26041 int ecode2 = 0 ;
26042 PyObject * obj0 = 0 ;
26043 PyObject * obj1 = 0 ;
26044 char * kwnames[] = {
26045 (char *) "self",(char *) "ischange", NULL
26046 };
26047
26048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26050 if (!SWIG_IsOK(res1)) {
26051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26052 }
26053 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26054 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26055 if (!SWIG_IsOK(ecode2)) {
26056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26057 }
26058 arg2 = static_cast< bool >(val2);
26059 {
26060 PyThreadState* __tstate = wxPyBeginAllowThreads();
26061 (arg1)->SetWindowChange(arg2);
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 resultobj = SWIG_Py_Void();
26066 return resultobj;
26067 fail:
26068 return NULL;
26069 }
26070
26071
26072 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26073 PyObject *resultobj = 0;
26074 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26075 bool result;
26076 void *argp1 = 0 ;
26077 int res1 = 0 ;
26078 PyObject *swig_obj[1] ;
26079
26080 if (!args) SWIG_fail;
26081 swig_obj[0] = args;
26082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26083 if (!SWIG_IsOK(res1)) {
26084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26085 }
26086 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26087 {
26088 PyThreadState* __tstate = wxPyBeginAllowThreads();
26089 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 {
26094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26095 }
26096 return resultobj;
26097 fail:
26098 return NULL;
26099 }
26100
26101
26102 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26103 PyObject *resultobj = 0;
26104 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26105 bool arg2 ;
26106 void *argp1 = 0 ;
26107 int res1 = 0 ;
26108 bool val2 ;
26109 int ecode2 = 0 ;
26110 PyObject * obj0 = 0 ;
26111 PyObject * obj1 = 0 ;
26112 char * kwnames[] = {
26113 (char *) "self",(char *) "bIs", NULL
26114 };
26115
26116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26118 if (!SWIG_IsOK(res1)) {
26119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26120 }
26121 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26122 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26123 if (!SWIG_IsOK(ecode2)) {
26124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26125 }
26126 arg2 = static_cast< bool >(val2);
26127 {
26128 PyThreadState* __tstate = wxPyBeginAllowThreads();
26129 (arg1)->SetFromTab(arg2);
26130 wxPyEndAllowThreads(__tstate);
26131 if (PyErr_Occurred()) SWIG_fail;
26132 }
26133 resultobj = SWIG_Py_Void();
26134 return resultobj;
26135 fail:
26136 return NULL;
26137 }
26138
26139
26140 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26141 PyObject *resultobj = 0;
26142 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26143 long arg2 ;
26144 void *argp1 = 0 ;
26145 int res1 = 0 ;
26146 long val2 ;
26147 int ecode2 = 0 ;
26148 PyObject * obj0 = 0 ;
26149 PyObject * obj1 = 0 ;
26150 char * kwnames[] = {
26151 (char *) "self",(char *) "flags", NULL
26152 };
26153
26154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26156 if (!SWIG_IsOK(res1)) {
26157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26158 }
26159 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26160 ecode2 = SWIG_AsVal_long(obj1, &val2);
26161 if (!SWIG_IsOK(ecode2)) {
26162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26163 }
26164 arg2 = static_cast< long >(val2);
26165 {
26166 PyThreadState* __tstate = wxPyBeginAllowThreads();
26167 (arg1)->SetFlags(arg2);
26168 wxPyEndAllowThreads(__tstate);
26169 if (PyErr_Occurred()) SWIG_fail;
26170 }
26171 resultobj = SWIG_Py_Void();
26172 return resultobj;
26173 fail:
26174 return NULL;
26175 }
26176
26177
26178 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26179 PyObject *resultobj = 0;
26180 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26181 wxWindow *result = 0 ;
26182 void *argp1 = 0 ;
26183 int res1 = 0 ;
26184 PyObject *swig_obj[1] ;
26185
26186 if (!args) SWIG_fail;
26187 swig_obj[0] = args;
26188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26189 if (!SWIG_IsOK(res1)) {
26190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26191 }
26192 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26193 {
26194 PyThreadState* __tstate = wxPyBeginAllowThreads();
26195 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26196 wxPyEndAllowThreads(__tstate);
26197 if (PyErr_Occurred()) SWIG_fail;
26198 }
26199 {
26200 resultobj = wxPyMake_wxObject(result, (bool)0);
26201 }
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26209 PyObject *resultobj = 0;
26210 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26211 wxWindow *arg2 = (wxWindow *) 0 ;
26212 void *argp1 = 0 ;
26213 int res1 = 0 ;
26214 void *argp2 = 0 ;
26215 int res2 = 0 ;
26216 PyObject * obj0 = 0 ;
26217 PyObject * obj1 = 0 ;
26218 char * kwnames[] = {
26219 (char *) "self",(char *) "win", NULL
26220 };
26221
26222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26224 if (!SWIG_IsOK(res1)) {
26225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26226 }
26227 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26229 if (!SWIG_IsOK(res2)) {
26230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26231 }
26232 arg2 = reinterpret_cast< wxWindow * >(argp2);
26233 {
26234 PyThreadState* __tstate = wxPyBeginAllowThreads();
26235 (arg1)->SetCurrentFocus(arg2);
26236 wxPyEndAllowThreads(__tstate);
26237 if (PyErr_Occurred()) SWIG_fail;
26238 }
26239 resultobj = SWIG_Py_Void();
26240 return resultobj;
26241 fail:
26242 return NULL;
26243 }
26244
26245
26246 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26247 PyObject *obj;
26248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26249 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26250 return SWIG_Py_Void();
26251 }
26252
26253 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26254 return SWIG_Python_InitShadowInstance(args);
26255 }
26256
26257 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26258 PyObject *resultobj = 0;
26259 wxWindow *arg1 = (wxWindow *) NULL ;
26260 wxWindowCreateEvent *result = 0 ;
26261 void *argp1 = 0 ;
26262 int res1 = 0 ;
26263 PyObject * obj0 = 0 ;
26264 char * kwnames[] = {
26265 (char *) "win", NULL
26266 };
26267
26268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26269 if (obj0) {
26270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26271 if (!SWIG_IsOK(res1)) {
26272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26273 }
26274 arg1 = reinterpret_cast< wxWindow * >(argp1);
26275 }
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 PyObject *resultobj = 0;
26291 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26292 wxWindow *result = 0 ;
26293 void *argp1 = 0 ;
26294 int res1 = 0 ;
26295 PyObject *swig_obj[1] ;
26296
26297 if (!args) SWIG_fail;
26298 swig_obj[0] = args;
26299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26300 if (!SWIG_IsOK(res1)) {
26301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26302 }
26303 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 {
26311 resultobj = wxPyMake_wxObject(result, (bool)0);
26312 }
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26320 PyObject *obj;
26321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26322 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26323 return SWIG_Py_Void();
26324 }
26325
26326 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26327 return SWIG_Python_InitShadowInstance(args);
26328 }
26329
26330 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26331 PyObject *resultobj = 0;
26332 wxWindow *arg1 = (wxWindow *) NULL ;
26333 wxWindowDestroyEvent *result = 0 ;
26334 void *argp1 = 0 ;
26335 int res1 = 0 ;
26336 PyObject * obj0 = 0 ;
26337 char * kwnames[] = {
26338 (char *) "win", NULL
26339 };
26340
26341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26342 if (obj0) {
26343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26344 if (!SWIG_IsOK(res1)) {
26345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26346 }
26347 arg1 = reinterpret_cast< wxWindow * >(argp1);
26348 }
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26363 PyObject *resultobj = 0;
26364 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26365 wxWindow *result = 0 ;
26366 void *argp1 = 0 ;
26367 int res1 = 0 ;
26368 PyObject *swig_obj[1] ;
26369
26370 if (!args) SWIG_fail;
26371 swig_obj[0] = args;
26372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26375 }
26376 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26380 wxPyEndAllowThreads(__tstate);
26381 if (PyErr_Occurred()) SWIG_fail;
26382 }
26383 {
26384 resultobj = wxPyMake_wxObject(result, (bool)0);
26385 }
26386 return resultobj;
26387 fail:
26388 return NULL;
26389 }
26390
26391
26392 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26393 PyObject *obj;
26394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26395 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26396 return SWIG_Py_Void();
26397 }
26398
26399 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26400 return SWIG_Python_InitShadowInstance(args);
26401 }
26402
26403 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26404 PyObject *resultobj = 0;
26405 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26406 int arg2 = (int) 0 ;
26407 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26408 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26409 wxContextMenuEvent *result = 0 ;
26410 int val1 ;
26411 int ecode1 = 0 ;
26412 int val2 ;
26413 int ecode2 = 0 ;
26414 wxPoint temp3 ;
26415 PyObject * obj0 = 0 ;
26416 PyObject * obj1 = 0 ;
26417 PyObject * obj2 = 0 ;
26418 char * kwnames[] = {
26419 (char *) "type",(char *) "winid",(char *) "pt", NULL
26420 };
26421
26422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26423 if (obj0) {
26424 ecode1 = SWIG_AsVal_int(obj0, &val1);
26425 if (!SWIG_IsOK(ecode1)) {
26426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26427 }
26428 arg1 = static_cast< wxEventType >(val1);
26429 }
26430 if (obj1) {
26431 ecode2 = SWIG_AsVal_int(obj1, &val2);
26432 if (!SWIG_IsOK(ecode2)) {
26433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26434 }
26435 arg2 = static_cast< int >(val2);
26436 }
26437 if (obj2) {
26438 {
26439 arg3 = &temp3;
26440 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26441 }
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26446 wxPyEndAllowThreads(__tstate);
26447 if (PyErr_Occurred()) SWIG_fail;
26448 }
26449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26450 return resultobj;
26451 fail:
26452 return NULL;
26453 }
26454
26455
26456 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26457 PyObject *resultobj = 0;
26458 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26459 wxPoint *result = 0 ;
26460 void *argp1 = 0 ;
26461 int res1 = 0 ;
26462 PyObject *swig_obj[1] ;
26463
26464 if (!args) SWIG_fail;
26465 swig_obj[0] = args;
26466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26467 if (!SWIG_IsOK(res1)) {
26468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26469 }
26470 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26471 {
26472 PyThreadState* __tstate = wxPyBeginAllowThreads();
26473 {
26474 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26475 result = (wxPoint *) &_result_ref;
26476 }
26477 wxPyEndAllowThreads(__tstate);
26478 if (PyErr_Occurred()) SWIG_fail;
26479 }
26480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26481 return resultobj;
26482 fail:
26483 return NULL;
26484 }
26485
26486
26487 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26488 PyObject *resultobj = 0;
26489 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26490 wxPoint *arg2 = 0 ;
26491 void *argp1 = 0 ;
26492 int res1 = 0 ;
26493 wxPoint temp2 ;
26494 PyObject * obj0 = 0 ;
26495 PyObject * obj1 = 0 ;
26496 char * kwnames[] = {
26497 (char *) "self",(char *) "pos", NULL
26498 };
26499
26500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26502 if (!SWIG_IsOK(res1)) {
26503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26504 }
26505 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26506 {
26507 arg2 = &temp2;
26508 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26509 }
26510 {
26511 PyThreadState* __tstate = wxPyBeginAllowThreads();
26512 (arg1)->SetPosition((wxPoint const &)*arg2);
26513 wxPyEndAllowThreads(__tstate);
26514 if (PyErr_Occurred()) SWIG_fail;
26515 }
26516 resultobj = SWIG_Py_Void();
26517 return resultobj;
26518 fail:
26519 return NULL;
26520 }
26521
26522
26523 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26524 PyObject *obj;
26525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26526 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26527 return SWIG_Py_Void();
26528 }
26529
26530 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26531 return SWIG_Python_InitShadowInstance(args);
26532 }
26533
26534 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26535 PyObject *resultobj = 0;
26536 wxIdleEvent *result = 0 ;
26537
26538 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26539 {
26540 PyThreadState* __tstate = wxPyBeginAllowThreads();
26541 result = (wxIdleEvent *)new wxIdleEvent();
26542 wxPyEndAllowThreads(__tstate);
26543 if (PyErr_Occurred()) SWIG_fail;
26544 }
26545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26546 return resultobj;
26547 fail:
26548 return NULL;
26549 }
26550
26551
26552 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26553 PyObject *resultobj = 0;
26554 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26555 bool arg2 = (bool) true ;
26556 void *argp1 = 0 ;
26557 int res1 = 0 ;
26558 bool val2 ;
26559 int ecode2 = 0 ;
26560 PyObject * obj0 = 0 ;
26561 PyObject * obj1 = 0 ;
26562 char * kwnames[] = {
26563 (char *) "self",(char *) "needMore", NULL
26564 };
26565
26566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26568 if (!SWIG_IsOK(res1)) {
26569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26570 }
26571 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26572 if (obj1) {
26573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26574 if (!SWIG_IsOK(ecode2)) {
26575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26576 }
26577 arg2 = static_cast< bool >(val2);
26578 }
26579 {
26580 PyThreadState* __tstate = wxPyBeginAllowThreads();
26581 (arg1)->RequestMore(arg2);
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 resultobj = SWIG_Py_Void();
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26593 PyObject *resultobj = 0;
26594 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26595 bool result;
26596 void *argp1 = 0 ;
26597 int res1 = 0 ;
26598 PyObject *swig_obj[1] ;
26599
26600 if (!args) SWIG_fail;
26601 swig_obj[0] = args;
26602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26603 if (!SWIG_IsOK(res1)) {
26604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26605 }
26606 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 {
26614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26615 }
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26623 PyObject *resultobj = 0;
26624 wxIdleMode arg1 ;
26625 int val1 ;
26626 int ecode1 = 0 ;
26627 PyObject * obj0 = 0 ;
26628 char * kwnames[] = {
26629 (char *) "mode", NULL
26630 };
26631
26632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26633 ecode1 = SWIG_AsVal_int(obj0, &val1);
26634 if (!SWIG_IsOK(ecode1)) {
26635 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26636 }
26637 arg1 = static_cast< wxIdleMode >(val1);
26638 {
26639 PyThreadState* __tstate = wxPyBeginAllowThreads();
26640 wxIdleEvent::SetMode(arg1);
26641 wxPyEndAllowThreads(__tstate);
26642 if (PyErr_Occurred()) SWIG_fail;
26643 }
26644 resultobj = SWIG_Py_Void();
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26652 PyObject *resultobj = 0;
26653 wxIdleMode result;
26654
26655 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26656 {
26657 PyThreadState* __tstate = wxPyBeginAllowThreads();
26658 result = (wxIdleMode)wxIdleEvent::GetMode();
26659 wxPyEndAllowThreads(__tstate);
26660 if (PyErr_Occurred()) SWIG_fail;
26661 }
26662 resultobj = SWIG_From_int(static_cast< int >(result));
26663 return resultobj;
26664 fail:
26665 return NULL;
26666 }
26667
26668
26669 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26670 PyObject *resultobj = 0;
26671 wxWindow *arg1 = (wxWindow *) 0 ;
26672 bool result;
26673 void *argp1 = 0 ;
26674 int res1 = 0 ;
26675 PyObject * obj0 = 0 ;
26676 char * kwnames[] = {
26677 (char *) "win", NULL
26678 };
26679
26680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26682 if (!SWIG_IsOK(res1)) {
26683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26684 }
26685 arg1 = reinterpret_cast< wxWindow * >(argp1);
26686 {
26687 PyThreadState* __tstate = wxPyBeginAllowThreads();
26688 result = (bool)wxIdleEvent::CanSend(arg1);
26689 wxPyEndAllowThreads(__tstate);
26690 if (PyErr_Occurred()) SWIG_fail;
26691 }
26692 {
26693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26694 }
26695 return resultobj;
26696 fail:
26697 return NULL;
26698 }
26699
26700
26701 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26702 PyObject *obj;
26703 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26704 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26705 return SWIG_Py_Void();
26706 }
26707
26708 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26709 return SWIG_Python_InitShadowInstance(args);
26710 }
26711
26712 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26713 PyObject *resultobj = 0;
26714 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26715 int arg2 = (int) 0 ;
26716 wxClipboardTextEvent *result = 0 ;
26717 int val1 ;
26718 int ecode1 = 0 ;
26719 int val2 ;
26720 int ecode2 = 0 ;
26721 PyObject * obj0 = 0 ;
26722 PyObject * obj1 = 0 ;
26723 char * kwnames[] = {
26724 (char *) "type",(char *) "winid", NULL
26725 };
26726
26727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26728 if (obj0) {
26729 ecode1 = SWIG_AsVal_int(obj0, &val1);
26730 if (!SWIG_IsOK(ecode1)) {
26731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26732 }
26733 arg1 = static_cast< wxEventType >(val1);
26734 }
26735 if (obj1) {
26736 ecode2 = SWIG_AsVal_int(obj1, &val2);
26737 if (!SWIG_IsOK(ecode2)) {
26738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26739 }
26740 arg2 = static_cast< int >(val2);
26741 }
26742 {
26743 PyThreadState* __tstate = wxPyBeginAllowThreads();
26744 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26745 wxPyEndAllowThreads(__tstate);
26746 if (PyErr_Occurred()) SWIG_fail;
26747 }
26748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26749 return resultobj;
26750 fail:
26751 return NULL;
26752 }
26753
26754
26755 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26756 PyObject *obj;
26757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26758 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26759 return SWIG_Py_Void();
26760 }
26761
26762 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26763 return SWIG_Python_InitShadowInstance(args);
26764 }
26765
26766 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26767 PyObject *resultobj = 0;
26768 int arg1 = (int) 0 ;
26769 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26770 wxPyEvent *result = 0 ;
26771 int val1 ;
26772 int ecode1 = 0 ;
26773 int val2 ;
26774 int ecode2 = 0 ;
26775 PyObject * obj0 = 0 ;
26776 PyObject * obj1 = 0 ;
26777 char * kwnames[] = {
26778 (char *) "winid",(char *) "eventType", NULL
26779 };
26780
26781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26782 if (obj0) {
26783 ecode1 = SWIG_AsVal_int(obj0, &val1);
26784 if (!SWIG_IsOK(ecode1)) {
26785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26786 }
26787 arg1 = static_cast< int >(val1);
26788 }
26789 if (obj1) {
26790 ecode2 = SWIG_AsVal_int(obj1, &val2);
26791 if (!SWIG_IsOK(ecode2)) {
26792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26793 }
26794 arg2 = static_cast< wxEventType >(val2);
26795 }
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26803 return resultobj;
26804 fail:
26805 return NULL;
26806 }
26807
26808
26809 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26810 PyObject *resultobj = 0;
26811 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26812 void *argp1 = 0 ;
26813 int res1 = 0 ;
26814 PyObject *swig_obj[1] ;
26815
26816 if (!args) SWIG_fail;
26817 swig_obj[0] = args;
26818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26819 if (!SWIG_IsOK(res1)) {
26820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26821 }
26822 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26823 {
26824 PyThreadState* __tstate = wxPyBeginAllowThreads();
26825 delete arg1;
26826
26827 wxPyEndAllowThreads(__tstate);
26828 if (PyErr_Occurred()) SWIG_fail;
26829 }
26830 resultobj = SWIG_Py_Void();
26831 return resultobj;
26832 fail:
26833 return NULL;
26834 }
26835
26836
26837 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26838 PyObject *resultobj = 0;
26839 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26840 PyObject *arg2 = (PyObject *) 0 ;
26841 void *argp1 = 0 ;
26842 int res1 = 0 ;
26843 PyObject * obj0 = 0 ;
26844 PyObject * obj1 = 0 ;
26845 char * kwnames[] = {
26846 (char *) "self",(char *) "self", NULL
26847 };
26848
26849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26851 if (!SWIG_IsOK(res1)) {
26852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26853 }
26854 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26855 arg2 = obj1;
26856 {
26857 PyThreadState* __tstate = wxPyBeginAllowThreads();
26858 (arg1)->SetSelf(arg2);
26859 wxPyEndAllowThreads(__tstate);
26860 if (PyErr_Occurred()) SWIG_fail;
26861 }
26862 resultobj = SWIG_Py_Void();
26863 return resultobj;
26864 fail:
26865 return NULL;
26866 }
26867
26868
26869 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26870 PyObject *resultobj = 0;
26871 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26872 PyObject *result = 0 ;
26873 void *argp1 = 0 ;
26874 int res1 = 0 ;
26875 PyObject *swig_obj[1] ;
26876
26877 if (!args) SWIG_fail;
26878 swig_obj[0] = args;
26879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26880 if (!SWIG_IsOK(res1)) {
26881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26882 }
26883 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26884 {
26885 PyThreadState* __tstate = wxPyBeginAllowThreads();
26886 result = (PyObject *)(arg1)->GetSelf();
26887 wxPyEndAllowThreads(__tstate);
26888 if (PyErr_Occurred()) SWIG_fail;
26889 }
26890 resultobj = result;
26891 return resultobj;
26892 fail:
26893 return NULL;
26894 }
26895
26896
26897 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26898 PyObject *obj;
26899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26900 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26901 return SWIG_Py_Void();
26902 }
26903
26904 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26905 return SWIG_Python_InitShadowInstance(args);
26906 }
26907
26908 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26909 PyObject *resultobj = 0;
26910 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26911 int arg2 = (int) 0 ;
26912 wxPyCommandEvent *result = 0 ;
26913 int val1 ;
26914 int ecode1 = 0 ;
26915 int val2 ;
26916 int ecode2 = 0 ;
26917 PyObject * obj0 = 0 ;
26918 PyObject * obj1 = 0 ;
26919 char * kwnames[] = {
26920 (char *) "eventType",(char *) "id", NULL
26921 };
26922
26923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26924 if (obj0) {
26925 ecode1 = SWIG_AsVal_int(obj0, &val1);
26926 if (!SWIG_IsOK(ecode1)) {
26927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26928 }
26929 arg1 = static_cast< wxEventType >(val1);
26930 }
26931 if (obj1) {
26932 ecode2 = SWIG_AsVal_int(obj1, &val2);
26933 if (!SWIG_IsOK(ecode2)) {
26934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26935 }
26936 arg2 = static_cast< int >(val2);
26937 }
26938 {
26939 PyThreadState* __tstate = wxPyBeginAllowThreads();
26940 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26941 wxPyEndAllowThreads(__tstate);
26942 if (PyErr_Occurred()) SWIG_fail;
26943 }
26944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26945 return resultobj;
26946 fail:
26947 return NULL;
26948 }
26949
26950
26951 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26952 PyObject *resultobj = 0;
26953 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26954 void *argp1 = 0 ;
26955 int res1 = 0 ;
26956 PyObject *swig_obj[1] ;
26957
26958 if (!args) SWIG_fail;
26959 swig_obj[0] = args;
26960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26961 if (!SWIG_IsOK(res1)) {
26962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26963 }
26964 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 delete arg1;
26968
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 resultobj = SWIG_Py_Void();
26973 return resultobj;
26974 fail:
26975 return NULL;
26976 }
26977
26978
26979 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26980 PyObject *resultobj = 0;
26981 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26982 PyObject *arg2 = (PyObject *) 0 ;
26983 void *argp1 = 0 ;
26984 int res1 = 0 ;
26985 PyObject * obj0 = 0 ;
26986 PyObject * obj1 = 0 ;
26987 char * kwnames[] = {
26988 (char *) "self",(char *) "self", NULL
26989 };
26990
26991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26993 if (!SWIG_IsOK(res1)) {
26994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26995 }
26996 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26997 arg2 = obj1;
26998 {
26999 PyThreadState* __tstate = wxPyBeginAllowThreads();
27000 (arg1)->SetSelf(arg2);
27001 wxPyEndAllowThreads(__tstate);
27002 if (PyErr_Occurred()) SWIG_fail;
27003 }
27004 resultobj = SWIG_Py_Void();
27005 return resultobj;
27006 fail:
27007 return NULL;
27008 }
27009
27010
27011 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27012 PyObject *resultobj = 0;
27013 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27014 PyObject *result = 0 ;
27015 void *argp1 = 0 ;
27016 int res1 = 0 ;
27017 PyObject *swig_obj[1] ;
27018
27019 if (!args) SWIG_fail;
27020 swig_obj[0] = args;
27021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27022 if (!SWIG_IsOK(res1)) {
27023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27024 }
27025 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27026 {
27027 PyThreadState* __tstate = wxPyBeginAllowThreads();
27028 result = (PyObject *)(arg1)->GetSelf();
27029 wxPyEndAllowThreads(__tstate);
27030 if (PyErr_Occurred()) SWIG_fail;
27031 }
27032 resultobj = result;
27033 return resultobj;
27034 fail:
27035 return NULL;
27036 }
27037
27038
27039 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27040 PyObject *obj;
27041 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27042 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27043 return SWIG_Py_Void();
27044 }
27045
27046 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27047 return SWIG_Python_InitShadowInstance(args);
27048 }
27049
27050 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27051 PyObject *resultobj = 0;
27052 wxWindow *arg1 = (wxWindow *) 0 ;
27053 wxDateTime *arg2 = 0 ;
27054 wxEventType arg3 ;
27055 wxDateEvent *result = 0 ;
27056 void *argp1 = 0 ;
27057 int res1 = 0 ;
27058 void *argp2 = 0 ;
27059 int res2 = 0 ;
27060 int val3 ;
27061 int ecode3 = 0 ;
27062 PyObject * obj0 = 0 ;
27063 PyObject * obj1 = 0 ;
27064 PyObject * obj2 = 0 ;
27065 char * kwnames[] = {
27066 (char *) "win",(char *) "dt",(char *) "type", NULL
27067 };
27068
27069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27071 if (!SWIG_IsOK(res1)) {
27072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27073 }
27074 arg1 = reinterpret_cast< wxWindow * >(argp1);
27075 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27076 if (!SWIG_IsOK(res2)) {
27077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27078 }
27079 if (!argp2) {
27080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27081 }
27082 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27083 ecode3 = SWIG_AsVal_int(obj2, &val3);
27084 if (!SWIG_IsOK(ecode3)) {
27085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27086 }
27087 arg3 = static_cast< wxEventType >(val3);
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27102 PyObject *resultobj = 0;
27103 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27104 wxDateTime *result = 0 ;
27105 void *argp1 = 0 ;
27106 int res1 = 0 ;
27107 PyObject *swig_obj[1] ;
27108
27109 if (!args) SWIG_fail;
27110 swig_obj[0] = args;
27111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27112 if (!SWIG_IsOK(res1)) {
27113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27114 }
27115 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 {
27119 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27120 result = (wxDateTime *) &_result_ref;
27121 }
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27126 return resultobj;
27127 fail:
27128 return NULL;
27129 }
27130
27131
27132 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27133 PyObject *resultobj = 0;
27134 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27135 wxDateTime *arg2 = 0 ;
27136 void *argp1 = 0 ;
27137 int res1 = 0 ;
27138 void *argp2 = 0 ;
27139 int res2 = 0 ;
27140 PyObject * obj0 = 0 ;
27141 PyObject * obj1 = 0 ;
27142 char * kwnames[] = {
27143 (char *) "self",(char *) "date", NULL
27144 };
27145
27146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27148 if (!SWIG_IsOK(res1)) {
27149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27150 }
27151 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27152 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27153 if (!SWIG_IsOK(res2)) {
27154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27155 }
27156 if (!argp2) {
27157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27158 }
27159 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27160 {
27161 PyThreadState* __tstate = wxPyBeginAllowThreads();
27162 (arg1)->SetDate((wxDateTime const &)*arg2);
27163 wxPyEndAllowThreads(__tstate);
27164 if (PyErr_Occurred()) SWIG_fail;
27165 }
27166 resultobj = SWIG_Py_Void();
27167 return resultobj;
27168 fail:
27169 return NULL;
27170 }
27171
27172
27173 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27174 PyObject *obj;
27175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27176 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27177 return SWIG_Py_Void();
27178 }
27179
27180 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27181 return SWIG_Python_InitShadowInstance(args);
27182 }
27183
27184 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27185 PyObject *resultobj = 0;
27186 wxPyApp *result = 0 ;
27187
27188 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27189 {
27190 PyThreadState* __tstate = wxPyBeginAllowThreads();
27191 result = (wxPyApp *)new_wxPyApp();
27192 wxPyEndAllowThreads(__tstate);
27193 if (PyErr_Occurred()) SWIG_fail;
27194 }
27195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27196 return resultobj;
27197 fail:
27198 return NULL;
27199 }
27200
27201
27202 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27203 PyObject *resultobj = 0;
27204 wxPyApp *arg1 = (wxPyApp *) 0 ;
27205 void *argp1 = 0 ;
27206 int res1 = 0 ;
27207 PyObject *swig_obj[1] ;
27208
27209 if (!args) SWIG_fail;
27210 swig_obj[0] = args;
27211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27212 if (!SWIG_IsOK(res1)) {
27213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27214 }
27215 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27216 {
27217 PyThreadState* __tstate = wxPyBeginAllowThreads();
27218 delete arg1;
27219
27220 wxPyEndAllowThreads(__tstate);
27221 if (PyErr_Occurred()) SWIG_fail;
27222 }
27223 resultobj = SWIG_Py_Void();
27224 return resultobj;
27225 fail:
27226 return NULL;
27227 }
27228
27229
27230 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27231 PyObject *resultobj = 0;
27232 wxPyApp *arg1 = (wxPyApp *) 0 ;
27233 PyObject *arg2 = (PyObject *) 0 ;
27234 PyObject *arg3 = (PyObject *) 0 ;
27235 bool arg4 ;
27236 void *argp1 = 0 ;
27237 int res1 = 0 ;
27238 bool val4 ;
27239 int ecode4 = 0 ;
27240 PyObject * obj0 = 0 ;
27241 PyObject * obj1 = 0 ;
27242 PyObject * obj2 = 0 ;
27243 PyObject * obj3 = 0 ;
27244 char * kwnames[] = {
27245 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27246 };
27247
27248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27250 if (!SWIG_IsOK(res1)) {
27251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27252 }
27253 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27254 arg2 = obj1;
27255 arg3 = obj2;
27256 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27257 if (!SWIG_IsOK(ecode4)) {
27258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27259 }
27260 arg4 = static_cast< bool >(val4);
27261 {
27262 PyThreadState* __tstate = wxPyBeginAllowThreads();
27263 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27264 wxPyEndAllowThreads(__tstate);
27265 if (PyErr_Occurred()) SWIG_fail;
27266 }
27267 resultobj = SWIG_Py_Void();
27268 return resultobj;
27269 fail:
27270 return NULL;
27271 }
27272
27273
27274 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27275 PyObject *resultobj = 0;
27276 wxPyApp *arg1 = (wxPyApp *) 0 ;
27277 wxString result;
27278 void *argp1 = 0 ;
27279 int res1 = 0 ;
27280 PyObject *swig_obj[1] ;
27281
27282 if (!args) SWIG_fail;
27283 swig_obj[0] = args;
27284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27285 if (!SWIG_IsOK(res1)) {
27286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27287 }
27288 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 result = ((wxPyApp const *)arg1)->GetAppName();
27292 wxPyEndAllowThreads(__tstate);
27293 if (PyErr_Occurred()) SWIG_fail;
27294 }
27295 {
27296 #if wxUSE_UNICODE
27297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27298 #else
27299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27300 #endif
27301 }
27302 return resultobj;
27303 fail:
27304 return NULL;
27305 }
27306
27307
27308 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27309 PyObject *resultobj = 0;
27310 wxPyApp *arg1 = (wxPyApp *) 0 ;
27311 wxString *arg2 = 0 ;
27312 void *argp1 = 0 ;
27313 int res1 = 0 ;
27314 bool temp2 = false ;
27315 PyObject * obj0 = 0 ;
27316 PyObject * obj1 = 0 ;
27317 char * kwnames[] = {
27318 (char *) "self",(char *) "name", NULL
27319 };
27320
27321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27323 if (!SWIG_IsOK(res1)) {
27324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27325 }
27326 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27327 {
27328 arg2 = wxString_in_helper(obj1);
27329 if (arg2 == NULL) SWIG_fail;
27330 temp2 = true;
27331 }
27332 {
27333 PyThreadState* __tstate = wxPyBeginAllowThreads();
27334 (arg1)->SetAppName((wxString const &)*arg2);
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 resultobj = SWIG_Py_Void();
27339 {
27340 if (temp2)
27341 delete arg2;
27342 }
27343 return resultobj;
27344 fail:
27345 {
27346 if (temp2)
27347 delete arg2;
27348 }
27349 return NULL;
27350 }
27351
27352
27353 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27354 PyObject *resultobj = 0;
27355 wxPyApp *arg1 = (wxPyApp *) 0 ;
27356 wxString result;
27357 void *argp1 = 0 ;
27358 int res1 = 0 ;
27359 PyObject *swig_obj[1] ;
27360
27361 if (!args) SWIG_fail;
27362 swig_obj[0] = args;
27363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27364 if (!SWIG_IsOK(res1)) {
27365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27366 }
27367 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 result = ((wxPyApp const *)arg1)->GetClassName();
27371 wxPyEndAllowThreads(__tstate);
27372 if (PyErr_Occurred()) SWIG_fail;
27373 }
27374 {
27375 #if wxUSE_UNICODE
27376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27377 #else
27378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27379 #endif
27380 }
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27388 PyObject *resultobj = 0;
27389 wxPyApp *arg1 = (wxPyApp *) 0 ;
27390 wxString *arg2 = 0 ;
27391 void *argp1 = 0 ;
27392 int res1 = 0 ;
27393 bool temp2 = false ;
27394 PyObject * obj0 = 0 ;
27395 PyObject * obj1 = 0 ;
27396 char * kwnames[] = {
27397 (char *) "self",(char *) "name", NULL
27398 };
27399
27400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27402 if (!SWIG_IsOK(res1)) {
27403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27404 }
27405 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27406 {
27407 arg2 = wxString_in_helper(obj1);
27408 if (arg2 == NULL) SWIG_fail;
27409 temp2 = true;
27410 }
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 (arg1)->SetClassName((wxString const &)*arg2);
27414 wxPyEndAllowThreads(__tstate);
27415 if (PyErr_Occurred()) SWIG_fail;
27416 }
27417 resultobj = SWIG_Py_Void();
27418 {
27419 if (temp2)
27420 delete arg2;
27421 }
27422 return resultobj;
27423 fail:
27424 {
27425 if (temp2)
27426 delete arg2;
27427 }
27428 return NULL;
27429 }
27430
27431
27432 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27433 PyObject *resultobj = 0;
27434 wxPyApp *arg1 = (wxPyApp *) 0 ;
27435 wxString *result = 0 ;
27436 void *argp1 = 0 ;
27437 int res1 = 0 ;
27438 PyObject *swig_obj[1] ;
27439
27440 if (!args) SWIG_fail;
27441 swig_obj[0] = args;
27442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27443 if (!SWIG_IsOK(res1)) {
27444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27445 }
27446 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27447 {
27448 PyThreadState* __tstate = wxPyBeginAllowThreads();
27449 {
27450 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27451 result = (wxString *) &_result_ref;
27452 }
27453 wxPyEndAllowThreads(__tstate);
27454 if (PyErr_Occurred()) SWIG_fail;
27455 }
27456 {
27457 #if wxUSE_UNICODE
27458 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27459 #else
27460 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27461 #endif
27462 }
27463 return resultobj;
27464 fail:
27465 return NULL;
27466 }
27467
27468
27469 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27470 PyObject *resultobj = 0;
27471 wxPyApp *arg1 = (wxPyApp *) 0 ;
27472 wxString *arg2 = 0 ;
27473 void *argp1 = 0 ;
27474 int res1 = 0 ;
27475 bool temp2 = false ;
27476 PyObject * obj0 = 0 ;
27477 PyObject * obj1 = 0 ;
27478 char * kwnames[] = {
27479 (char *) "self",(char *) "name", NULL
27480 };
27481
27482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27484 if (!SWIG_IsOK(res1)) {
27485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27486 }
27487 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27488 {
27489 arg2 = wxString_in_helper(obj1);
27490 if (arg2 == NULL) SWIG_fail;
27491 temp2 = true;
27492 }
27493 {
27494 PyThreadState* __tstate = wxPyBeginAllowThreads();
27495 (arg1)->SetVendorName((wxString const &)*arg2);
27496 wxPyEndAllowThreads(__tstate);
27497 if (PyErr_Occurred()) SWIG_fail;
27498 }
27499 resultobj = SWIG_Py_Void();
27500 {
27501 if (temp2)
27502 delete arg2;
27503 }
27504 return resultobj;
27505 fail:
27506 {
27507 if (temp2)
27508 delete arg2;
27509 }
27510 return NULL;
27511 }
27512
27513
27514 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27515 PyObject *resultobj = 0;
27516 wxPyApp *arg1 = (wxPyApp *) 0 ;
27517 wxAppTraits *result = 0 ;
27518 void *argp1 = 0 ;
27519 int res1 = 0 ;
27520 PyObject *swig_obj[1] ;
27521
27522 if (!args) SWIG_fail;
27523 swig_obj[0] = args;
27524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27525 if (!SWIG_IsOK(res1)) {
27526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27527 }
27528 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = (wxAppTraits *)(arg1)->GetTraits();
27532 wxPyEndAllowThreads(__tstate);
27533 if (PyErr_Occurred()) SWIG_fail;
27534 }
27535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27536 return resultobj;
27537 fail:
27538 return NULL;
27539 }
27540
27541
27542 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27543 PyObject *resultobj = 0;
27544 wxPyApp *arg1 = (wxPyApp *) 0 ;
27545 void *argp1 = 0 ;
27546 int res1 = 0 ;
27547 PyObject *swig_obj[1] ;
27548
27549 if (!args) SWIG_fail;
27550 swig_obj[0] = args;
27551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27552 if (!SWIG_IsOK(res1)) {
27553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27554 }
27555 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 (arg1)->ProcessPendingEvents();
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 resultobj = SWIG_Py_Void();
27563 return resultobj;
27564 fail:
27565 return NULL;
27566 }
27567
27568
27569 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27570 PyObject *resultobj = 0;
27571 wxPyApp *arg1 = (wxPyApp *) 0 ;
27572 bool arg2 = (bool) false ;
27573 bool result;
27574 void *argp1 = 0 ;
27575 int res1 = 0 ;
27576 bool val2 ;
27577 int ecode2 = 0 ;
27578 PyObject * obj0 = 0 ;
27579 PyObject * obj1 = 0 ;
27580 char * kwnames[] = {
27581 (char *) "self",(char *) "onlyIfNeeded", NULL
27582 };
27583
27584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27586 if (!SWIG_IsOK(res1)) {
27587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27588 }
27589 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27590 if (obj1) {
27591 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27592 if (!SWIG_IsOK(ecode2)) {
27593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27594 }
27595 arg2 = static_cast< bool >(val2);
27596 }
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (bool)(arg1)->Yield(arg2);
27600 wxPyEndAllowThreads(__tstate);
27601 if (PyErr_Occurred()) SWIG_fail;
27602 }
27603 {
27604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27605 }
27606 return resultobj;
27607 fail:
27608 return NULL;
27609 }
27610
27611
27612 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27613 PyObject *resultobj = 0;
27614 wxPyApp *arg1 = (wxPyApp *) 0 ;
27615 void *argp1 = 0 ;
27616 int res1 = 0 ;
27617 PyObject *swig_obj[1] ;
27618
27619 if (!args) SWIG_fail;
27620 swig_obj[0] = args;
27621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27624 }
27625 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27626 {
27627 PyThreadState* __tstate = wxPyBeginAllowThreads();
27628 (arg1)->WakeUpIdle();
27629 wxPyEndAllowThreads(__tstate);
27630 if (PyErr_Occurred()) SWIG_fail;
27631 }
27632 resultobj = SWIG_Py_Void();
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27640 PyObject *resultobj = 0;
27641 bool result;
27642
27643 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 result = (bool)wxPyApp::IsMainLoopRunning();
27647 wxPyEndAllowThreads(__tstate);
27648 if (PyErr_Occurred()) SWIG_fail;
27649 }
27650 {
27651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27652 }
27653 return resultobj;
27654 fail:
27655 return NULL;
27656 }
27657
27658
27659 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27660 PyObject *resultobj = 0;
27661 wxPyApp *arg1 = (wxPyApp *) 0 ;
27662 int result;
27663 void *argp1 = 0 ;
27664 int res1 = 0 ;
27665 PyObject *swig_obj[1] ;
27666
27667 if (!args) SWIG_fail;
27668 swig_obj[0] = args;
27669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27670 if (!SWIG_IsOK(res1)) {
27671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27672 }
27673 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27674 {
27675 PyThreadState* __tstate = wxPyBeginAllowThreads();
27676 result = (int)(arg1)->MainLoop();
27677 wxPyEndAllowThreads(__tstate);
27678 if (PyErr_Occurred()) SWIG_fail;
27679 }
27680 resultobj = SWIG_From_int(static_cast< int >(result));
27681 return resultobj;
27682 fail:
27683 return NULL;
27684 }
27685
27686
27687 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27688 PyObject *resultobj = 0;
27689 wxPyApp *arg1 = (wxPyApp *) 0 ;
27690 void *argp1 = 0 ;
27691 int res1 = 0 ;
27692 PyObject *swig_obj[1] ;
27693
27694 if (!args) SWIG_fail;
27695 swig_obj[0] = args;
27696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27697 if (!SWIG_IsOK(res1)) {
27698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27699 }
27700 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27701 {
27702 PyThreadState* __tstate = wxPyBeginAllowThreads();
27703 (arg1)->Exit();
27704 wxPyEndAllowThreads(__tstate);
27705 if (PyErr_Occurred()) SWIG_fail;
27706 }
27707 resultobj = SWIG_Py_Void();
27708 return resultobj;
27709 fail:
27710 return NULL;
27711 }
27712
27713
27714 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27715 PyObject *resultobj = 0;
27716 wxPyApp *arg1 = (wxPyApp *) 0 ;
27717 void *argp1 = 0 ;
27718 int res1 = 0 ;
27719 PyObject *swig_obj[1] ;
27720
27721 if (!args) SWIG_fail;
27722 swig_obj[0] = args;
27723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27724 if (!SWIG_IsOK(res1)) {
27725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27726 }
27727 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 (arg1)->ExitMainLoop();
27731 wxPyEndAllowThreads(__tstate);
27732 if (PyErr_Occurred()) SWIG_fail;
27733 }
27734 resultobj = SWIG_Py_Void();
27735 return resultobj;
27736 fail:
27737 return NULL;
27738 }
27739
27740
27741 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27742 PyObject *resultobj = 0;
27743 wxPyApp *arg1 = (wxPyApp *) 0 ;
27744 bool result;
27745 void *argp1 = 0 ;
27746 int res1 = 0 ;
27747 PyObject *swig_obj[1] ;
27748
27749 if (!args) SWIG_fail;
27750 swig_obj[0] = args;
27751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27752 if (!SWIG_IsOK(res1)) {
27753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27754 }
27755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 result = (bool)(arg1)->Pending();
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 {
27763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27764 }
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27772 PyObject *resultobj = 0;
27773 wxPyApp *arg1 = (wxPyApp *) 0 ;
27774 bool result;
27775 void *argp1 = 0 ;
27776 int res1 = 0 ;
27777 PyObject *swig_obj[1] ;
27778
27779 if (!args) SWIG_fail;
27780 swig_obj[0] = args;
27781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27782 if (!SWIG_IsOK(res1)) {
27783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27784 }
27785 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 result = (bool)(arg1)->Dispatch();
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 {
27793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27794 }
27795 return resultobj;
27796 fail:
27797 return NULL;
27798 }
27799
27800
27801 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27802 PyObject *resultobj = 0;
27803 wxPyApp *arg1 = (wxPyApp *) 0 ;
27804 bool result;
27805 void *argp1 = 0 ;
27806 int res1 = 0 ;
27807 PyObject *swig_obj[1] ;
27808
27809 if (!args) SWIG_fail;
27810 swig_obj[0] = args;
27811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27812 if (!SWIG_IsOK(res1)) {
27813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27814 }
27815 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 result = (bool)(arg1)->ProcessIdle();
27819 wxPyEndAllowThreads(__tstate);
27820 if (PyErr_Occurred()) SWIG_fail;
27821 }
27822 {
27823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27824 }
27825 return resultobj;
27826 fail:
27827 return NULL;
27828 }
27829
27830
27831 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27832 PyObject *resultobj = 0;
27833 wxPyApp *arg1 = (wxPyApp *) 0 ;
27834 wxWindow *arg2 = (wxWindow *) 0 ;
27835 wxIdleEvent *arg3 = 0 ;
27836 bool result;
27837 void *argp1 = 0 ;
27838 int res1 = 0 ;
27839 void *argp2 = 0 ;
27840 int res2 = 0 ;
27841 void *argp3 = 0 ;
27842 int res3 = 0 ;
27843 PyObject * obj0 = 0 ;
27844 PyObject * obj1 = 0 ;
27845 PyObject * obj2 = 0 ;
27846 char * kwnames[] = {
27847 (char *) "self",(char *) "win",(char *) "event", NULL
27848 };
27849
27850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27852 if (!SWIG_IsOK(res1)) {
27853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27854 }
27855 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27856 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27857 if (!SWIG_IsOK(res2)) {
27858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27859 }
27860 arg2 = reinterpret_cast< wxWindow * >(argp2);
27861 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27862 if (!SWIG_IsOK(res3)) {
27863 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27864 }
27865 if (!argp3) {
27866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27867 }
27868 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27869 {
27870 PyThreadState* __tstate = wxPyBeginAllowThreads();
27871 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 {
27876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27877 }
27878 return resultobj;
27879 fail:
27880 return NULL;
27881 }
27882
27883
27884 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27885 PyObject *resultobj = 0;
27886 wxPyApp *arg1 = (wxPyApp *) 0 ;
27887 bool result;
27888 void *argp1 = 0 ;
27889 int res1 = 0 ;
27890 PyObject *swig_obj[1] ;
27891
27892 if (!args) SWIG_fail;
27893 swig_obj[0] = args;
27894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27895 if (!SWIG_IsOK(res1)) {
27896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27897 }
27898 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27899 {
27900 PyThreadState* __tstate = wxPyBeginAllowThreads();
27901 result = (bool)((wxPyApp const *)arg1)->IsActive();
27902 wxPyEndAllowThreads(__tstate);
27903 if (PyErr_Occurred()) SWIG_fail;
27904 }
27905 {
27906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27907 }
27908 return resultobj;
27909 fail:
27910 return NULL;
27911 }
27912
27913
27914 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27915 PyObject *resultobj = 0;
27916 wxPyApp *arg1 = (wxPyApp *) 0 ;
27917 wxWindow *arg2 = (wxWindow *) 0 ;
27918 void *argp1 = 0 ;
27919 int res1 = 0 ;
27920 void *argp2 = 0 ;
27921 int res2 = 0 ;
27922 PyObject * obj0 = 0 ;
27923 PyObject * obj1 = 0 ;
27924 char * kwnames[] = {
27925 (char *) "self",(char *) "win", NULL
27926 };
27927
27928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27930 if (!SWIG_IsOK(res1)) {
27931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27932 }
27933 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27935 if (!SWIG_IsOK(res2)) {
27936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27937 }
27938 arg2 = reinterpret_cast< wxWindow * >(argp2);
27939 {
27940 PyThreadState* __tstate = wxPyBeginAllowThreads();
27941 (arg1)->SetTopWindow(arg2);
27942 wxPyEndAllowThreads(__tstate);
27943 if (PyErr_Occurred()) SWIG_fail;
27944 }
27945 resultobj = SWIG_Py_Void();
27946 return resultobj;
27947 fail:
27948 return NULL;
27949 }
27950
27951
27952 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27953 PyObject *resultobj = 0;
27954 wxPyApp *arg1 = (wxPyApp *) 0 ;
27955 wxWindow *result = 0 ;
27956 void *argp1 = 0 ;
27957 int res1 = 0 ;
27958 PyObject *swig_obj[1] ;
27959
27960 if (!args) SWIG_fail;
27961 swig_obj[0] = args;
27962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27963 if (!SWIG_IsOK(res1)) {
27964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27965 }
27966 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27967 {
27968 PyThreadState* __tstate = wxPyBeginAllowThreads();
27969 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27970 wxPyEndAllowThreads(__tstate);
27971 if (PyErr_Occurred()) SWIG_fail;
27972 }
27973 {
27974 resultobj = wxPyMake_wxObject(result, (bool)0);
27975 }
27976 return resultobj;
27977 fail:
27978 return NULL;
27979 }
27980
27981
27982 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27983 PyObject *resultobj = 0;
27984 wxPyApp *arg1 = (wxPyApp *) 0 ;
27985 bool arg2 ;
27986 void *argp1 = 0 ;
27987 int res1 = 0 ;
27988 bool val2 ;
27989 int ecode2 = 0 ;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char * kwnames[] = {
27993 (char *) "self",(char *) "flag", NULL
27994 };
27995
27996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27998 if (!SWIG_IsOK(res1)) {
27999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28000 }
28001 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28003 if (!SWIG_IsOK(ecode2)) {
28004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28005 }
28006 arg2 = static_cast< bool >(val2);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 (arg1)->SetExitOnFrameDelete(arg2);
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 resultobj = SWIG_Py_Void();
28014 return resultobj;
28015 fail:
28016 return NULL;
28017 }
28018
28019
28020 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28021 PyObject *resultobj = 0;
28022 wxPyApp *arg1 = (wxPyApp *) 0 ;
28023 bool result;
28024 void *argp1 = 0 ;
28025 int res1 = 0 ;
28026 PyObject *swig_obj[1] ;
28027
28028 if (!args) SWIG_fail;
28029 swig_obj[0] = args;
28030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28031 if (!SWIG_IsOK(res1)) {
28032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28033 }
28034 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28035 {
28036 PyThreadState* __tstate = wxPyBeginAllowThreads();
28037 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28038 wxPyEndAllowThreads(__tstate);
28039 if (PyErr_Occurred()) SWIG_fail;
28040 }
28041 {
28042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28043 }
28044 return resultobj;
28045 fail:
28046 return NULL;
28047 }
28048
28049
28050 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28051 PyObject *resultobj = 0;
28052 wxPyApp *arg1 = (wxPyApp *) 0 ;
28053 bool arg2 ;
28054 void *argp1 = 0 ;
28055 int res1 = 0 ;
28056 bool val2 ;
28057 int ecode2 = 0 ;
28058 PyObject * obj0 = 0 ;
28059 PyObject * obj1 = 0 ;
28060 char * kwnames[] = {
28061 (char *) "self",(char *) "flag", NULL
28062 };
28063
28064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28066 if (!SWIG_IsOK(res1)) {
28067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28068 }
28069 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28071 if (!SWIG_IsOK(ecode2)) {
28072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28073 }
28074 arg2 = static_cast< bool >(val2);
28075 {
28076 PyThreadState* __tstate = wxPyBeginAllowThreads();
28077 (arg1)->SetUseBestVisual(arg2);
28078 wxPyEndAllowThreads(__tstate);
28079 if (PyErr_Occurred()) SWIG_fail;
28080 }
28081 resultobj = SWIG_Py_Void();
28082 return resultobj;
28083 fail:
28084 return NULL;
28085 }
28086
28087
28088 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28089 PyObject *resultobj = 0;
28090 wxPyApp *arg1 = (wxPyApp *) 0 ;
28091 bool result;
28092 void *argp1 = 0 ;
28093 int res1 = 0 ;
28094 PyObject *swig_obj[1] ;
28095
28096 if (!args) SWIG_fail;
28097 swig_obj[0] = args;
28098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28099 if (!SWIG_IsOK(res1)) {
28100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28101 }
28102 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28106 wxPyEndAllowThreads(__tstate);
28107 if (PyErr_Occurred()) SWIG_fail;
28108 }
28109 {
28110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28111 }
28112 return resultobj;
28113 fail:
28114 return NULL;
28115 }
28116
28117
28118 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28119 PyObject *resultobj = 0;
28120 wxPyApp *arg1 = (wxPyApp *) 0 ;
28121 int arg2 ;
28122 void *argp1 = 0 ;
28123 int res1 = 0 ;
28124 int val2 ;
28125 int ecode2 = 0 ;
28126 PyObject * obj0 = 0 ;
28127 PyObject * obj1 = 0 ;
28128 char * kwnames[] = {
28129 (char *) "self",(char *) "mode", NULL
28130 };
28131
28132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28134 if (!SWIG_IsOK(res1)) {
28135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28136 }
28137 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28138 ecode2 = SWIG_AsVal_int(obj1, &val2);
28139 if (!SWIG_IsOK(ecode2)) {
28140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28141 }
28142 arg2 = static_cast< int >(val2);
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 (arg1)->SetPrintMode(arg2);
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 resultobj = SWIG_Py_Void();
28150 return resultobj;
28151 fail:
28152 return NULL;
28153 }
28154
28155
28156 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28157 PyObject *resultobj = 0;
28158 wxPyApp *arg1 = (wxPyApp *) 0 ;
28159 int result;
28160 void *argp1 = 0 ;
28161 int res1 = 0 ;
28162 PyObject *swig_obj[1] ;
28163
28164 if (!args) SWIG_fail;
28165 swig_obj[0] = args;
28166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28167 if (!SWIG_IsOK(res1)) {
28168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28169 }
28170 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 resultobj = SWIG_From_int(static_cast< int >(result));
28178 return resultobj;
28179 fail:
28180 return NULL;
28181 }
28182
28183
28184 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28185 PyObject *resultobj = 0;
28186 wxPyApp *arg1 = (wxPyApp *) 0 ;
28187 int arg2 ;
28188 void *argp1 = 0 ;
28189 int res1 = 0 ;
28190 int val2 ;
28191 int ecode2 = 0 ;
28192 PyObject * obj0 = 0 ;
28193 PyObject * obj1 = 0 ;
28194 char * kwnames[] = {
28195 (char *) "self",(char *) "mode", NULL
28196 };
28197
28198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28200 if (!SWIG_IsOK(res1)) {
28201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28202 }
28203 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28204 ecode2 = SWIG_AsVal_int(obj1, &val2);
28205 if (!SWIG_IsOK(ecode2)) {
28206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28207 }
28208 arg2 = static_cast< int >(val2);
28209 {
28210 PyThreadState* __tstate = wxPyBeginAllowThreads();
28211 (arg1)->SetAssertMode(arg2);
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_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28223 PyObject *resultobj = 0;
28224 wxPyApp *arg1 = (wxPyApp *) 0 ;
28225 int result;
28226 void *argp1 = 0 ;
28227 int res1 = 0 ;
28228 PyObject *swig_obj[1] ;
28229
28230 if (!args) SWIG_fail;
28231 swig_obj[0] = args;
28232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28233 if (!SWIG_IsOK(res1)) {
28234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28235 }
28236 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28237 {
28238 PyThreadState* __tstate = wxPyBeginAllowThreads();
28239 result = (int)(arg1)->GetAssertMode();
28240 wxPyEndAllowThreads(__tstate);
28241 if (PyErr_Occurred()) SWIG_fail;
28242 }
28243 resultobj = SWIG_From_int(static_cast< int >(result));
28244 return resultobj;
28245 fail:
28246 return NULL;
28247 }
28248
28249
28250 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28251 PyObject *resultobj = 0;
28252 bool result;
28253
28254 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 {
28262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28263 }
28264 return resultobj;
28265 fail:
28266 return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28271 PyObject *resultobj = 0;
28272 long result;
28273
28274 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 result = (long)wxPyApp::GetMacAboutMenuItemId();
28278 wxPyEndAllowThreads(__tstate);
28279 if (PyErr_Occurred()) SWIG_fail;
28280 }
28281 resultobj = SWIG_From_long(static_cast< long >(result));
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28289 PyObject *resultobj = 0;
28290 long result;
28291
28292 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28293 {
28294 PyThreadState* __tstate = wxPyBeginAllowThreads();
28295 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 resultobj = SWIG_From_long(static_cast< long >(result));
28300 return resultobj;
28301 fail:
28302 return NULL;
28303 }
28304
28305
28306 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28307 PyObject *resultobj = 0;
28308 long result;
28309
28310 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = (long)wxPyApp::GetMacExitMenuItemId();
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 resultobj = SWIG_From_long(static_cast< long >(result));
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28325 PyObject *resultobj = 0;
28326 wxString result;
28327
28328 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = wxPyApp::GetMacHelpMenuTitleName();
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 #if wxUSE_UNICODE
28337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28338 #else
28339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28340 #endif
28341 }
28342 return resultobj;
28343 fail:
28344 return NULL;
28345 }
28346
28347
28348 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28349 PyObject *resultobj = 0;
28350 bool arg1 ;
28351 bool val1 ;
28352 int ecode1 = 0 ;
28353 PyObject * obj0 = 0 ;
28354 char * kwnames[] = {
28355 (char *) "val", NULL
28356 };
28357
28358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28359 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28360 if (!SWIG_IsOK(ecode1)) {
28361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28362 }
28363 arg1 = static_cast< bool >(val1);
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28367 wxPyEndAllowThreads(__tstate);
28368 if (PyErr_Occurred()) SWIG_fail;
28369 }
28370 resultobj = SWIG_Py_Void();
28371 return resultobj;
28372 fail:
28373 return NULL;
28374 }
28375
28376
28377 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28378 PyObject *resultobj = 0;
28379 long arg1 ;
28380 long val1 ;
28381 int ecode1 = 0 ;
28382 PyObject * obj0 = 0 ;
28383 char * kwnames[] = {
28384 (char *) "val", NULL
28385 };
28386
28387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28388 ecode1 = SWIG_AsVal_long(obj0, &val1);
28389 if (!SWIG_IsOK(ecode1)) {
28390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28391 }
28392 arg1 = static_cast< long >(val1);
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 wxPyApp::SetMacAboutMenuItemId(arg1);
28396 wxPyEndAllowThreads(__tstate);
28397 if (PyErr_Occurred()) SWIG_fail;
28398 }
28399 resultobj = SWIG_Py_Void();
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28407 PyObject *resultobj = 0;
28408 long arg1 ;
28409 long val1 ;
28410 int ecode1 = 0 ;
28411 PyObject * obj0 = 0 ;
28412 char * kwnames[] = {
28413 (char *) "val", NULL
28414 };
28415
28416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28417 ecode1 = SWIG_AsVal_long(obj0, &val1);
28418 if (!SWIG_IsOK(ecode1)) {
28419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28420 }
28421 arg1 = static_cast< long >(val1);
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 resultobj = SWIG_Py_Void();
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28436 PyObject *resultobj = 0;
28437 long arg1 ;
28438 long val1 ;
28439 int ecode1 = 0 ;
28440 PyObject * obj0 = 0 ;
28441 char * kwnames[] = {
28442 (char *) "val", NULL
28443 };
28444
28445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28446 ecode1 = SWIG_AsVal_long(obj0, &val1);
28447 if (!SWIG_IsOK(ecode1)) {
28448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28449 }
28450 arg1 = static_cast< long >(val1);
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 wxPyApp::SetMacExitMenuItemId(arg1);
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_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28465 PyObject *resultobj = 0;
28466 wxString *arg1 = 0 ;
28467 bool temp1 = false ;
28468 PyObject * obj0 = 0 ;
28469 char * kwnames[] = {
28470 (char *) "val", NULL
28471 };
28472
28473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28474 {
28475 arg1 = wxString_in_helper(obj0);
28476 if (arg1 == NULL) SWIG_fail;
28477 temp1 = true;
28478 }
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_Py_Void();
28486 {
28487 if (temp1)
28488 delete arg1;
28489 }
28490 return resultobj;
28491 fail:
28492 {
28493 if (temp1)
28494 delete arg1;
28495 }
28496 return NULL;
28497 }
28498
28499
28500 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28501 PyObject *resultobj = 0;
28502 wxPyApp *arg1 = (wxPyApp *) 0 ;
28503 void *argp1 = 0 ;
28504 int res1 = 0 ;
28505 PyObject *swig_obj[1] ;
28506
28507 if (!args) SWIG_fail;
28508 swig_obj[0] = args;
28509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28510 if (!SWIG_IsOK(res1)) {
28511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28512 }
28513 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28514 {
28515 PyThreadState* __tstate = wxPyBeginAllowThreads();
28516 (arg1)->_BootstrapApp();
28517 wxPyEndAllowThreads(__tstate);
28518 if (PyErr_Occurred()) SWIG_fail;
28519 }
28520 resultobj = SWIG_Py_Void();
28521 return resultobj;
28522 fail:
28523 return NULL;
28524 }
28525
28526
28527 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28528 PyObject *resultobj = 0;
28529 int result;
28530
28531 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 result = (int)wxPyApp_GetComCtl32Version();
28535 wxPyEndAllowThreads(__tstate);
28536 if (PyErr_Occurred()) SWIG_fail;
28537 }
28538 resultobj = SWIG_From_int(static_cast< int >(result));
28539 return resultobj;
28540 fail:
28541 return NULL;
28542 }
28543
28544
28545 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28546 PyObject *resultobj = 0;
28547 bool result;
28548
28549 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 result = (bool)wxPyApp_DisplayAvailable();
28553 wxPyEndAllowThreads(__tstate);
28554 if (PyErr_Occurred()) SWIG_fail;
28555 }
28556 {
28557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28558 }
28559 return resultobj;
28560 fail:
28561 return NULL;
28562 }
28563
28564
28565 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28566 PyObject *obj;
28567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28568 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28569 return SWIG_Py_Void();
28570 }
28571
28572 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28573 return SWIG_Python_InitShadowInstance(args);
28574 }
28575
28576 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28577 PyObject *resultobj = 0;
28578
28579 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28580 {
28581 PyThreadState* __tstate = wxPyBeginAllowThreads();
28582 wxExit();
28583 wxPyEndAllowThreads(__tstate);
28584 if (PyErr_Occurred()) SWIG_fail;
28585 }
28586 resultobj = SWIG_Py_Void();
28587 return resultobj;
28588 fail:
28589 return NULL;
28590 }
28591
28592
28593 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28594 PyObject *resultobj = 0;
28595 bool result;
28596
28597 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 result = (bool)wxYield();
28601 wxPyEndAllowThreads(__tstate);
28602 if (PyErr_Occurred()) SWIG_fail;
28603 }
28604 {
28605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28606 }
28607 return resultobj;
28608 fail:
28609 return NULL;
28610 }
28611
28612
28613 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28614 PyObject *resultobj = 0;
28615 bool result;
28616
28617 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28618 {
28619 PyThreadState* __tstate = wxPyBeginAllowThreads();
28620 result = (bool)wxYieldIfNeeded();
28621 wxPyEndAllowThreads(__tstate);
28622 if (PyErr_Occurred()) SWIG_fail;
28623 }
28624 {
28625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28626 }
28627 return resultobj;
28628 fail:
28629 return NULL;
28630 }
28631
28632
28633 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28634 PyObject *resultobj = 0;
28635 wxWindow *arg1 = (wxWindow *) NULL ;
28636 bool arg2 = (bool) false ;
28637 bool result;
28638 void *argp1 = 0 ;
28639 int res1 = 0 ;
28640 bool val2 ;
28641 int ecode2 = 0 ;
28642 PyObject * obj0 = 0 ;
28643 PyObject * obj1 = 0 ;
28644 char * kwnames[] = {
28645 (char *) "win",(char *) "onlyIfNeeded", NULL
28646 };
28647
28648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28649 if (obj0) {
28650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28651 if (!SWIG_IsOK(res1)) {
28652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28653 }
28654 arg1 = reinterpret_cast< wxWindow * >(argp1);
28655 }
28656 if (obj1) {
28657 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28658 if (!SWIG_IsOK(ecode2)) {
28659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28660 }
28661 arg2 = static_cast< bool >(val2);
28662 }
28663 {
28664 PyThreadState* __tstate = wxPyBeginAllowThreads();
28665 result = (bool)wxSafeYield(arg1,arg2);
28666 wxPyEndAllowThreads(__tstate);
28667 if (PyErr_Occurred()) SWIG_fail;
28668 }
28669 {
28670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28671 }
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28679 PyObject *resultobj = 0;
28680
28681 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28682 {
28683 PyThreadState* __tstate = wxPyBeginAllowThreads();
28684 wxWakeUpIdle();
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 resultobj = SWIG_Py_Void();
28689 return resultobj;
28690 fail:
28691 return NULL;
28692 }
28693
28694
28695 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28696 PyObject *resultobj = 0;
28697 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28698 wxEvent *arg2 = 0 ;
28699 void *argp1 = 0 ;
28700 int res1 = 0 ;
28701 void *argp2 = 0 ;
28702 int res2 = 0 ;
28703 PyObject * obj0 = 0 ;
28704 PyObject * obj1 = 0 ;
28705 char * kwnames[] = {
28706 (char *) "dest",(char *) "event", NULL
28707 };
28708
28709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28711 if (!SWIG_IsOK(res1)) {
28712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28713 }
28714 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28715 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28716 if (!SWIG_IsOK(res2)) {
28717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28718 }
28719 if (!argp2) {
28720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28721 }
28722 arg2 = reinterpret_cast< wxEvent * >(argp2);
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 wxPostEvent(arg1,*arg2);
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 resultobj = SWIG_Py_Void();
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28737 PyObject *resultobj = 0;
28738
28739 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28740 {
28741 PyThreadState* __tstate = wxPyBeginAllowThreads();
28742 wxApp_CleanUp();
28743 wxPyEndAllowThreads(__tstate);
28744 if (PyErr_Occurred()) SWIG_fail;
28745 }
28746 resultobj = SWIG_Py_Void();
28747 return resultobj;
28748 fail:
28749 return NULL;
28750 }
28751
28752
28753 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28754 PyObject *resultobj = 0;
28755 wxPyApp *result = 0 ;
28756
28757 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28758 {
28759 PyThreadState* __tstate = wxPyBeginAllowThreads();
28760 result = (wxPyApp *)wxPyGetApp();
28761 wxPyEndAllowThreads(__tstate);
28762 if (PyErr_Occurred()) SWIG_fail;
28763 }
28764 {
28765 resultobj = wxPyMake_wxObject(result, 0);
28766 }
28767 return resultobj;
28768 fail:
28769 return NULL;
28770 }
28771
28772
28773 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28774 PyObject *resultobj = 0;
28775 char *arg1 = (char *) 0 ;
28776 int res1 ;
28777 char *buf1 = 0 ;
28778 int alloc1 = 0 ;
28779 PyObject * obj0 = 0 ;
28780 char * kwnames[] = {
28781 (char *) "encoding", NULL
28782 };
28783
28784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28785 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28786 if (!SWIG_IsOK(res1)) {
28787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28788 }
28789 arg1 = buf1;
28790 {
28791 PyThreadState* __tstate = wxPyBeginAllowThreads();
28792 wxSetDefaultPyEncoding((char const *)arg1);
28793 wxPyEndAllowThreads(__tstate);
28794 if (PyErr_Occurred()) SWIG_fail;
28795 }
28796 resultobj = SWIG_Py_Void();
28797 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28798 return resultobj;
28799 fail:
28800 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28801 return NULL;
28802 }
28803
28804
28805 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28806 PyObject *resultobj = 0;
28807 char *result = 0 ;
28808
28809 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (char *)wxGetDefaultPyEncoding();
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 resultobj = SWIG_FromCharPtr(result);
28817 return resultobj;
28818 fail:
28819 return NULL;
28820 }
28821
28822
28823 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28824 PyObject *resultobj = 0;
28825 wxEventLoop *result = 0 ;
28826
28827 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28828 {
28829 PyThreadState* __tstate = wxPyBeginAllowThreads();
28830 result = (wxEventLoop *)new wxEventLoop();
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28842 PyObject *resultobj = 0;
28843 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28844 void *argp1 = 0 ;
28845 int res1 = 0 ;
28846 PyObject *swig_obj[1] ;
28847
28848 if (!args) SWIG_fail;
28849 swig_obj[0] = args;
28850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28851 if (!SWIG_IsOK(res1)) {
28852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28853 }
28854 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 delete arg1;
28858
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 resultobj = SWIG_Py_Void();
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28870 PyObject *resultobj = 0;
28871 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28872 int result;
28873 void *argp1 = 0 ;
28874 int res1 = 0 ;
28875 PyObject *swig_obj[1] ;
28876
28877 if (!args) SWIG_fail;
28878 swig_obj[0] = args;
28879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28880 if (!SWIG_IsOK(res1)) {
28881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28882 }
28883 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28884 {
28885 PyThreadState* __tstate = wxPyBeginAllowThreads();
28886 result = (int)(arg1)->Run();
28887 wxPyEndAllowThreads(__tstate);
28888 if (PyErr_Occurred()) SWIG_fail;
28889 }
28890 resultobj = SWIG_From_int(static_cast< int >(result));
28891 return resultobj;
28892 fail:
28893 return NULL;
28894 }
28895
28896
28897 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28898 PyObject *resultobj = 0;
28899 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28900 int arg2 = (int) 0 ;
28901 void *argp1 = 0 ;
28902 int res1 = 0 ;
28903 int val2 ;
28904 int ecode2 = 0 ;
28905 PyObject * obj0 = 0 ;
28906 PyObject * obj1 = 0 ;
28907 char * kwnames[] = {
28908 (char *) "self",(char *) "rc", NULL
28909 };
28910
28911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28913 if (!SWIG_IsOK(res1)) {
28914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28915 }
28916 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28917 if (obj1) {
28918 ecode2 = SWIG_AsVal_int(obj1, &val2);
28919 if (!SWIG_IsOK(ecode2)) {
28920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28921 }
28922 arg2 = static_cast< int >(val2);
28923 }
28924 {
28925 PyThreadState* __tstate = wxPyBeginAllowThreads();
28926 (arg1)->Exit(arg2);
28927 wxPyEndAllowThreads(__tstate);
28928 if (PyErr_Occurred()) SWIG_fail;
28929 }
28930 resultobj = SWIG_Py_Void();
28931 return resultobj;
28932 fail:
28933 return NULL;
28934 }
28935
28936
28937 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28938 PyObject *resultobj = 0;
28939 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28940 bool result;
28941 void *argp1 = 0 ;
28942 int res1 = 0 ;
28943 PyObject *swig_obj[1] ;
28944
28945 if (!args) SWIG_fail;
28946 swig_obj[0] = args;
28947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28948 if (!SWIG_IsOK(res1)) {
28949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28950 }
28951 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28952 {
28953 PyThreadState* __tstate = wxPyBeginAllowThreads();
28954 result = (bool)((wxEventLoop const *)arg1)->Pending();
28955 wxPyEndAllowThreads(__tstate);
28956 if (PyErr_Occurred()) SWIG_fail;
28957 }
28958 {
28959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28960 }
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28968 PyObject *resultobj = 0;
28969 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28970 bool result;
28971 void *argp1 = 0 ;
28972 int res1 = 0 ;
28973 PyObject *swig_obj[1] ;
28974
28975 if (!args) SWIG_fail;
28976 swig_obj[0] = args;
28977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28978 if (!SWIG_IsOK(res1)) {
28979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28980 }
28981 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28982 {
28983 PyThreadState* __tstate = wxPyBeginAllowThreads();
28984 result = (bool)(arg1)->Dispatch();
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 {
28989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28990 }
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29000 bool result;
29001 void *argp1 = 0 ;
29002 int res1 = 0 ;
29003 PyObject *swig_obj[1] ;
29004
29005 if (!args) SWIG_fail;
29006 swig_obj[0] = args;
29007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29008 if (!SWIG_IsOK(res1)) {
29009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29010 }
29011 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29015 wxPyEndAllowThreads(__tstate);
29016 if (PyErr_Occurred()) SWIG_fail;
29017 }
29018 {
29019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29020 }
29021 return resultobj;
29022 fail:
29023 return NULL;
29024 }
29025
29026
29027 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29028 PyObject *resultobj = 0;
29029 wxEventLoop *result = 0 ;
29030
29031 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 result = (wxEventLoop *)wxEventLoop::GetActive();
29035 wxPyEndAllowThreads(__tstate);
29036 if (PyErr_Occurred()) SWIG_fail;
29037 }
29038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29039 return resultobj;
29040 fail:
29041 return NULL;
29042 }
29043
29044
29045 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29046 PyObject *resultobj = 0;
29047 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29048 void *argp1 = 0 ;
29049 int res1 = 0 ;
29050 PyObject * obj0 = 0 ;
29051 char * kwnames[] = {
29052 (char *) "loop", NULL
29053 };
29054
29055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29057 if (!SWIG_IsOK(res1)) {
29058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29059 }
29060 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29061 {
29062 PyThreadState* __tstate = wxPyBeginAllowThreads();
29063 wxEventLoop::SetActive(arg1);
29064 wxPyEndAllowThreads(__tstate);
29065 if (PyErr_Occurred()) SWIG_fail;
29066 }
29067 resultobj = SWIG_Py_Void();
29068 return resultobj;
29069 fail:
29070 return NULL;
29071 }
29072
29073
29074 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29075 PyObject *obj;
29076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29077 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29078 return SWIG_Py_Void();
29079 }
29080
29081 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29082 return SWIG_Python_InitShadowInstance(args);
29083 }
29084
29085 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29086 PyObject *resultobj = 0;
29087 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29088 wxEventLoopActivator *result = 0 ;
29089 void *argp1 = 0 ;
29090 int res1 = 0 ;
29091 PyObject * obj0 = 0 ;
29092 char * kwnames[] = {
29093 (char *) "evtLoop", NULL
29094 };
29095
29096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29098 if (!SWIG_IsOK(res1)) {
29099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29100 }
29101 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29102 {
29103 PyThreadState* __tstate = wxPyBeginAllowThreads();
29104 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29105 wxPyEndAllowThreads(__tstate);
29106 if (PyErr_Occurred()) SWIG_fail;
29107 }
29108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29109 return resultobj;
29110 fail:
29111 return NULL;
29112 }
29113
29114
29115 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29116 PyObject *resultobj = 0;
29117 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29118 void *argp1 = 0 ;
29119 int res1 = 0 ;
29120 PyObject *swig_obj[1] ;
29121
29122 if (!args) SWIG_fail;
29123 swig_obj[0] = args;
29124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29125 if (!SWIG_IsOK(res1)) {
29126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29127 }
29128 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29129 {
29130 PyThreadState* __tstate = wxPyBeginAllowThreads();
29131 delete arg1;
29132
29133 wxPyEndAllowThreads(__tstate);
29134 if (PyErr_Occurred()) SWIG_fail;
29135 }
29136 resultobj = SWIG_Py_Void();
29137 return resultobj;
29138 fail:
29139 return NULL;
29140 }
29141
29142
29143 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29144 PyObject *obj;
29145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29146 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29147 return SWIG_Py_Void();
29148 }
29149
29150 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29151 return SWIG_Python_InitShadowInstance(args);
29152 }
29153
29154 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29155 PyObject *resultobj = 0;
29156 int arg1 = (int) 0 ;
29157 int arg2 = (int) 0 ;
29158 int arg3 = (int) 0 ;
29159 wxAcceleratorEntry *result = 0 ;
29160 int val1 ;
29161 int ecode1 = 0 ;
29162 int val2 ;
29163 int ecode2 = 0 ;
29164 int val3 ;
29165 int ecode3 = 0 ;
29166 PyObject * obj0 = 0 ;
29167 PyObject * obj1 = 0 ;
29168 PyObject * obj2 = 0 ;
29169 char * kwnames[] = {
29170 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29171 };
29172
29173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29174 if (obj0) {
29175 ecode1 = SWIG_AsVal_int(obj0, &val1);
29176 if (!SWIG_IsOK(ecode1)) {
29177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29178 }
29179 arg1 = static_cast< int >(val1);
29180 }
29181 if (obj1) {
29182 ecode2 = SWIG_AsVal_int(obj1, &val2);
29183 if (!SWIG_IsOK(ecode2)) {
29184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29185 }
29186 arg2 = static_cast< int >(val2);
29187 }
29188 if (obj2) {
29189 ecode3 = SWIG_AsVal_int(obj2, &val3);
29190 if (!SWIG_IsOK(ecode3)) {
29191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29192 }
29193 arg3 = static_cast< int >(val3);
29194 }
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29198 wxPyEndAllowThreads(__tstate);
29199 if (PyErr_Occurred()) SWIG_fail;
29200 }
29201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29202 return resultobj;
29203 fail:
29204 return NULL;
29205 }
29206
29207
29208 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29209 PyObject *resultobj = 0;
29210 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29211 void *argp1 = 0 ;
29212 int res1 = 0 ;
29213 PyObject *swig_obj[1] ;
29214
29215 if (!args) SWIG_fail;
29216 swig_obj[0] = args;
29217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29218 if (!SWIG_IsOK(res1)) {
29219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29220 }
29221 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29222 {
29223 PyThreadState* __tstate = wxPyBeginAllowThreads();
29224 delete arg1;
29225
29226 wxPyEndAllowThreads(__tstate);
29227 if (PyErr_Occurred()) SWIG_fail;
29228 }
29229 resultobj = SWIG_Py_Void();
29230 return resultobj;
29231 fail:
29232 return NULL;
29233 }
29234
29235
29236 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29237 PyObject *resultobj = 0;
29238 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29239 int arg2 ;
29240 int arg3 ;
29241 int arg4 ;
29242 void *argp1 = 0 ;
29243 int res1 = 0 ;
29244 int val2 ;
29245 int ecode2 = 0 ;
29246 int val3 ;
29247 int ecode3 = 0 ;
29248 int val4 ;
29249 int ecode4 = 0 ;
29250 PyObject * obj0 = 0 ;
29251 PyObject * obj1 = 0 ;
29252 PyObject * obj2 = 0 ;
29253 PyObject * obj3 = 0 ;
29254 char * kwnames[] = {
29255 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29256 };
29257
29258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29260 if (!SWIG_IsOK(res1)) {
29261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29262 }
29263 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29264 ecode2 = SWIG_AsVal_int(obj1, &val2);
29265 if (!SWIG_IsOK(ecode2)) {
29266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29267 }
29268 arg2 = static_cast< int >(val2);
29269 ecode3 = SWIG_AsVal_int(obj2, &val3);
29270 if (!SWIG_IsOK(ecode3)) {
29271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29272 }
29273 arg3 = static_cast< int >(val3);
29274 ecode4 = SWIG_AsVal_int(obj3, &val4);
29275 if (!SWIG_IsOK(ecode4)) {
29276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29277 }
29278 arg4 = static_cast< int >(val4);
29279 {
29280 PyThreadState* __tstate = wxPyBeginAllowThreads();
29281 (arg1)->Set(arg2,arg3,arg4);
29282 wxPyEndAllowThreads(__tstate);
29283 if (PyErr_Occurred()) SWIG_fail;
29284 }
29285 resultobj = SWIG_Py_Void();
29286 return resultobj;
29287 fail:
29288 return NULL;
29289 }
29290
29291
29292 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29293 PyObject *resultobj = 0;
29294 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29295 int result;
29296 void *argp1 = 0 ;
29297 int res1 = 0 ;
29298 PyObject *swig_obj[1] ;
29299
29300 if (!args) SWIG_fail;
29301 swig_obj[0] = args;
29302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29303 if (!SWIG_IsOK(res1)) {
29304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29305 }
29306 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29307 {
29308 PyThreadState* __tstate = wxPyBeginAllowThreads();
29309 result = (int)(arg1)->GetFlags();
29310 wxPyEndAllowThreads(__tstate);
29311 if (PyErr_Occurred()) SWIG_fail;
29312 }
29313 resultobj = SWIG_From_int(static_cast< int >(result));
29314 return resultobj;
29315 fail:
29316 return NULL;
29317 }
29318
29319
29320 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29321 PyObject *resultobj = 0;
29322 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29323 int result;
29324 void *argp1 = 0 ;
29325 int res1 = 0 ;
29326 PyObject *swig_obj[1] ;
29327
29328 if (!args) SWIG_fail;
29329 swig_obj[0] = args;
29330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29331 if (!SWIG_IsOK(res1)) {
29332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29333 }
29334 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 result = (int)(arg1)->GetKeyCode();
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 resultobj = SWIG_From_int(static_cast< int >(result));
29342 return resultobj;
29343 fail:
29344 return NULL;
29345 }
29346
29347
29348 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29349 PyObject *resultobj = 0;
29350 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29351 int result;
29352 void *argp1 = 0 ;
29353 int res1 = 0 ;
29354 PyObject *swig_obj[1] ;
29355
29356 if (!args) SWIG_fail;
29357 swig_obj[0] = args;
29358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29359 if (!SWIG_IsOK(res1)) {
29360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29361 }
29362 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29363 {
29364 PyThreadState* __tstate = wxPyBeginAllowThreads();
29365 result = (int)(arg1)->GetCommand();
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 resultobj = SWIG_From_int(static_cast< int >(result));
29370 return resultobj;
29371 fail:
29372 return NULL;
29373 }
29374
29375
29376 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29377 PyObject *obj;
29378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29379 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29380 return SWIG_Py_Void();
29381 }
29382
29383 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29384 return SWIG_Python_InitShadowInstance(args);
29385 }
29386
29387 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29388 PyObject *resultobj = 0;
29389 int arg1 ;
29390 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29391 wxAcceleratorTable *result = 0 ;
29392 PyObject * obj0 = 0 ;
29393 char * kwnames[] = {
29394 (char *) "n", NULL
29395 };
29396
29397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29398 {
29399 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29400 if (arg2) arg1 = PyList_Size(obj0);
29401 else arg1 = 0;
29402 }
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 PyObject *resultobj = 0;
29418 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29419 void *argp1 = 0 ;
29420 int res1 = 0 ;
29421 PyObject *swig_obj[1] ;
29422
29423 if (!args) SWIG_fail;
29424 swig_obj[0] = args;
29425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29428 }
29429 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 delete arg1;
29433
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 resultobj = SWIG_Py_Void();
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29445 PyObject *resultobj = 0;
29446 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29447 bool result;
29448 void *argp1 = 0 ;
29449 int res1 = 0 ;
29450 PyObject *swig_obj[1] ;
29451
29452 if (!args) SWIG_fail;
29453 swig_obj[0] = args;
29454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29455 if (!SWIG_IsOK(res1)) {
29456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29457 }
29458 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29459 {
29460 PyThreadState* __tstate = wxPyBeginAllowThreads();
29461 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 {
29466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29467 }
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29475 PyObject *obj;
29476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29477 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29478 return SWIG_Py_Void();
29479 }
29480
29481 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29482 return SWIG_Python_InitShadowInstance(args);
29483 }
29484
29485 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29486 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29487 return 1;
29488 }
29489
29490
29491 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29492 PyObject *pyobj = 0;
29493
29494 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29495 return pyobj;
29496 }
29497
29498
29499 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29500 PyObject *resultobj = 0;
29501 wxString *arg1 = 0 ;
29502 wxAcceleratorEntry *result = 0 ;
29503 bool temp1 = false ;
29504 PyObject * obj0 = 0 ;
29505 char * kwnames[] = {
29506 (char *) "label", NULL
29507 };
29508
29509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29510 {
29511 arg1 = wxString_in_helper(obj0);
29512 if (arg1 == NULL) SWIG_fail;
29513 temp1 = true;
29514 }
29515 {
29516 PyThreadState* __tstate = wxPyBeginAllowThreads();
29517 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29518 wxPyEndAllowThreads(__tstate);
29519 if (PyErr_Occurred()) SWIG_fail;
29520 }
29521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29522 {
29523 if (temp1)
29524 delete arg1;
29525 }
29526 return resultobj;
29527 fail:
29528 {
29529 if (temp1)
29530 delete arg1;
29531 }
29532 return NULL;
29533 }
29534
29535
29536 SWIGINTERN int PanelNameStr_set(PyObject *) {
29537 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29538 return 1;
29539 }
29540
29541
29542 SWIGINTERN PyObject *PanelNameStr_get(void) {
29543 PyObject *pyobj = 0;
29544
29545 {
29546 #if wxUSE_UNICODE
29547 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29548 #else
29549 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29550 #endif
29551 }
29552 return pyobj;
29553 }
29554
29555
29556 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29557 PyObject *resultobj = 0;
29558 wxVisualAttributes *result = 0 ;
29559
29560 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29561 {
29562 PyThreadState* __tstate = wxPyBeginAllowThreads();
29563 result = (wxVisualAttributes *)new_wxVisualAttributes();
29564 wxPyEndAllowThreads(__tstate);
29565 if (PyErr_Occurred()) SWIG_fail;
29566 }
29567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29568 return resultobj;
29569 fail:
29570 return NULL;
29571 }
29572
29573
29574 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29575 PyObject *resultobj = 0;
29576 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29577 void *argp1 = 0 ;
29578 int res1 = 0 ;
29579 PyObject *swig_obj[1] ;
29580
29581 if (!args) SWIG_fail;
29582 swig_obj[0] = args;
29583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29584 if (!SWIG_IsOK(res1)) {
29585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29586 }
29587 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29588 {
29589 PyThreadState* __tstate = wxPyBeginAllowThreads();
29590 delete_wxVisualAttributes(arg1);
29591
29592 wxPyEndAllowThreads(__tstate);
29593 if (PyErr_Occurred()) SWIG_fail;
29594 }
29595 resultobj = SWIG_Py_Void();
29596 return resultobj;
29597 fail:
29598 return NULL;
29599 }
29600
29601
29602 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29603 PyObject *resultobj = 0;
29604 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29605 wxFont *arg2 = (wxFont *) 0 ;
29606 void *argp1 = 0 ;
29607 int res1 = 0 ;
29608 void *argp2 = 0 ;
29609 int res2 = 0 ;
29610 PyObject *swig_obj[2] ;
29611
29612 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29614 if (!SWIG_IsOK(res1)) {
29615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29616 }
29617 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29618 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29619 if (!SWIG_IsOK(res2)) {
29620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29621 }
29622 arg2 = reinterpret_cast< wxFont * >(argp2);
29623 if (arg1) (arg1)->font = *arg2;
29624
29625 resultobj = SWIG_Py_Void();
29626 return resultobj;
29627 fail:
29628 return NULL;
29629 }
29630
29631
29632 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29633 PyObject *resultobj = 0;
29634 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29635 wxFont *result = 0 ;
29636 void *argp1 = 0 ;
29637 int res1 = 0 ;
29638 PyObject *swig_obj[1] ;
29639
29640 if (!args) SWIG_fail;
29641 swig_obj[0] = args;
29642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29643 if (!SWIG_IsOK(res1)) {
29644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29645 }
29646 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29647 result = (wxFont *)& ((arg1)->font);
29648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29649 return resultobj;
29650 fail:
29651 return NULL;
29652 }
29653
29654
29655 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29656 PyObject *resultobj = 0;
29657 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29658 wxColour *arg2 = (wxColour *) 0 ;
29659 void *argp1 = 0 ;
29660 int res1 = 0 ;
29661 void *argp2 = 0 ;
29662 int res2 = 0 ;
29663 PyObject *swig_obj[2] ;
29664
29665 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29667 if (!SWIG_IsOK(res1)) {
29668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29669 }
29670 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29671 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29672 if (!SWIG_IsOK(res2)) {
29673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29674 }
29675 arg2 = reinterpret_cast< wxColour * >(argp2);
29676 if (arg1) (arg1)->colFg = *arg2;
29677
29678 resultobj = SWIG_Py_Void();
29679 return resultobj;
29680 fail:
29681 return NULL;
29682 }
29683
29684
29685 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29686 PyObject *resultobj = 0;
29687 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29688 wxColour *result = 0 ;
29689 void *argp1 = 0 ;
29690 int res1 = 0 ;
29691 PyObject *swig_obj[1] ;
29692
29693 if (!args) SWIG_fail;
29694 swig_obj[0] = args;
29695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29696 if (!SWIG_IsOK(res1)) {
29697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29698 }
29699 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29700 result = (wxColour *)& ((arg1)->colFg);
29701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29702 return resultobj;
29703 fail:
29704 return NULL;
29705 }
29706
29707
29708 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29709 PyObject *resultobj = 0;
29710 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29711 wxColour *arg2 = (wxColour *) 0 ;
29712 void *argp1 = 0 ;
29713 int res1 = 0 ;
29714 void *argp2 = 0 ;
29715 int res2 = 0 ;
29716 PyObject *swig_obj[2] ;
29717
29718 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29720 if (!SWIG_IsOK(res1)) {
29721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29722 }
29723 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29724 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29725 if (!SWIG_IsOK(res2)) {
29726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29727 }
29728 arg2 = reinterpret_cast< wxColour * >(argp2);
29729 if (arg1) (arg1)->colBg = *arg2;
29730
29731 resultobj = SWIG_Py_Void();
29732 return resultobj;
29733 fail:
29734 return NULL;
29735 }
29736
29737
29738 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29739 PyObject *resultobj = 0;
29740 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29741 wxColour *result = 0 ;
29742 void *argp1 = 0 ;
29743 int res1 = 0 ;
29744 PyObject *swig_obj[1] ;
29745
29746 if (!args) SWIG_fail;
29747 swig_obj[0] = args;
29748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29749 if (!SWIG_IsOK(res1)) {
29750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29751 }
29752 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29753 result = (wxColour *)& ((arg1)->colBg);
29754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29755 return resultobj;
29756 fail:
29757 return NULL;
29758 }
29759
29760
29761 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29762 PyObject *obj;
29763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29764 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29765 return SWIG_Py_Void();
29766 }
29767
29768 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29769 return SWIG_Python_InitShadowInstance(args);
29770 }
29771
29772 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29773 PyObject *resultobj = 0;
29774 wxWindow *arg1 = (wxWindow *) 0 ;
29775 int arg2 = (int) (int)-1 ;
29776 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29777 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29778 wxSize const &arg4_defvalue = wxDefaultSize ;
29779 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29780 long arg5 = (long) 0 ;
29781 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29782 wxString *arg6 = (wxString *) &arg6_defvalue ;
29783 wxWindow *result = 0 ;
29784 void *argp1 = 0 ;
29785 int res1 = 0 ;
29786 int val2 ;
29787 int ecode2 = 0 ;
29788 wxPoint temp3 ;
29789 wxSize temp4 ;
29790 long val5 ;
29791 int ecode5 = 0 ;
29792 bool temp6 = false ;
29793 PyObject * obj0 = 0 ;
29794 PyObject * obj1 = 0 ;
29795 PyObject * obj2 = 0 ;
29796 PyObject * obj3 = 0 ;
29797 PyObject * obj4 = 0 ;
29798 PyObject * obj5 = 0 ;
29799 char * kwnames[] = {
29800 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29801 };
29802
29803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29805 if (!SWIG_IsOK(res1)) {
29806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29807 }
29808 arg1 = reinterpret_cast< wxWindow * >(argp1);
29809 if (obj1) {
29810 ecode2 = SWIG_AsVal_int(obj1, &val2);
29811 if (!SWIG_IsOK(ecode2)) {
29812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29813 }
29814 arg2 = static_cast< int >(val2);
29815 }
29816 if (obj2) {
29817 {
29818 arg3 = &temp3;
29819 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29820 }
29821 }
29822 if (obj3) {
29823 {
29824 arg4 = &temp4;
29825 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29826 }
29827 }
29828 if (obj4) {
29829 ecode5 = SWIG_AsVal_long(obj4, &val5);
29830 if (!SWIG_IsOK(ecode5)) {
29831 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29832 }
29833 arg5 = static_cast< long >(val5);
29834 }
29835 if (obj5) {
29836 {
29837 arg6 = wxString_in_helper(obj5);
29838 if (arg6 == NULL) SWIG_fail;
29839 temp6 = true;
29840 }
29841 }
29842 {
29843 if (!wxPyCheckForApp()) SWIG_fail;
29844 PyThreadState* __tstate = wxPyBeginAllowThreads();
29845 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29846 wxPyEndAllowThreads(__tstate);
29847 if (PyErr_Occurred()) SWIG_fail;
29848 }
29849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29850 {
29851 if (temp6)
29852 delete arg6;
29853 }
29854 return resultobj;
29855 fail:
29856 {
29857 if (temp6)
29858 delete arg6;
29859 }
29860 return NULL;
29861 }
29862
29863
29864 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29865 PyObject *resultobj = 0;
29866 wxWindow *result = 0 ;
29867
29868 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29869 {
29870 if (!wxPyCheckForApp()) SWIG_fail;
29871 PyThreadState* __tstate = wxPyBeginAllowThreads();
29872 result = (wxWindow *)new wxWindow();
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29884 PyObject *resultobj = 0;
29885 wxWindow *arg1 = (wxWindow *) 0 ;
29886 wxWindow *arg2 = (wxWindow *) 0 ;
29887 int arg3 = (int) (int)-1 ;
29888 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29889 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29890 wxSize const &arg5_defvalue = wxDefaultSize ;
29891 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29892 long arg6 = (long) 0 ;
29893 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29894 wxString *arg7 = (wxString *) &arg7_defvalue ;
29895 bool result;
29896 void *argp1 = 0 ;
29897 int res1 = 0 ;
29898 void *argp2 = 0 ;
29899 int res2 = 0 ;
29900 int val3 ;
29901 int ecode3 = 0 ;
29902 wxPoint temp4 ;
29903 wxSize temp5 ;
29904 long val6 ;
29905 int ecode6 = 0 ;
29906 bool temp7 = false ;
29907 PyObject * obj0 = 0 ;
29908 PyObject * obj1 = 0 ;
29909 PyObject * obj2 = 0 ;
29910 PyObject * obj3 = 0 ;
29911 PyObject * obj4 = 0 ;
29912 PyObject * obj5 = 0 ;
29913 PyObject * obj6 = 0 ;
29914 char * kwnames[] = {
29915 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29916 };
29917
29918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29920 if (!SWIG_IsOK(res1)) {
29921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29922 }
29923 arg1 = reinterpret_cast< wxWindow * >(argp1);
29924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29925 if (!SWIG_IsOK(res2)) {
29926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29927 }
29928 arg2 = reinterpret_cast< wxWindow * >(argp2);
29929 if (obj2) {
29930 ecode3 = SWIG_AsVal_int(obj2, &val3);
29931 if (!SWIG_IsOK(ecode3)) {
29932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29933 }
29934 arg3 = static_cast< int >(val3);
29935 }
29936 if (obj3) {
29937 {
29938 arg4 = &temp4;
29939 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29940 }
29941 }
29942 if (obj4) {
29943 {
29944 arg5 = &temp5;
29945 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29946 }
29947 }
29948 if (obj5) {
29949 ecode6 = SWIG_AsVal_long(obj5, &val6);
29950 if (!SWIG_IsOK(ecode6)) {
29951 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29952 }
29953 arg6 = static_cast< long >(val6);
29954 }
29955 if (obj6) {
29956 {
29957 arg7 = wxString_in_helper(obj6);
29958 if (arg7 == NULL) SWIG_fail;
29959 temp7 = true;
29960 }
29961 }
29962 {
29963 PyThreadState* __tstate = wxPyBeginAllowThreads();
29964 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29965 wxPyEndAllowThreads(__tstate);
29966 if (PyErr_Occurred()) SWIG_fail;
29967 }
29968 {
29969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29970 }
29971 {
29972 if (temp7)
29973 delete arg7;
29974 }
29975 return resultobj;
29976 fail:
29977 {
29978 if (temp7)
29979 delete arg7;
29980 }
29981 return NULL;
29982 }
29983
29984
29985 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29986 PyObject *resultobj = 0;
29987 wxWindow *arg1 = (wxWindow *) 0 ;
29988 bool arg2 = (bool) false ;
29989 bool result;
29990 void *argp1 = 0 ;
29991 int res1 = 0 ;
29992 bool val2 ;
29993 int ecode2 = 0 ;
29994 PyObject * obj0 = 0 ;
29995 PyObject * obj1 = 0 ;
29996 char * kwnames[] = {
29997 (char *) "self",(char *) "force", NULL
29998 };
29999
30000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30002 if (!SWIG_IsOK(res1)) {
30003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30004 }
30005 arg1 = reinterpret_cast< wxWindow * >(argp1);
30006 if (obj1) {
30007 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30008 if (!SWIG_IsOK(ecode2)) {
30009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30010 }
30011 arg2 = static_cast< bool >(val2);
30012 }
30013 {
30014 PyThreadState* __tstate = wxPyBeginAllowThreads();
30015 result = (bool)(arg1)->Close(arg2);
30016 wxPyEndAllowThreads(__tstate);
30017 if (PyErr_Occurred()) SWIG_fail;
30018 }
30019 {
30020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30021 }
30022 return resultobj;
30023 fail:
30024 return NULL;
30025 }
30026
30027
30028 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30029 PyObject *resultobj = 0;
30030 wxWindow *arg1 = (wxWindow *) 0 ;
30031 bool result;
30032 void *argp1 = 0 ;
30033 int res1 = 0 ;
30034 PyObject *swig_obj[1] ;
30035
30036 if (!args) SWIG_fail;
30037 swig_obj[0] = args;
30038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30039 if (!SWIG_IsOK(res1)) {
30040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30041 }
30042 arg1 = reinterpret_cast< wxWindow * >(argp1);
30043 {
30044 PyThreadState* __tstate = wxPyBeginAllowThreads();
30045 result = (bool)(arg1)->Destroy();
30046 wxPyEndAllowThreads(__tstate);
30047 if (PyErr_Occurred()) SWIG_fail;
30048 }
30049 {
30050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30051 }
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30059 PyObject *resultobj = 0;
30060 wxWindow *arg1 = (wxWindow *) 0 ;
30061 bool result;
30062 void *argp1 = 0 ;
30063 int res1 = 0 ;
30064 PyObject *swig_obj[1] ;
30065
30066 if (!args) SWIG_fail;
30067 swig_obj[0] = args;
30068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30069 if (!SWIG_IsOK(res1)) {
30070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30071 }
30072 arg1 = reinterpret_cast< wxWindow * >(argp1);
30073 {
30074 PyThreadState* __tstate = wxPyBeginAllowThreads();
30075 result = (bool)(arg1)->DestroyChildren();
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 {
30080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30081 }
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30089 PyObject *resultobj = 0;
30090 wxWindow *arg1 = (wxWindow *) 0 ;
30091 bool result;
30092 void *argp1 = 0 ;
30093 int res1 = 0 ;
30094 PyObject *swig_obj[1] ;
30095
30096 if (!args) SWIG_fail;
30097 swig_obj[0] = args;
30098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30099 if (!SWIG_IsOK(res1)) {
30100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30101 }
30102 arg1 = reinterpret_cast< wxWindow * >(argp1);
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30106 wxPyEndAllowThreads(__tstate);
30107 if (PyErr_Occurred()) SWIG_fail;
30108 }
30109 {
30110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30111 }
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj = 0;
30120 wxWindow *arg1 = (wxWindow *) 0 ;
30121 wxString *arg2 = 0 ;
30122 void *argp1 = 0 ;
30123 int res1 = 0 ;
30124 bool temp2 = false ;
30125 PyObject * obj0 = 0 ;
30126 PyObject * obj1 = 0 ;
30127 char * kwnames[] = {
30128 (char *) "self",(char *) "label", NULL
30129 };
30130
30131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30133 if (!SWIG_IsOK(res1)) {
30134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30135 }
30136 arg1 = reinterpret_cast< wxWindow * >(argp1);
30137 {
30138 arg2 = wxString_in_helper(obj1);
30139 if (arg2 == NULL) SWIG_fail;
30140 temp2 = true;
30141 }
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 (arg1)->SetLabel((wxString const &)*arg2);
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_Py_Void();
30149 {
30150 if (temp2)
30151 delete arg2;
30152 }
30153 return resultobj;
30154 fail:
30155 {
30156 if (temp2)
30157 delete arg2;
30158 }
30159 return NULL;
30160 }
30161
30162
30163 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30164 PyObject *resultobj = 0;
30165 wxWindow *arg1 = (wxWindow *) 0 ;
30166 wxString result;
30167 void *argp1 = 0 ;
30168 int res1 = 0 ;
30169 PyObject *swig_obj[1] ;
30170
30171 if (!args) SWIG_fail;
30172 swig_obj[0] = args;
30173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30174 if (!SWIG_IsOK(res1)) {
30175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30176 }
30177 arg1 = reinterpret_cast< wxWindow * >(argp1);
30178 {
30179 PyThreadState* __tstate = wxPyBeginAllowThreads();
30180 result = ((wxWindow const *)arg1)->GetLabel();
30181 wxPyEndAllowThreads(__tstate);
30182 if (PyErr_Occurred()) SWIG_fail;
30183 }
30184 {
30185 #if wxUSE_UNICODE
30186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30187 #else
30188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30189 #endif
30190 }
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30198 PyObject *resultobj = 0;
30199 wxWindow *arg1 = (wxWindow *) 0 ;
30200 wxString *arg2 = 0 ;
30201 void *argp1 = 0 ;
30202 int res1 = 0 ;
30203 bool temp2 = false ;
30204 PyObject * obj0 = 0 ;
30205 PyObject * obj1 = 0 ;
30206 char * kwnames[] = {
30207 (char *) "self",(char *) "name", NULL
30208 };
30209
30210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30212 if (!SWIG_IsOK(res1)) {
30213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30214 }
30215 arg1 = reinterpret_cast< wxWindow * >(argp1);
30216 {
30217 arg2 = wxString_in_helper(obj1);
30218 if (arg2 == NULL) SWIG_fail;
30219 temp2 = true;
30220 }
30221 {
30222 PyThreadState* __tstate = wxPyBeginAllowThreads();
30223 (arg1)->SetName((wxString const &)*arg2);
30224 wxPyEndAllowThreads(__tstate);
30225 if (PyErr_Occurred()) SWIG_fail;
30226 }
30227 resultobj = SWIG_Py_Void();
30228 {
30229 if (temp2)
30230 delete arg2;
30231 }
30232 return resultobj;
30233 fail:
30234 {
30235 if (temp2)
30236 delete arg2;
30237 }
30238 return NULL;
30239 }
30240
30241
30242 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30243 PyObject *resultobj = 0;
30244 wxWindow *arg1 = (wxWindow *) 0 ;
30245 wxString result;
30246 void *argp1 = 0 ;
30247 int res1 = 0 ;
30248 PyObject *swig_obj[1] ;
30249
30250 if (!args) SWIG_fail;
30251 swig_obj[0] = args;
30252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30253 if (!SWIG_IsOK(res1)) {
30254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30255 }
30256 arg1 = reinterpret_cast< wxWindow * >(argp1);
30257 {
30258 PyThreadState* __tstate = wxPyBeginAllowThreads();
30259 result = ((wxWindow const *)arg1)->GetName();
30260 wxPyEndAllowThreads(__tstate);
30261 if (PyErr_Occurred()) SWIG_fail;
30262 }
30263 {
30264 #if wxUSE_UNICODE
30265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30266 #else
30267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30268 #endif
30269 }
30270 return resultobj;
30271 fail:
30272 return NULL;
30273 }
30274
30275
30276 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30277 PyObject *resultobj = 0;
30278 wxWindow *arg1 = (wxWindow *) 0 ;
30279 wxWindowVariant arg2 ;
30280 void *argp1 = 0 ;
30281 int res1 = 0 ;
30282 int val2 ;
30283 int ecode2 = 0 ;
30284 PyObject * obj0 = 0 ;
30285 PyObject * obj1 = 0 ;
30286 char * kwnames[] = {
30287 (char *) "self",(char *) "variant", NULL
30288 };
30289
30290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30292 if (!SWIG_IsOK(res1)) {
30293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30294 }
30295 arg1 = reinterpret_cast< wxWindow * >(argp1);
30296 ecode2 = SWIG_AsVal_int(obj1, &val2);
30297 if (!SWIG_IsOK(ecode2)) {
30298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30299 }
30300 arg2 = static_cast< wxWindowVariant >(val2);
30301 {
30302 PyThreadState* __tstate = wxPyBeginAllowThreads();
30303 (arg1)->SetWindowVariant(arg2);
30304 wxPyEndAllowThreads(__tstate);
30305 if (PyErr_Occurred()) SWIG_fail;
30306 }
30307 resultobj = SWIG_Py_Void();
30308 return resultobj;
30309 fail:
30310 return NULL;
30311 }
30312
30313
30314 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30315 PyObject *resultobj = 0;
30316 wxWindow *arg1 = (wxWindow *) 0 ;
30317 wxWindowVariant result;
30318 void *argp1 = 0 ;
30319 int res1 = 0 ;
30320 PyObject *swig_obj[1] ;
30321
30322 if (!args) SWIG_fail;
30323 swig_obj[0] = args;
30324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30325 if (!SWIG_IsOK(res1)) {
30326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30327 }
30328 arg1 = reinterpret_cast< wxWindow * >(argp1);
30329 {
30330 PyThreadState* __tstate = wxPyBeginAllowThreads();
30331 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30332 wxPyEndAllowThreads(__tstate);
30333 if (PyErr_Occurred()) SWIG_fail;
30334 }
30335 resultobj = SWIG_From_int(static_cast< int >(result));
30336 return resultobj;
30337 fail:
30338 return NULL;
30339 }
30340
30341
30342 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30343 PyObject *resultobj = 0;
30344 wxWindow *arg1 = (wxWindow *) 0 ;
30345 int arg2 ;
30346 void *argp1 = 0 ;
30347 int res1 = 0 ;
30348 int val2 ;
30349 int ecode2 = 0 ;
30350 PyObject * obj0 = 0 ;
30351 PyObject * obj1 = 0 ;
30352 char * kwnames[] = {
30353 (char *) "self",(char *) "winid", NULL
30354 };
30355
30356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30358 if (!SWIG_IsOK(res1)) {
30359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30360 }
30361 arg1 = reinterpret_cast< wxWindow * >(argp1);
30362 ecode2 = SWIG_AsVal_int(obj1, &val2);
30363 if (!SWIG_IsOK(ecode2)) {
30364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30365 }
30366 arg2 = static_cast< int >(val2);
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 (arg1)->SetId(arg2);
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 resultobj = SWIG_Py_Void();
30374 return resultobj;
30375 fail:
30376 return NULL;
30377 }
30378
30379
30380 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30381 PyObject *resultobj = 0;
30382 wxWindow *arg1 = (wxWindow *) 0 ;
30383 int result;
30384 void *argp1 = 0 ;
30385 int res1 = 0 ;
30386 PyObject *swig_obj[1] ;
30387
30388 if (!args) SWIG_fail;
30389 swig_obj[0] = args;
30390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30391 if (!SWIG_IsOK(res1)) {
30392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30393 }
30394 arg1 = reinterpret_cast< wxWindow * >(argp1);
30395 {
30396 PyThreadState* __tstate = wxPyBeginAllowThreads();
30397 result = (int)((wxWindow const *)arg1)->GetId();
30398 wxPyEndAllowThreads(__tstate);
30399 if (PyErr_Occurred()) SWIG_fail;
30400 }
30401 resultobj = SWIG_From_int(static_cast< int >(result));
30402 return resultobj;
30403 fail:
30404 return NULL;
30405 }
30406
30407
30408 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30409 PyObject *resultobj = 0;
30410 int result;
30411
30412 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30413 {
30414 PyThreadState* __tstate = wxPyBeginAllowThreads();
30415 result = (int)wxWindow::NewControlId();
30416 wxPyEndAllowThreads(__tstate);
30417 if (PyErr_Occurred()) SWIG_fail;
30418 }
30419 resultobj = SWIG_From_int(static_cast< int >(result));
30420 return resultobj;
30421 fail:
30422 return NULL;
30423 }
30424
30425
30426 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30427 PyObject *resultobj = 0;
30428 int arg1 ;
30429 int result;
30430 int val1 ;
30431 int ecode1 = 0 ;
30432 PyObject * obj0 = 0 ;
30433 char * kwnames[] = {
30434 (char *) "winid", NULL
30435 };
30436
30437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30438 ecode1 = SWIG_AsVal_int(obj0, &val1);
30439 if (!SWIG_IsOK(ecode1)) {
30440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30441 }
30442 arg1 = static_cast< int >(val1);
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 result = (int)wxWindow::NextControlId(arg1);
30446 wxPyEndAllowThreads(__tstate);
30447 if (PyErr_Occurred()) SWIG_fail;
30448 }
30449 resultobj = SWIG_From_int(static_cast< int >(result));
30450 return resultobj;
30451 fail:
30452 return NULL;
30453 }
30454
30455
30456 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30457 PyObject *resultobj = 0;
30458 int arg1 ;
30459 int result;
30460 int val1 ;
30461 int ecode1 = 0 ;
30462 PyObject * obj0 = 0 ;
30463 char * kwnames[] = {
30464 (char *) "winid", NULL
30465 };
30466
30467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30468 ecode1 = SWIG_AsVal_int(obj0, &val1);
30469 if (!SWIG_IsOK(ecode1)) {
30470 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30471 }
30472 arg1 = static_cast< int >(val1);
30473 {
30474 PyThreadState* __tstate = wxPyBeginAllowThreads();
30475 result = (int)wxWindow::PrevControlId(arg1);
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 resultobj = SWIG_From_int(static_cast< int >(result));
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj = 0;
30488 wxWindow *arg1 = (wxWindow *) 0 ;
30489 wxSize *arg2 = 0 ;
30490 void *argp1 = 0 ;
30491 int res1 = 0 ;
30492 wxSize temp2 ;
30493 PyObject * obj0 = 0 ;
30494 PyObject * obj1 = 0 ;
30495 char * kwnames[] = {
30496 (char *) "self",(char *) "size", NULL
30497 };
30498
30499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30501 if (!SWIG_IsOK(res1)) {
30502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30503 }
30504 arg1 = reinterpret_cast< wxWindow * >(argp1);
30505 {
30506 arg2 = &temp2;
30507 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30508 }
30509 {
30510 PyThreadState* __tstate = wxPyBeginAllowThreads();
30511 (arg1)->SetSize((wxSize const &)*arg2);
30512 wxPyEndAllowThreads(__tstate);
30513 if (PyErr_Occurred()) SWIG_fail;
30514 }
30515 resultobj = SWIG_Py_Void();
30516 return resultobj;
30517 fail:
30518 return NULL;
30519 }
30520
30521
30522 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30523 PyObject *resultobj = 0;
30524 wxWindow *arg1 = (wxWindow *) 0 ;
30525 int arg2 ;
30526 int arg3 ;
30527 int arg4 ;
30528 int arg5 ;
30529 int arg6 = (int) wxSIZE_AUTO ;
30530 void *argp1 = 0 ;
30531 int res1 = 0 ;
30532 int val2 ;
30533 int ecode2 = 0 ;
30534 int val3 ;
30535 int ecode3 = 0 ;
30536 int val4 ;
30537 int ecode4 = 0 ;
30538 int val5 ;
30539 int ecode5 = 0 ;
30540 int val6 ;
30541 int ecode6 = 0 ;
30542 PyObject * obj0 = 0 ;
30543 PyObject * obj1 = 0 ;
30544 PyObject * obj2 = 0 ;
30545 PyObject * obj3 = 0 ;
30546 PyObject * obj4 = 0 ;
30547 PyObject * obj5 = 0 ;
30548 char * kwnames[] = {
30549 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30550 };
30551
30552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30554 if (!SWIG_IsOK(res1)) {
30555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30556 }
30557 arg1 = reinterpret_cast< wxWindow * >(argp1);
30558 ecode2 = SWIG_AsVal_int(obj1, &val2);
30559 if (!SWIG_IsOK(ecode2)) {
30560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30561 }
30562 arg2 = static_cast< int >(val2);
30563 ecode3 = SWIG_AsVal_int(obj2, &val3);
30564 if (!SWIG_IsOK(ecode3)) {
30565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30566 }
30567 arg3 = static_cast< int >(val3);
30568 ecode4 = SWIG_AsVal_int(obj3, &val4);
30569 if (!SWIG_IsOK(ecode4)) {
30570 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30571 }
30572 arg4 = static_cast< int >(val4);
30573 ecode5 = SWIG_AsVal_int(obj4, &val5);
30574 if (!SWIG_IsOK(ecode5)) {
30575 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30576 }
30577 arg5 = static_cast< int >(val5);
30578 if (obj5) {
30579 ecode6 = SWIG_AsVal_int(obj5, &val6);
30580 if (!SWIG_IsOK(ecode6)) {
30581 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30582 }
30583 arg6 = static_cast< int >(val6);
30584 }
30585 {
30586 PyThreadState* __tstate = wxPyBeginAllowThreads();
30587 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 resultobj = SWIG_Py_Void();
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30599 PyObject *resultobj = 0;
30600 wxWindow *arg1 = (wxWindow *) 0 ;
30601 wxRect *arg2 = 0 ;
30602 int arg3 = (int) wxSIZE_AUTO ;
30603 void *argp1 = 0 ;
30604 int res1 = 0 ;
30605 wxRect temp2 ;
30606 int val3 ;
30607 int ecode3 = 0 ;
30608 PyObject * obj0 = 0 ;
30609 PyObject * obj1 = 0 ;
30610 PyObject * obj2 = 0 ;
30611 char * kwnames[] = {
30612 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30613 };
30614
30615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30617 if (!SWIG_IsOK(res1)) {
30618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30619 }
30620 arg1 = reinterpret_cast< wxWindow * >(argp1);
30621 {
30622 arg2 = &temp2;
30623 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30624 }
30625 if (obj2) {
30626 ecode3 = SWIG_AsVal_int(obj2, &val3);
30627 if (!SWIG_IsOK(ecode3)) {
30628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30629 }
30630 arg3 = static_cast< int >(val3);
30631 }
30632 {
30633 PyThreadState* __tstate = wxPyBeginAllowThreads();
30634 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30635 wxPyEndAllowThreads(__tstate);
30636 if (PyErr_Occurred()) SWIG_fail;
30637 }
30638 resultobj = SWIG_Py_Void();
30639 return resultobj;
30640 fail:
30641 return NULL;
30642 }
30643
30644
30645 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30646 PyObject *resultobj = 0;
30647 wxWindow *arg1 = (wxWindow *) 0 ;
30648 int arg2 ;
30649 int arg3 ;
30650 void *argp1 = 0 ;
30651 int res1 = 0 ;
30652 int val2 ;
30653 int ecode2 = 0 ;
30654 int val3 ;
30655 int ecode3 = 0 ;
30656 PyObject * obj0 = 0 ;
30657 PyObject * obj1 = 0 ;
30658 PyObject * obj2 = 0 ;
30659 char * kwnames[] = {
30660 (char *) "self",(char *) "width",(char *) "height", NULL
30661 };
30662
30663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30665 if (!SWIG_IsOK(res1)) {
30666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30667 }
30668 arg1 = reinterpret_cast< wxWindow * >(argp1);
30669 ecode2 = SWIG_AsVal_int(obj1, &val2);
30670 if (!SWIG_IsOK(ecode2)) {
30671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30672 }
30673 arg2 = static_cast< int >(val2);
30674 ecode3 = SWIG_AsVal_int(obj2, &val3);
30675 if (!SWIG_IsOK(ecode3)) {
30676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30677 }
30678 arg3 = static_cast< int >(val3);
30679 {
30680 PyThreadState* __tstate = wxPyBeginAllowThreads();
30681 (arg1)->SetSize(arg2,arg3);
30682 wxPyEndAllowThreads(__tstate);
30683 if (PyErr_Occurred()) SWIG_fail;
30684 }
30685 resultobj = SWIG_Py_Void();
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj = 0;
30694 wxWindow *arg1 = (wxWindow *) 0 ;
30695 wxPoint *arg2 = 0 ;
30696 int arg3 = (int) wxSIZE_USE_EXISTING ;
30697 void *argp1 = 0 ;
30698 int res1 = 0 ;
30699 wxPoint temp2 ;
30700 int val3 ;
30701 int ecode3 = 0 ;
30702 PyObject * obj0 = 0 ;
30703 PyObject * obj1 = 0 ;
30704 PyObject * obj2 = 0 ;
30705 char * kwnames[] = {
30706 (char *) "self",(char *) "pt",(char *) "flags", NULL
30707 };
30708
30709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30711 if (!SWIG_IsOK(res1)) {
30712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30713 }
30714 arg1 = reinterpret_cast< wxWindow * >(argp1);
30715 {
30716 arg2 = &temp2;
30717 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30718 }
30719 if (obj2) {
30720 ecode3 = SWIG_AsVal_int(obj2, &val3);
30721 if (!SWIG_IsOK(ecode3)) {
30722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30723 }
30724 arg3 = static_cast< int >(val3);
30725 }
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 (arg1)->Move((wxPoint const &)*arg2,arg3);
30729 wxPyEndAllowThreads(__tstate);
30730 if (PyErr_Occurred()) SWIG_fail;
30731 }
30732 resultobj = SWIG_Py_Void();
30733 return resultobj;
30734 fail:
30735 return NULL;
30736 }
30737
30738
30739 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30740 PyObject *resultobj = 0;
30741 wxWindow *arg1 = (wxWindow *) 0 ;
30742 int arg2 ;
30743 int arg3 ;
30744 int arg4 = (int) wxSIZE_USE_EXISTING ;
30745 void *argp1 = 0 ;
30746 int res1 = 0 ;
30747 int val2 ;
30748 int ecode2 = 0 ;
30749 int val3 ;
30750 int ecode3 = 0 ;
30751 int val4 ;
30752 int ecode4 = 0 ;
30753 PyObject * obj0 = 0 ;
30754 PyObject * obj1 = 0 ;
30755 PyObject * obj2 = 0 ;
30756 PyObject * obj3 = 0 ;
30757 char * kwnames[] = {
30758 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30759 };
30760
30761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30763 if (!SWIG_IsOK(res1)) {
30764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30765 }
30766 arg1 = reinterpret_cast< wxWindow * >(argp1);
30767 ecode2 = SWIG_AsVal_int(obj1, &val2);
30768 if (!SWIG_IsOK(ecode2)) {
30769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30770 }
30771 arg2 = static_cast< int >(val2);
30772 ecode3 = SWIG_AsVal_int(obj2, &val3);
30773 if (!SWIG_IsOK(ecode3)) {
30774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30775 }
30776 arg3 = static_cast< int >(val3);
30777 if (obj3) {
30778 ecode4 = SWIG_AsVal_int(obj3, &val4);
30779 if (!SWIG_IsOK(ecode4)) {
30780 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30781 }
30782 arg4 = static_cast< int >(val4);
30783 }
30784 {
30785 PyThreadState* __tstate = wxPyBeginAllowThreads();
30786 (arg1)->Move(arg2,arg3,arg4);
30787 wxPyEndAllowThreads(__tstate);
30788 if (PyErr_Occurred()) SWIG_fail;
30789 }
30790 resultobj = SWIG_Py_Void();
30791 return resultobj;
30792 fail:
30793 return NULL;
30794 }
30795
30796
30797 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30798 PyObject *resultobj = 0;
30799 wxWindow *arg1 = (wxWindow *) 0 ;
30800 wxSize const &arg2_defvalue = wxDefaultSize ;
30801 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30802 void *argp1 = 0 ;
30803 int res1 = 0 ;
30804 wxSize temp2 ;
30805 PyObject * obj0 = 0 ;
30806 PyObject * obj1 = 0 ;
30807 char * kwnames[] = {
30808 (char *) "self",(char *) "size", NULL
30809 };
30810
30811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30813 if (!SWIG_IsOK(res1)) {
30814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30815 }
30816 arg1 = reinterpret_cast< wxWindow * >(argp1);
30817 if (obj1) {
30818 {
30819 arg2 = &temp2;
30820 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30821 }
30822 }
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30826 wxPyEndAllowThreads(__tstate);
30827 if (PyErr_Occurred()) SWIG_fail;
30828 }
30829 resultobj = SWIG_Py_Void();
30830 return resultobj;
30831 fail:
30832 return NULL;
30833 }
30834
30835
30836 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30837 PyObject *resultobj = 0;
30838 wxWindow *arg1 = (wxWindow *) 0 ;
30839 void *argp1 = 0 ;
30840 int res1 = 0 ;
30841 PyObject *swig_obj[1] ;
30842
30843 if (!args) SWIG_fail;
30844 swig_obj[0] = args;
30845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30846 if (!SWIG_IsOK(res1)) {
30847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30848 }
30849 arg1 = reinterpret_cast< wxWindow * >(argp1);
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 (arg1)->Raise();
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = SWIG_Py_Void();
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30864 PyObject *resultobj = 0;
30865 wxWindow *arg1 = (wxWindow *) 0 ;
30866 void *argp1 = 0 ;
30867 int res1 = 0 ;
30868 PyObject *swig_obj[1] ;
30869
30870 if (!args) SWIG_fail;
30871 swig_obj[0] = args;
30872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30873 if (!SWIG_IsOK(res1)) {
30874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30875 }
30876 arg1 = reinterpret_cast< wxWindow * >(argp1);
30877 {
30878 PyThreadState* __tstate = wxPyBeginAllowThreads();
30879 (arg1)->Lower();
30880 wxPyEndAllowThreads(__tstate);
30881 if (PyErr_Occurred()) SWIG_fail;
30882 }
30883 resultobj = SWIG_Py_Void();
30884 return resultobj;
30885 fail:
30886 return NULL;
30887 }
30888
30889
30890 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30891 PyObject *resultobj = 0;
30892 wxWindow *arg1 = (wxWindow *) 0 ;
30893 wxSize *arg2 = 0 ;
30894 void *argp1 = 0 ;
30895 int res1 = 0 ;
30896 wxSize temp2 ;
30897 PyObject * obj0 = 0 ;
30898 PyObject * obj1 = 0 ;
30899 char * kwnames[] = {
30900 (char *) "self",(char *) "size", NULL
30901 };
30902
30903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30907 }
30908 arg1 = reinterpret_cast< wxWindow * >(argp1);
30909 {
30910 arg2 = &temp2;
30911 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30912 }
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 (arg1)->SetClientSize((wxSize const &)*arg2);
30916 wxPyEndAllowThreads(__tstate);
30917 if (PyErr_Occurred()) SWIG_fail;
30918 }
30919 resultobj = SWIG_Py_Void();
30920 return resultobj;
30921 fail:
30922 return NULL;
30923 }
30924
30925
30926 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30927 PyObject *resultobj = 0;
30928 wxWindow *arg1 = (wxWindow *) 0 ;
30929 int arg2 ;
30930 int arg3 ;
30931 void *argp1 = 0 ;
30932 int res1 = 0 ;
30933 int val2 ;
30934 int ecode2 = 0 ;
30935 int val3 ;
30936 int ecode3 = 0 ;
30937 PyObject * obj0 = 0 ;
30938 PyObject * obj1 = 0 ;
30939 PyObject * obj2 = 0 ;
30940 char * kwnames[] = {
30941 (char *) "self",(char *) "width",(char *) "height", NULL
30942 };
30943
30944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30946 if (!SWIG_IsOK(res1)) {
30947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30948 }
30949 arg1 = reinterpret_cast< wxWindow * >(argp1);
30950 ecode2 = SWIG_AsVal_int(obj1, &val2);
30951 if (!SWIG_IsOK(ecode2)) {
30952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30953 }
30954 arg2 = static_cast< int >(val2);
30955 ecode3 = SWIG_AsVal_int(obj2, &val3);
30956 if (!SWIG_IsOK(ecode3)) {
30957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30958 }
30959 arg3 = static_cast< int >(val3);
30960 {
30961 PyThreadState* __tstate = wxPyBeginAllowThreads();
30962 (arg1)->SetClientSize(arg2,arg3);
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 resultobj = SWIG_Py_Void();
30967 return resultobj;
30968 fail:
30969 return NULL;
30970 }
30971
30972
30973 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30974 PyObject *resultobj = 0;
30975 wxWindow *arg1 = (wxWindow *) 0 ;
30976 wxRect *arg2 = 0 ;
30977 void *argp1 = 0 ;
30978 int res1 = 0 ;
30979 wxRect temp2 ;
30980 PyObject * obj0 = 0 ;
30981 PyObject * obj1 = 0 ;
30982 char * kwnames[] = {
30983 (char *) "self",(char *) "rect", NULL
30984 };
30985
30986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30988 if (!SWIG_IsOK(res1)) {
30989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30990 }
30991 arg1 = reinterpret_cast< wxWindow * >(argp1);
30992 {
30993 arg2 = &temp2;
30994 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30995 }
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 (arg1)->SetClientSize((wxRect const &)*arg2);
30999 wxPyEndAllowThreads(__tstate);
31000 if (PyErr_Occurred()) SWIG_fail;
31001 }
31002 resultobj = SWIG_Py_Void();
31003 return resultobj;
31004 fail:
31005 return NULL;
31006 }
31007
31008
31009 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31010 PyObject *resultobj = 0;
31011 wxWindow *arg1 = (wxWindow *) 0 ;
31012 wxPoint result;
31013 void *argp1 = 0 ;
31014 int res1 = 0 ;
31015 PyObject *swig_obj[1] ;
31016
31017 if (!args) SWIG_fail;
31018 swig_obj[0] = args;
31019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31020 if (!SWIG_IsOK(res1)) {
31021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31022 }
31023 arg1 = reinterpret_cast< wxWindow * >(argp1);
31024 {
31025 PyThreadState* __tstate = wxPyBeginAllowThreads();
31026 result = ((wxWindow const *)arg1)->GetPosition();
31027 wxPyEndAllowThreads(__tstate);
31028 if (PyErr_Occurred()) SWIG_fail;
31029 }
31030 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31031 return resultobj;
31032 fail:
31033 return NULL;
31034 }
31035
31036
31037 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31038 PyObject *resultobj = 0;
31039 wxWindow *arg1 = (wxWindow *) 0 ;
31040 int *arg2 = (int *) 0 ;
31041 int *arg3 = (int *) 0 ;
31042 void *argp1 = 0 ;
31043 int res1 = 0 ;
31044 int temp2 ;
31045 int res2 = SWIG_TMPOBJ ;
31046 int temp3 ;
31047 int res3 = SWIG_TMPOBJ ;
31048 PyObject *swig_obj[1] ;
31049
31050 arg2 = &temp2;
31051 arg3 = &temp3;
31052 if (!args) SWIG_fail;
31053 swig_obj[0] = args;
31054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31055 if (!SWIG_IsOK(res1)) {
31056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31057 }
31058 arg1 = reinterpret_cast< wxWindow * >(argp1);
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31062 wxPyEndAllowThreads(__tstate);
31063 if (PyErr_Occurred()) SWIG_fail;
31064 }
31065 resultobj = SWIG_Py_Void();
31066 if (SWIG_IsTmpObj(res2)) {
31067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31068 } else {
31069 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31071 }
31072 if (SWIG_IsTmpObj(res3)) {
31073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31074 } else {
31075 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31077 }
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31085 PyObject *resultobj = 0;
31086 wxWindow *arg1 = (wxWindow *) 0 ;
31087 wxPoint result;
31088 void *argp1 = 0 ;
31089 int res1 = 0 ;
31090 PyObject *swig_obj[1] ;
31091
31092 if (!args) SWIG_fail;
31093 swig_obj[0] = args;
31094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31095 if (!SWIG_IsOK(res1)) {
31096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31097 }
31098 arg1 = reinterpret_cast< wxWindow * >(argp1);
31099 {
31100 PyThreadState* __tstate = wxPyBeginAllowThreads();
31101 result = ((wxWindow const *)arg1)->GetScreenPosition();
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31106 return resultobj;
31107 fail:
31108 return NULL;
31109 }
31110
31111
31112 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31113 PyObject *resultobj = 0;
31114 wxWindow *arg1 = (wxWindow *) 0 ;
31115 int *arg2 = (int *) 0 ;
31116 int *arg3 = (int *) 0 ;
31117 void *argp1 = 0 ;
31118 int res1 = 0 ;
31119 int temp2 ;
31120 int res2 = SWIG_TMPOBJ ;
31121 int temp3 ;
31122 int res3 = SWIG_TMPOBJ ;
31123 PyObject *swig_obj[1] ;
31124
31125 arg2 = &temp2;
31126 arg3 = &temp3;
31127 if (!args) SWIG_fail;
31128 swig_obj[0] = args;
31129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31130 if (!SWIG_IsOK(res1)) {
31131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31132 }
31133 arg1 = reinterpret_cast< wxWindow * >(argp1);
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31137 wxPyEndAllowThreads(__tstate);
31138 if (PyErr_Occurred()) SWIG_fail;
31139 }
31140 resultobj = SWIG_Py_Void();
31141 if (SWIG_IsTmpObj(res2)) {
31142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31143 } else {
31144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31146 }
31147 if (SWIG_IsTmpObj(res3)) {
31148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31149 } else {
31150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31152 }
31153 return resultobj;
31154 fail:
31155 return NULL;
31156 }
31157
31158
31159 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31160 PyObject *resultobj = 0;
31161 wxWindow *arg1 = (wxWindow *) 0 ;
31162 wxRect result;
31163 void *argp1 = 0 ;
31164 int res1 = 0 ;
31165 PyObject *swig_obj[1] ;
31166
31167 if (!args) SWIG_fail;
31168 swig_obj[0] = args;
31169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31170 if (!SWIG_IsOK(res1)) {
31171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31172 }
31173 arg1 = reinterpret_cast< wxWindow * >(argp1);
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 result = ((wxWindow const *)arg1)->GetScreenRect();
31177 wxPyEndAllowThreads(__tstate);
31178 if (PyErr_Occurred()) SWIG_fail;
31179 }
31180 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31188 PyObject *resultobj = 0;
31189 wxWindow *arg1 = (wxWindow *) 0 ;
31190 wxSize result;
31191 void *argp1 = 0 ;
31192 int res1 = 0 ;
31193 PyObject *swig_obj[1] ;
31194
31195 if (!args) SWIG_fail;
31196 swig_obj[0] = args;
31197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31198 if (!SWIG_IsOK(res1)) {
31199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31200 }
31201 arg1 = reinterpret_cast< wxWindow * >(argp1);
31202 {
31203 PyThreadState* __tstate = wxPyBeginAllowThreads();
31204 result = ((wxWindow const *)arg1)->GetSize();
31205 wxPyEndAllowThreads(__tstate);
31206 if (PyErr_Occurred()) SWIG_fail;
31207 }
31208 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31209 return resultobj;
31210 fail:
31211 return NULL;
31212 }
31213
31214
31215 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31216 PyObject *resultobj = 0;
31217 wxWindow *arg1 = (wxWindow *) 0 ;
31218 int *arg2 = (int *) 0 ;
31219 int *arg3 = (int *) 0 ;
31220 void *argp1 = 0 ;
31221 int res1 = 0 ;
31222 int temp2 ;
31223 int res2 = SWIG_TMPOBJ ;
31224 int temp3 ;
31225 int res3 = SWIG_TMPOBJ ;
31226 PyObject *swig_obj[1] ;
31227
31228 arg2 = &temp2;
31229 arg3 = &temp3;
31230 if (!args) SWIG_fail;
31231 swig_obj[0] = args;
31232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31233 if (!SWIG_IsOK(res1)) {
31234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31235 }
31236 arg1 = reinterpret_cast< wxWindow * >(argp1);
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 resultobj = SWIG_Py_Void();
31244 if (SWIG_IsTmpObj(res2)) {
31245 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31246 } else {
31247 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31249 }
31250 if (SWIG_IsTmpObj(res3)) {
31251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31252 } else {
31253 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31255 }
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31263 PyObject *resultobj = 0;
31264 wxWindow *arg1 = (wxWindow *) 0 ;
31265 wxRect result;
31266 void *argp1 = 0 ;
31267 int res1 = 0 ;
31268 PyObject *swig_obj[1] ;
31269
31270 if (!args) SWIG_fail;
31271 swig_obj[0] = args;
31272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31273 if (!SWIG_IsOK(res1)) {
31274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31275 }
31276 arg1 = reinterpret_cast< wxWindow * >(argp1);
31277 {
31278 PyThreadState* __tstate = wxPyBeginAllowThreads();
31279 result = ((wxWindow const *)arg1)->GetRect();
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31291 PyObject *resultobj = 0;
31292 wxWindow *arg1 = (wxWindow *) 0 ;
31293 wxSize result;
31294 void *argp1 = 0 ;
31295 int res1 = 0 ;
31296 PyObject *swig_obj[1] ;
31297
31298 if (!args) SWIG_fail;
31299 swig_obj[0] = args;
31300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31301 if (!SWIG_IsOK(res1)) {
31302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31303 }
31304 arg1 = reinterpret_cast< wxWindow * >(argp1);
31305 {
31306 PyThreadState* __tstate = wxPyBeginAllowThreads();
31307 result = ((wxWindow const *)arg1)->GetClientSize();
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31319 PyObject *resultobj = 0;
31320 wxWindow *arg1 = (wxWindow *) 0 ;
31321 int *arg2 = (int *) 0 ;
31322 int *arg3 = (int *) 0 ;
31323 void *argp1 = 0 ;
31324 int res1 = 0 ;
31325 int temp2 ;
31326 int res2 = SWIG_TMPOBJ ;
31327 int temp3 ;
31328 int res3 = SWIG_TMPOBJ ;
31329 PyObject *swig_obj[1] ;
31330
31331 arg2 = &temp2;
31332 arg3 = &temp3;
31333 if (!args) SWIG_fail;
31334 swig_obj[0] = args;
31335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31336 if (!SWIG_IsOK(res1)) {
31337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31338 }
31339 arg1 = reinterpret_cast< wxWindow * >(argp1);
31340 {
31341 PyThreadState* __tstate = wxPyBeginAllowThreads();
31342 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31343 wxPyEndAllowThreads(__tstate);
31344 if (PyErr_Occurred()) SWIG_fail;
31345 }
31346 resultobj = SWIG_Py_Void();
31347 if (SWIG_IsTmpObj(res2)) {
31348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31349 } else {
31350 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31352 }
31353 if (SWIG_IsTmpObj(res3)) {
31354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31355 } else {
31356 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31358 }
31359 return resultobj;
31360 fail:
31361 return NULL;
31362 }
31363
31364
31365 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31366 PyObject *resultobj = 0;
31367 wxWindow *arg1 = (wxWindow *) 0 ;
31368 wxPoint result;
31369 void *argp1 = 0 ;
31370 int res1 = 0 ;
31371 PyObject *swig_obj[1] ;
31372
31373 if (!args) SWIG_fail;
31374 swig_obj[0] = args;
31375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31376 if (!SWIG_IsOK(res1)) {
31377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31378 }
31379 arg1 = reinterpret_cast< wxWindow * >(argp1);
31380 {
31381 PyThreadState* __tstate = wxPyBeginAllowThreads();
31382 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31383 wxPyEndAllowThreads(__tstate);
31384 if (PyErr_Occurred()) SWIG_fail;
31385 }
31386 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31387 return resultobj;
31388 fail:
31389 return NULL;
31390 }
31391
31392
31393 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31394 PyObject *resultobj = 0;
31395 wxWindow *arg1 = (wxWindow *) 0 ;
31396 wxRect result;
31397 void *argp1 = 0 ;
31398 int res1 = 0 ;
31399 PyObject *swig_obj[1] ;
31400
31401 if (!args) SWIG_fail;
31402 swig_obj[0] = args;
31403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31404 if (!SWIG_IsOK(res1)) {
31405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31406 }
31407 arg1 = reinterpret_cast< wxWindow * >(argp1);
31408 {
31409 PyThreadState* __tstate = wxPyBeginAllowThreads();
31410 result = ((wxWindow const *)arg1)->GetClientRect();
31411 wxPyEndAllowThreads(__tstate);
31412 if (PyErr_Occurred()) SWIG_fail;
31413 }
31414 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31415 return resultobj;
31416 fail:
31417 return NULL;
31418 }
31419
31420
31421 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31422 PyObject *resultobj = 0;
31423 wxWindow *arg1 = (wxWindow *) 0 ;
31424 wxSize result;
31425 void *argp1 = 0 ;
31426 int res1 = 0 ;
31427 PyObject *swig_obj[1] ;
31428
31429 if (!args) SWIG_fail;
31430 swig_obj[0] = args;
31431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31432 if (!SWIG_IsOK(res1)) {
31433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31434 }
31435 arg1 = reinterpret_cast< wxWindow * >(argp1);
31436 {
31437 PyThreadState* __tstate = wxPyBeginAllowThreads();
31438 result = ((wxWindow const *)arg1)->GetBestSize();
31439 wxPyEndAllowThreads(__tstate);
31440 if (PyErr_Occurred()) SWIG_fail;
31441 }
31442 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31443 return resultobj;
31444 fail:
31445 return NULL;
31446 }
31447
31448
31449 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31450 PyObject *resultobj = 0;
31451 wxWindow *arg1 = (wxWindow *) 0 ;
31452 int *arg2 = (int *) 0 ;
31453 int *arg3 = (int *) 0 ;
31454 void *argp1 = 0 ;
31455 int res1 = 0 ;
31456 int temp2 ;
31457 int res2 = SWIG_TMPOBJ ;
31458 int temp3 ;
31459 int res3 = SWIG_TMPOBJ ;
31460 PyObject *swig_obj[1] ;
31461
31462 arg2 = &temp2;
31463 arg3 = &temp3;
31464 if (!args) SWIG_fail;
31465 swig_obj[0] = args;
31466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31467 if (!SWIG_IsOK(res1)) {
31468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31469 }
31470 arg1 = reinterpret_cast< wxWindow * >(argp1);
31471 {
31472 PyThreadState* __tstate = wxPyBeginAllowThreads();
31473 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 resultobj = SWIG_Py_Void();
31478 if (SWIG_IsTmpObj(res2)) {
31479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31480 } else {
31481 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31483 }
31484 if (SWIG_IsTmpObj(res3)) {
31485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31486 } else {
31487 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31489 }
31490 return resultobj;
31491 fail:
31492 return NULL;
31493 }
31494
31495
31496 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31497 PyObject *resultobj = 0;
31498 wxWindow *arg1 = (wxWindow *) 0 ;
31499 void *argp1 = 0 ;
31500 int res1 = 0 ;
31501 PyObject *swig_obj[1] ;
31502
31503 if (!args) SWIG_fail;
31504 swig_obj[0] = args;
31505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31506 if (!SWIG_IsOK(res1)) {
31507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31508 }
31509 arg1 = reinterpret_cast< wxWindow * >(argp1);
31510 {
31511 PyThreadState* __tstate = wxPyBeginAllowThreads();
31512 (arg1)->InvalidateBestSize();
31513 wxPyEndAllowThreads(__tstate);
31514 if (PyErr_Occurred()) SWIG_fail;
31515 }
31516 resultobj = SWIG_Py_Void();
31517 return resultobj;
31518 fail:
31519 return NULL;
31520 }
31521
31522
31523 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31524 PyObject *resultobj = 0;
31525 wxWindow *arg1 = (wxWindow *) 0 ;
31526 wxSize *arg2 = 0 ;
31527 void *argp1 = 0 ;
31528 int res1 = 0 ;
31529 wxSize temp2 ;
31530 PyObject * obj0 = 0 ;
31531 PyObject * obj1 = 0 ;
31532 char * kwnames[] = {
31533 (char *) "self",(char *) "size", NULL
31534 };
31535
31536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31538 if (!SWIG_IsOK(res1)) {
31539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31540 }
31541 arg1 = reinterpret_cast< wxWindow * >(argp1);
31542 {
31543 arg2 = &temp2;
31544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31545 }
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 resultobj = SWIG_Py_Void();
31553 return resultobj;
31554 fail:
31555 return NULL;
31556 }
31557
31558
31559 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31560 PyObject *resultobj = 0;
31561 wxWindow *arg1 = (wxWindow *) 0 ;
31562 wxSize result;
31563 void *argp1 = 0 ;
31564 int res1 = 0 ;
31565 PyObject *swig_obj[1] ;
31566
31567 if (!args) SWIG_fail;
31568 swig_obj[0] = args;
31569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31570 if (!SWIG_IsOK(res1)) {
31571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31572 }
31573 arg1 = reinterpret_cast< wxWindow * >(argp1);
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31588 PyObject *resultobj = 0;
31589 wxWindow *arg1 = (wxWindow *) 0 ;
31590 wxSize result;
31591 void *argp1 = 0 ;
31592 int res1 = 0 ;
31593 PyObject *swig_obj[1] ;
31594
31595 if (!args) SWIG_fail;
31596 swig_obj[0] = args;
31597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31598 if (!SWIG_IsOK(res1)) {
31599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31600 }
31601 arg1 = reinterpret_cast< wxWindow * >(argp1);
31602 {
31603 PyThreadState* __tstate = wxPyBeginAllowThreads();
31604 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31605 wxPyEndAllowThreads(__tstate);
31606 if (PyErr_Occurred()) SWIG_fail;
31607 }
31608 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31609 return resultobj;
31610 fail:
31611 return NULL;
31612 }
31613
31614
31615 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31616 PyObject *resultobj = 0;
31617 wxWindow *arg1 = (wxWindow *) 0 ;
31618 int arg2 = (int) wxBOTH ;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 int val2 ;
31622 int ecode2 = 0 ;
31623 PyObject * obj0 = 0 ;
31624 PyObject * obj1 = 0 ;
31625 char * kwnames[] = {
31626 (char *) "self",(char *) "direction", NULL
31627 };
31628
31629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31631 if (!SWIG_IsOK(res1)) {
31632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31633 }
31634 arg1 = reinterpret_cast< wxWindow * >(argp1);
31635 if (obj1) {
31636 ecode2 = SWIG_AsVal_int(obj1, &val2);
31637 if (!SWIG_IsOK(ecode2)) {
31638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31639 }
31640 arg2 = static_cast< int >(val2);
31641 }
31642 {
31643 PyThreadState* __tstate = wxPyBeginAllowThreads();
31644 (arg1)->Center(arg2);
31645 wxPyEndAllowThreads(__tstate);
31646 if (PyErr_Occurred()) SWIG_fail;
31647 }
31648 resultobj = SWIG_Py_Void();
31649 return resultobj;
31650 fail:
31651 return NULL;
31652 }
31653
31654
31655 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31656 PyObject *resultobj = 0;
31657 wxWindow *arg1 = (wxWindow *) 0 ;
31658 int arg2 = (int) wxBOTH ;
31659 void *argp1 = 0 ;
31660 int res1 = 0 ;
31661 int val2 ;
31662 int ecode2 = 0 ;
31663 PyObject * obj0 = 0 ;
31664 PyObject * obj1 = 0 ;
31665 char * kwnames[] = {
31666 (char *) "self",(char *) "dir", NULL
31667 };
31668
31669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31671 if (!SWIG_IsOK(res1)) {
31672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31673 }
31674 arg1 = reinterpret_cast< wxWindow * >(argp1);
31675 if (obj1) {
31676 ecode2 = SWIG_AsVal_int(obj1, &val2);
31677 if (!SWIG_IsOK(ecode2)) {
31678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31679 }
31680 arg2 = static_cast< int >(val2);
31681 }
31682 {
31683 PyThreadState* __tstate = wxPyBeginAllowThreads();
31684 (arg1)->CenterOnParent(arg2);
31685 wxPyEndAllowThreads(__tstate);
31686 if (PyErr_Occurred()) SWIG_fail;
31687 }
31688 resultobj = SWIG_Py_Void();
31689 return resultobj;
31690 fail:
31691 return NULL;
31692 }
31693
31694
31695 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31696 PyObject *resultobj = 0;
31697 wxWindow *arg1 = (wxWindow *) 0 ;
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_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31707 }
31708 arg1 = reinterpret_cast< wxWindow * >(argp1);
31709 {
31710 PyThreadState* __tstate = wxPyBeginAllowThreads();
31711 (arg1)->Fit();
31712 wxPyEndAllowThreads(__tstate);
31713 if (PyErr_Occurred()) SWIG_fail;
31714 }
31715 resultobj = SWIG_Py_Void();
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31723 PyObject *resultobj = 0;
31724 wxWindow *arg1 = (wxWindow *) 0 ;
31725 void *argp1 = 0 ;
31726 int res1 = 0 ;
31727 PyObject *swig_obj[1] ;
31728
31729 if (!args) SWIG_fail;
31730 swig_obj[0] = args;
31731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31732 if (!SWIG_IsOK(res1)) {
31733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31734 }
31735 arg1 = reinterpret_cast< wxWindow * >(argp1);
31736 {
31737 PyThreadState* __tstate = wxPyBeginAllowThreads();
31738 (arg1)->FitInside();
31739 wxPyEndAllowThreads(__tstate);
31740 if (PyErr_Occurred()) SWIG_fail;
31741 }
31742 resultobj = SWIG_Py_Void();
31743 return resultobj;
31744 fail:
31745 return NULL;
31746 }
31747
31748
31749 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31750 PyObject *resultobj = 0;
31751 wxWindow *arg1 = (wxWindow *) 0 ;
31752 int arg2 ;
31753 int arg3 ;
31754 int arg4 = (int) -1 ;
31755 int arg5 = (int) -1 ;
31756 int arg6 = (int) -1 ;
31757 int arg7 = (int) -1 ;
31758 void *argp1 = 0 ;
31759 int res1 = 0 ;
31760 int val2 ;
31761 int ecode2 = 0 ;
31762 int val3 ;
31763 int ecode3 = 0 ;
31764 int val4 ;
31765 int ecode4 = 0 ;
31766 int val5 ;
31767 int ecode5 = 0 ;
31768 int val6 ;
31769 int ecode6 = 0 ;
31770 int val7 ;
31771 int ecode7 = 0 ;
31772 PyObject * obj0 = 0 ;
31773 PyObject * obj1 = 0 ;
31774 PyObject * obj2 = 0 ;
31775 PyObject * obj3 = 0 ;
31776 PyObject * obj4 = 0 ;
31777 PyObject * obj5 = 0 ;
31778 PyObject * obj6 = 0 ;
31779 char * kwnames[] = {
31780 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31781 };
31782
31783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31785 if (!SWIG_IsOK(res1)) {
31786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31787 }
31788 arg1 = reinterpret_cast< wxWindow * >(argp1);
31789 ecode2 = SWIG_AsVal_int(obj1, &val2);
31790 if (!SWIG_IsOK(ecode2)) {
31791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31792 }
31793 arg2 = static_cast< int >(val2);
31794 ecode3 = SWIG_AsVal_int(obj2, &val3);
31795 if (!SWIG_IsOK(ecode3)) {
31796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31797 }
31798 arg3 = static_cast< int >(val3);
31799 if (obj3) {
31800 ecode4 = SWIG_AsVal_int(obj3, &val4);
31801 if (!SWIG_IsOK(ecode4)) {
31802 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31803 }
31804 arg4 = static_cast< int >(val4);
31805 }
31806 if (obj4) {
31807 ecode5 = SWIG_AsVal_int(obj4, &val5);
31808 if (!SWIG_IsOK(ecode5)) {
31809 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31810 }
31811 arg5 = static_cast< int >(val5);
31812 }
31813 if (obj5) {
31814 ecode6 = SWIG_AsVal_int(obj5, &val6);
31815 if (!SWIG_IsOK(ecode6)) {
31816 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31817 }
31818 arg6 = static_cast< int >(val6);
31819 }
31820 if (obj6) {
31821 ecode7 = SWIG_AsVal_int(obj6, &val7);
31822 if (!SWIG_IsOK(ecode7)) {
31823 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31824 }
31825 arg7 = static_cast< int >(val7);
31826 }
31827 {
31828 PyThreadState* __tstate = wxPyBeginAllowThreads();
31829 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31830 wxPyEndAllowThreads(__tstate);
31831 if (PyErr_Occurred()) SWIG_fail;
31832 }
31833 resultobj = SWIG_Py_Void();
31834 return resultobj;
31835 fail:
31836 return NULL;
31837 }
31838
31839
31840 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31841 PyObject *resultobj = 0;
31842 wxWindow *arg1 = (wxWindow *) 0 ;
31843 wxSize *arg2 = 0 ;
31844 wxSize const &arg3_defvalue = wxDefaultSize ;
31845 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31846 wxSize const &arg4_defvalue = wxDefaultSize ;
31847 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 wxSize temp2 ;
31851 wxSize temp3 ;
31852 wxSize temp4 ;
31853 PyObject * obj0 = 0 ;
31854 PyObject * obj1 = 0 ;
31855 PyObject * obj2 = 0 ;
31856 PyObject * obj3 = 0 ;
31857 char * kwnames[] = {
31858 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31859 };
31860
31861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31863 if (!SWIG_IsOK(res1)) {
31864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31865 }
31866 arg1 = reinterpret_cast< wxWindow * >(argp1);
31867 {
31868 arg2 = &temp2;
31869 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31870 }
31871 if (obj2) {
31872 {
31873 arg3 = &temp3;
31874 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31875 }
31876 }
31877 if (obj3) {
31878 {
31879 arg4 = &temp4;
31880 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31881 }
31882 }
31883 {
31884 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 resultobj = SWIG_Py_Void();
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31897 PyObject *resultobj = 0;
31898 wxWindow *arg1 = (wxWindow *) 0 ;
31899 int arg2 ;
31900 int arg3 ;
31901 int arg4 = (int) -1 ;
31902 int arg5 = (int) -1 ;
31903 void *argp1 = 0 ;
31904 int res1 = 0 ;
31905 int val2 ;
31906 int ecode2 = 0 ;
31907 int val3 ;
31908 int ecode3 = 0 ;
31909 int val4 ;
31910 int ecode4 = 0 ;
31911 int val5 ;
31912 int ecode5 = 0 ;
31913 PyObject * obj0 = 0 ;
31914 PyObject * obj1 = 0 ;
31915 PyObject * obj2 = 0 ;
31916 PyObject * obj3 = 0 ;
31917 PyObject * obj4 = 0 ;
31918 char * kwnames[] = {
31919 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31920 };
31921
31922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31924 if (!SWIG_IsOK(res1)) {
31925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31926 }
31927 arg1 = reinterpret_cast< wxWindow * >(argp1);
31928 ecode2 = SWIG_AsVal_int(obj1, &val2);
31929 if (!SWIG_IsOK(ecode2)) {
31930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31931 }
31932 arg2 = static_cast< int >(val2);
31933 ecode3 = SWIG_AsVal_int(obj2, &val3);
31934 if (!SWIG_IsOK(ecode3)) {
31935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31936 }
31937 arg3 = static_cast< int >(val3);
31938 if (obj3) {
31939 ecode4 = SWIG_AsVal_int(obj3, &val4);
31940 if (!SWIG_IsOK(ecode4)) {
31941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31942 }
31943 arg4 = static_cast< int >(val4);
31944 }
31945 if (obj4) {
31946 ecode5 = SWIG_AsVal_int(obj4, &val5);
31947 if (!SWIG_IsOK(ecode5)) {
31948 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31949 }
31950 arg5 = static_cast< int >(val5);
31951 }
31952 {
31953 PyThreadState* __tstate = wxPyBeginAllowThreads();
31954 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31955 wxPyEndAllowThreads(__tstate);
31956 if (PyErr_Occurred()) SWIG_fail;
31957 }
31958 resultobj = SWIG_Py_Void();
31959 return resultobj;
31960 fail:
31961 return NULL;
31962 }
31963
31964
31965 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31966 PyObject *resultobj = 0;
31967 wxWindow *arg1 = (wxWindow *) 0 ;
31968 wxSize *arg2 = 0 ;
31969 wxSize const &arg3_defvalue = wxDefaultSize ;
31970 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31971 void *argp1 = 0 ;
31972 int res1 = 0 ;
31973 wxSize temp2 ;
31974 wxSize temp3 ;
31975 PyObject * obj0 = 0 ;
31976 PyObject * obj1 = 0 ;
31977 PyObject * obj2 = 0 ;
31978 char * kwnames[] = {
31979 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31980 };
31981
31982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31984 if (!SWIG_IsOK(res1)) {
31985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31986 }
31987 arg1 = reinterpret_cast< wxWindow * >(argp1);
31988 {
31989 arg2 = &temp2;
31990 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31991 }
31992 if (obj2) {
31993 {
31994 arg3 = &temp3;
31995 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31996 }
31997 }
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_Py_Void();
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32012 PyObject *resultobj = 0;
32013 wxWindow *arg1 = (wxWindow *) 0 ;
32014 wxSize result;
32015 void *argp1 = 0 ;
32016 int res1 = 0 ;
32017 PyObject *swig_obj[1] ;
32018
32019 if (!args) SWIG_fail;
32020 swig_obj[0] = args;
32021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32022 if (!SWIG_IsOK(res1)) {
32023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32024 }
32025 arg1 = reinterpret_cast< wxWindow * >(argp1);
32026 {
32027 PyThreadState* __tstate = wxPyBeginAllowThreads();
32028 result = ((wxWindow const *)arg1)->GetMaxSize();
32029 wxPyEndAllowThreads(__tstate);
32030 if (PyErr_Occurred()) SWIG_fail;
32031 }
32032 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32033 return resultobj;
32034 fail:
32035 return NULL;
32036 }
32037
32038
32039 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32040 PyObject *resultobj = 0;
32041 wxWindow *arg1 = (wxWindow *) 0 ;
32042 wxSize result;
32043 void *argp1 = 0 ;
32044 int res1 = 0 ;
32045 PyObject *swig_obj[1] ;
32046
32047 if (!args) SWIG_fail;
32048 swig_obj[0] = args;
32049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32050 if (!SWIG_IsOK(res1)) {
32051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32052 }
32053 arg1 = reinterpret_cast< wxWindow * >(argp1);
32054 {
32055 PyThreadState* __tstate = wxPyBeginAllowThreads();
32056 result = ((wxWindow const *)arg1)->GetMinSize();
32057 wxPyEndAllowThreads(__tstate);
32058 if (PyErr_Occurred()) SWIG_fail;
32059 }
32060 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32061 return resultobj;
32062 fail:
32063 return NULL;
32064 }
32065
32066
32067 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32068 PyObject *resultobj = 0;
32069 wxWindow *arg1 = (wxWindow *) 0 ;
32070 wxSize *arg2 = 0 ;
32071 void *argp1 = 0 ;
32072 int res1 = 0 ;
32073 wxSize temp2 ;
32074 PyObject * obj0 = 0 ;
32075 PyObject * obj1 = 0 ;
32076 char * kwnames[] = {
32077 (char *) "self",(char *) "minSize", NULL
32078 };
32079
32080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32082 if (!SWIG_IsOK(res1)) {
32083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32084 }
32085 arg1 = reinterpret_cast< wxWindow * >(argp1);
32086 {
32087 arg2 = &temp2;
32088 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32089 }
32090 {
32091 PyThreadState* __tstate = wxPyBeginAllowThreads();
32092 (arg1)->SetMinSize((wxSize const &)*arg2);
32093 wxPyEndAllowThreads(__tstate);
32094 if (PyErr_Occurred()) SWIG_fail;
32095 }
32096 resultobj = SWIG_Py_Void();
32097 return resultobj;
32098 fail:
32099 return NULL;
32100 }
32101
32102
32103 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32104 PyObject *resultobj = 0;
32105 wxWindow *arg1 = (wxWindow *) 0 ;
32106 wxSize *arg2 = 0 ;
32107 void *argp1 = 0 ;
32108 int res1 = 0 ;
32109 wxSize temp2 ;
32110 PyObject * obj0 = 0 ;
32111 PyObject * obj1 = 0 ;
32112 char * kwnames[] = {
32113 (char *) "self",(char *) "maxSize", NULL
32114 };
32115
32116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32118 if (!SWIG_IsOK(res1)) {
32119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32120 }
32121 arg1 = reinterpret_cast< wxWindow * >(argp1);
32122 {
32123 arg2 = &temp2;
32124 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32125 }
32126 {
32127 PyThreadState* __tstate = wxPyBeginAllowThreads();
32128 (arg1)->SetMaxSize((wxSize const &)*arg2);
32129 wxPyEndAllowThreads(__tstate);
32130 if (PyErr_Occurred()) SWIG_fail;
32131 }
32132 resultobj = SWIG_Py_Void();
32133 return resultobj;
32134 fail:
32135 return NULL;
32136 }
32137
32138
32139 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32140 PyObject *resultobj = 0;
32141 wxWindow *arg1 = (wxWindow *) 0 ;
32142 int result;
32143 void *argp1 = 0 ;
32144 int res1 = 0 ;
32145 PyObject *swig_obj[1] ;
32146
32147 if (!args) SWIG_fail;
32148 swig_obj[0] = args;
32149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32150 if (!SWIG_IsOK(res1)) {
32151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32152 }
32153 arg1 = reinterpret_cast< wxWindow * >(argp1);
32154 {
32155 PyThreadState* __tstate = wxPyBeginAllowThreads();
32156 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32157 wxPyEndAllowThreads(__tstate);
32158 if (PyErr_Occurred()) SWIG_fail;
32159 }
32160 resultobj = SWIG_From_int(static_cast< int >(result));
32161 return resultobj;
32162 fail:
32163 return NULL;
32164 }
32165
32166
32167 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32168 PyObject *resultobj = 0;
32169 wxWindow *arg1 = (wxWindow *) 0 ;
32170 int result;
32171 void *argp1 = 0 ;
32172 int res1 = 0 ;
32173 PyObject *swig_obj[1] ;
32174
32175 if (!args) SWIG_fail;
32176 swig_obj[0] = args;
32177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32178 if (!SWIG_IsOK(res1)) {
32179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32180 }
32181 arg1 = reinterpret_cast< wxWindow * >(argp1);
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32185 wxPyEndAllowThreads(__tstate);
32186 if (PyErr_Occurred()) SWIG_fail;
32187 }
32188 resultobj = SWIG_From_int(static_cast< int >(result));
32189 return resultobj;
32190 fail:
32191 return NULL;
32192 }
32193
32194
32195 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32196 PyObject *resultobj = 0;
32197 wxWindow *arg1 = (wxWindow *) 0 ;
32198 int result;
32199 void *argp1 = 0 ;
32200 int res1 = 0 ;
32201 PyObject *swig_obj[1] ;
32202
32203 if (!args) SWIG_fail;
32204 swig_obj[0] = args;
32205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32206 if (!SWIG_IsOK(res1)) {
32207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32208 }
32209 arg1 = reinterpret_cast< wxWindow * >(argp1);
32210 {
32211 PyThreadState* __tstate = wxPyBeginAllowThreads();
32212 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32213 wxPyEndAllowThreads(__tstate);
32214 if (PyErr_Occurred()) SWIG_fail;
32215 }
32216 resultobj = SWIG_From_int(static_cast< int >(result));
32217 return resultobj;
32218 fail:
32219 return NULL;
32220 }
32221
32222
32223 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32224 PyObject *resultobj = 0;
32225 wxWindow *arg1 = (wxWindow *) 0 ;
32226 int result;
32227 void *argp1 = 0 ;
32228 int res1 = 0 ;
32229 PyObject *swig_obj[1] ;
32230
32231 if (!args) SWIG_fail;
32232 swig_obj[0] = args;
32233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32234 if (!SWIG_IsOK(res1)) {
32235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32236 }
32237 arg1 = reinterpret_cast< wxWindow * >(argp1);
32238 {
32239 PyThreadState* __tstate = wxPyBeginAllowThreads();
32240 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32241 wxPyEndAllowThreads(__tstate);
32242 if (PyErr_Occurred()) SWIG_fail;
32243 }
32244 resultobj = SWIG_From_int(static_cast< int >(result));
32245 return resultobj;
32246 fail:
32247 return NULL;
32248 }
32249
32250
32251 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32252 PyObject *resultobj = 0;
32253 wxWindow *arg1 = (wxWindow *) 0 ;
32254 wxSize *arg2 = 0 ;
32255 void *argp1 = 0 ;
32256 int res1 = 0 ;
32257 wxSize temp2 ;
32258 PyObject * obj0 = 0 ;
32259 PyObject * obj1 = 0 ;
32260 char * kwnames[] = {
32261 (char *) "self",(char *) "size", NULL
32262 };
32263
32264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32266 if (!SWIG_IsOK(res1)) {
32267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32268 }
32269 arg1 = reinterpret_cast< wxWindow * >(argp1);
32270 {
32271 arg2 = &temp2;
32272 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32273 }
32274 {
32275 PyThreadState* __tstate = wxPyBeginAllowThreads();
32276 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32277 wxPyEndAllowThreads(__tstate);
32278 if (PyErr_Occurred()) SWIG_fail;
32279 }
32280 resultobj = SWIG_Py_Void();
32281 return resultobj;
32282 fail:
32283 return NULL;
32284 }
32285
32286
32287 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32288 PyObject *resultobj = 0;
32289 wxWindow *arg1 = (wxWindow *) 0 ;
32290 int arg2 ;
32291 int arg3 ;
32292 void *argp1 = 0 ;
32293 int res1 = 0 ;
32294 int val2 ;
32295 int ecode2 = 0 ;
32296 int val3 ;
32297 int ecode3 = 0 ;
32298 PyObject * obj0 = 0 ;
32299 PyObject * obj1 = 0 ;
32300 PyObject * obj2 = 0 ;
32301 char * kwnames[] = {
32302 (char *) "self",(char *) "w",(char *) "h", NULL
32303 };
32304
32305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32307 if (!SWIG_IsOK(res1)) {
32308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32309 }
32310 arg1 = reinterpret_cast< wxWindow * >(argp1);
32311 ecode2 = SWIG_AsVal_int(obj1, &val2);
32312 if (!SWIG_IsOK(ecode2)) {
32313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32314 }
32315 arg2 = static_cast< int >(val2);
32316 ecode3 = SWIG_AsVal_int(obj2, &val3);
32317 if (!SWIG_IsOK(ecode3)) {
32318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32319 }
32320 arg3 = static_cast< int >(val3);
32321 {
32322 PyThreadState* __tstate = wxPyBeginAllowThreads();
32323 (arg1)->SetVirtualSize(arg2,arg3);
32324 wxPyEndAllowThreads(__tstate);
32325 if (PyErr_Occurred()) SWIG_fail;
32326 }
32327 resultobj = SWIG_Py_Void();
32328 return resultobj;
32329 fail:
32330 return NULL;
32331 }
32332
32333
32334 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32335 PyObject *resultobj = 0;
32336 wxWindow *arg1 = (wxWindow *) 0 ;
32337 wxSize result;
32338 void *argp1 = 0 ;
32339 int res1 = 0 ;
32340 PyObject *swig_obj[1] ;
32341
32342 if (!args) SWIG_fail;
32343 swig_obj[0] = args;
32344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32345 if (!SWIG_IsOK(res1)) {
32346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32347 }
32348 arg1 = reinterpret_cast< wxWindow * >(argp1);
32349 {
32350 PyThreadState* __tstate = wxPyBeginAllowThreads();
32351 result = ((wxWindow const *)arg1)->GetVirtualSize();
32352 wxPyEndAllowThreads(__tstate);
32353 if (PyErr_Occurred()) SWIG_fail;
32354 }
32355 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32356 return resultobj;
32357 fail:
32358 return NULL;
32359 }
32360
32361
32362 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32363 PyObject *resultobj = 0;
32364 wxWindow *arg1 = (wxWindow *) 0 ;
32365 int *arg2 = (int *) 0 ;
32366 int *arg3 = (int *) 0 ;
32367 void *argp1 = 0 ;
32368 int res1 = 0 ;
32369 int temp2 ;
32370 int res2 = SWIG_TMPOBJ ;
32371 int temp3 ;
32372 int res3 = SWIG_TMPOBJ ;
32373 PyObject *swig_obj[1] ;
32374
32375 arg2 = &temp2;
32376 arg3 = &temp3;
32377 if (!args) SWIG_fail;
32378 swig_obj[0] = args;
32379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32380 if (!SWIG_IsOK(res1)) {
32381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32382 }
32383 arg1 = reinterpret_cast< wxWindow * >(argp1);
32384 {
32385 PyThreadState* __tstate = wxPyBeginAllowThreads();
32386 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32387 wxPyEndAllowThreads(__tstate);
32388 if (PyErr_Occurred()) SWIG_fail;
32389 }
32390 resultobj = SWIG_Py_Void();
32391 if (SWIG_IsTmpObj(res2)) {
32392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32393 } else {
32394 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32396 }
32397 if (SWIG_IsTmpObj(res3)) {
32398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32399 } else {
32400 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32402 }
32403 return resultobj;
32404 fail:
32405 return NULL;
32406 }
32407
32408
32409 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32410 PyObject *resultobj = 0;
32411 wxWindow *arg1 = (wxWindow *) 0 ;
32412 wxSize result;
32413 void *argp1 = 0 ;
32414 int res1 = 0 ;
32415 PyObject *swig_obj[1] ;
32416
32417 if (!args) SWIG_fail;
32418 swig_obj[0] = args;
32419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32420 if (!SWIG_IsOK(res1)) {
32421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32422 }
32423 arg1 = reinterpret_cast< wxWindow * >(argp1);
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32427 wxPyEndAllowThreads(__tstate);
32428 if (PyErr_Occurred()) SWIG_fail;
32429 }
32430 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32431 return resultobj;
32432 fail:
32433 return NULL;
32434 }
32435
32436
32437 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32438 PyObject *resultobj = 0;
32439 wxWindow *arg1 = (wxWindow *) 0 ;
32440 bool arg2 = (bool) true ;
32441 bool result;
32442 void *argp1 = 0 ;
32443 int res1 = 0 ;
32444 bool val2 ;
32445 int ecode2 = 0 ;
32446 PyObject * obj0 = 0 ;
32447 PyObject * obj1 = 0 ;
32448 char * kwnames[] = {
32449 (char *) "self",(char *) "show", NULL
32450 };
32451
32452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32454 if (!SWIG_IsOK(res1)) {
32455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32456 }
32457 arg1 = reinterpret_cast< wxWindow * >(argp1);
32458 if (obj1) {
32459 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32460 if (!SWIG_IsOK(ecode2)) {
32461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32462 }
32463 arg2 = static_cast< bool >(val2);
32464 }
32465 {
32466 PyThreadState* __tstate = wxPyBeginAllowThreads();
32467 result = (bool)(arg1)->Show(arg2);
32468 wxPyEndAllowThreads(__tstate);
32469 if (PyErr_Occurred()) SWIG_fail;
32470 }
32471 {
32472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32473 }
32474 return resultobj;
32475 fail:
32476 return NULL;
32477 }
32478
32479
32480 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32481 PyObject *resultobj = 0;
32482 wxWindow *arg1 = (wxWindow *) 0 ;
32483 bool result;
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_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32493 }
32494 arg1 = reinterpret_cast< wxWindow * >(argp1);
32495 {
32496 PyThreadState* __tstate = wxPyBeginAllowThreads();
32497 result = (bool)(arg1)->Hide();
32498 wxPyEndAllowThreads(__tstate);
32499 if (PyErr_Occurred()) SWIG_fail;
32500 }
32501 {
32502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32503 }
32504 return resultobj;
32505 fail:
32506 return NULL;
32507 }
32508
32509
32510 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32511 PyObject *resultobj = 0;
32512 wxWindow *arg1 = (wxWindow *) 0 ;
32513 bool arg2 = (bool) true ;
32514 bool result;
32515 void *argp1 = 0 ;
32516 int res1 = 0 ;
32517 bool val2 ;
32518 int ecode2 = 0 ;
32519 PyObject * obj0 = 0 ;
32520 PyObject * obj1 = 0 ;
32521 char * kwnames[] = {
32522 (char *) "self",(char *) "enable", NULL
32523 };
32524
32525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32529 }
32530 arg1 = reinterpret_cast< wxWindow * >(argp1);
32531 if (obj1) {
32532 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32533 if (!SWIG_IsOK(ecode2)) {
32534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32535 }
32536 arg2 = static_cast< bool >(val2);
32537 }
32538 {
32539 PyThreadState* __tstate = wxPyBeginAllowThreads();
32540 result = (bool)(arg1)->Enable(arg2);
32541 wxPyEndAllowThreads(__tstate);
32542 if (PyErr_Occurred()) SWIG_fail;
32543 }
32544 {
32545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32546 }
32547 return resultobj;
32548 fail:
32549 return NULL;
32550 }
32551
32552
32553 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32554 PyObject *resultobj = 0;
32555 wxWindow *arg1 = (wxWindow *) 0 ;
32556 bool result;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 PyObject *swig_obj[1] ;
32560
32561 if (!args) SWIG_fail;
32562 swig_obj[0] = args;
32563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32564 if (!SWIG_IsOK(res1)) {
32565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32566 }
32567 arg1 = reinterpret_cast< wxWindow * >(argp1);
32568 {
32569 PyThreadState* __tstate = wxPyBeginAllowThreads();
32570 result = (bool)(arg1)->Disable();
32571 wxPyEndAllowThreads(__tstate);
32572 if (PyErr_Occurred()) SWIG_fail;
32573 }
32574 {
32575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32576 }
32577 return resultobj;
32578 fail:
32579 return NULL;
32580 }
32581
32582
32583 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32584 PyObject *resultobj = 0;
32585 wxWindow *arg1 = (wxWindow *) 0 ;
32586 bool result;
32587 void *argp1 = 0 ;
32588 int res1 = 0 ;
32589 PyObject *swig_obj[1] ;
32590
32591 if (!args) SWIG_fail;
32592 swig_obj[0] = args;
32593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32594 if (!SWIG_IsOK(res1)) {
32595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32596 }
32597 arg1 = reinterpret_cast< wxWindow * >(argp1);
32598 {
32599 PyThreadState* __tstate = wxPyBeginAllowThreads();
32600 result = (bool)((wxWindow const *)arg1)->IsShown();
32601 wxPyEndAllowThreads(__tstate);
32602 if (PyErr_Occurred()) SWIG_fail;
32603 }
32604 {
32605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32606 }
32607 return resultobj;
32608 fail:
32609 return NULL;
32610 }
32611
32612
32613 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32614 PyObject *resultobj = 0;
32615 wxWindow *arg1 = (wxWindow *) 0 ;
32616 bool result;
32617 void *argp1 = 0 ;
32618 int res1 = 0 ;
32619 PyObject *swig_obj[1] ;
32620
32621 if (!args) SWIG_fail;
32622 swig_obj[0] = args;
32623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32624 if (!SWIG_IsOK(res1)) {
32625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32626 }
32627 arg1 = reinterpret_cast< wxWindow * >(argp1);
32628 {
32629 PyThreadState* __tstate = wxPyBeginAllowThreads();
32630 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32631 wxPyEndAllowThreads(__tstate);
32632 if (PyErr_Occurred()) SWIG_fail;
32633 }
32634 {
32635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32636 }
32637 return resultobj;
32638 fail:
32639 return NULL;
32640 }
32641
32642
32643 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32644 PyObject *resultobj = 0;
32645 wxWindow *arg1 = (wxWindow *) 0 ;
32646 long arg2 ;
32647 void *argp1 = 0 ;
32648 int res1 = 0 ;
32649 long val2 ;
32650 int ecode2 = 0 ;
32651 PyObject * obj0 = 0 ;
32652 PyObject * obj1 = 0 ;
32653 char * kwnames[] = {
32654 (char *) "self",(char *) "style", NULL
32655 };
32656
32657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32659 if (!SWIG_IsOK(res1)) {
32660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32661 }
32662 arg1 = reinterpret_cast< wxWindow * >(argp1);
32663 ecode2 = SWIG_AsVal_long(obj1, &val2);
32664 if (!SWIG_IsOK(ecode2)) {
32665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32666 }
32667 arg2 = static_cast< long >(val2);
32668 {
32669 PyThreadState* __tstate = wxPyBeginAllowThreads();
32670 (arg1)->SetWindowStyleFlag(arg2);
32671 wxPyEndAllowThreads(__tstate);
32672 if (PyErr_Occurred()) SWIG_fail;
32673 }
32674 resultobj = SWIG_Py_Void();
32675 return resultobj;
32676 fail:
32677 return NULL;
32678 }
32679
32680
32681 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32682 PyObject *resultobj = 0;
32683 wxWindow *arg1 = (wxWindow *) 0 ;
32684 long result;
32685 void *argp1 = 0 ;
32686 int res1 = 0 ;
32687 PyObject *swig_obj[1] ;
32688
32689 if (!args) SWIG_fail;
32690 swig_obj[0] = args;
32691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32692 if (!SWIG_IsOK(res1)) {
32693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32694 }
32695 arg1 = reinterpret_cast< wxWindow * >(argp1);
32696 {
32697 PyThreadState* __tstate = wxPyBeginAllowThreads();
32698 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32699 wxPyEndAllowThreads(__tstate);
32700 if (PyErr_Occurred()) SWIG_fail;
32701 }
32702 resultobj = SWIG_From_long(static_cast< long >(result));
32703 return resultobj;
32704 fail:
32705 return NULL;
32706 }
32707
32708
32709 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32710 PyObject *resultobj = 0;
32711 wxWindow *arg1 = (wxWindow *) 0 ;
32712 int arg2 ;
32713 bool result;
32714 void *argp1 = 0 ;
32715 int res1 = 0 ;
32716 int val2 ;
32717 int ecode2 = 0 ;
32718 PyObject * obj0 = 0 ;
32719 PyObject * obj1 = 0 ;
32720 char * kwnames[] = {
32721 (char *) "self",(char *) "flag", NULL
32722 };
32723
32724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32726 if (!SWIG_IsOK(res1)) {
32727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32728 }
32729 arg1 = reinterpret_cast< wxWindow * >(argp1);
32730 ecode2 = SWIG_AsVal_int(obj1, &val2);
32731 if (!SWIG_IsOK(ecode2)) {
32732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32733 }
32734 arg2 = static_cast< int >(val2);
32735 {
32736 PyThreadState* __tstate = wxPyBeginAllowThreads();
32737 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32738 wxPyEndAllowThreads(__tstate);
32739 if (PyErr_Occurred()) SWIG_fail;
32740 }
32741 {
32742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32743 }
32744 return resultobj;
32745 fail:
32746 return NULL;
32747 }
32748
32749
32750 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32751 PyObject *resultobj = 0;
32752 wxWindow *arg1 = (wxWindow *) 0 ;
32753 bool result;
32754 void *argp1 = 0 ;
32755 int res1 = 0 ;
32756 PyObject *swig_obj[1] ;
32757
32758 if (!args) SWIG_fail;
32759 swig_obj[0] = args;
32760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32763 }
32764 arg1 = reinterpret_cast< wxWindow * >(argp1);
32765 {
32766 PyThreadState* __tstate = wxPyBeginAllowThreads();
32767 result = (bool)((wxWindow const *)arg1)->IsRetained();
32768 wxPyEndAllowThreads(__tstate);
32769 if (PyErr_Occurred()) SWIG_fail;
32770 }
32771 {
32772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32773 }
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32781 PyObject *resultobj = 0;
32782 wxWindow *arg1 = (wxWindow *) 0 ;
32783 long arg2 ;
32784 void *argp1 = 0 ;
32785 int res1 = 0 ;
32786 long val2 ;
32787 int ecode2 = 0 ;
32788 PyObject * obj0 = 0 ;
32789 PyObject * obj1 = 0 ;
32790 char * kwnames[] = {
32791 (char *) "self",(char *) "exStyle", NULL
32792 };
32793
32794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32796 if (!SWIG_IsOK(res1)) {
32797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32798 }
32799 arg1 = reinterpret_cast< wxWindow * >(argp1);
32800 ecode2 = SWIG_AsVal_long(obj1, &val2);
32801 if (!SWIG_IsOK(ecode2)) {
32802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32803 }
32804 arg2 = static_cast< long >(val2);
32805 {
32806 PyThreadState* __tstate = wxPyBeginAllowThreads();
32807 (arg1)->SetExtraStyle(arg2);
32808 wxPyEndAllowThreads(__tstate);
32809 if (PyErr_Occurred()) SWIG_fail;
32810 }
32811 resultobj = SWIG_Py_Void();
32812 return resultobj;
32813 fail:
32814 return NULL;
32815 }
32816
32817
32818 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32819 PyObject *resultobj = 0;
32820 wxWindow *arg1 = (wxWindow *) 0 ;
32821 long result;
32822 void *argp1 = 0 ;
32823 int res1 = 0 ;
32824 PyObject *swig_obj[1] ;
32825
32826 if (!args) SWIG_fail;
32827 swig_obj[0] = args;
32828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32829 if (!SWIG_IsOK(res1)) {
32830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32831 }
32832 arg1 = reinterpret_cast< wxWindow * >(argp1);
32833 {
32834 PyThreadState* __tstate = wxPyBeginAllowThreads();
32835 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32836 wxPyEndAllowThreads(__tstate);
32837 if (PyErr_Occurred()) SWIG_fail;
32838 }
32839 resultobj = SWIG_From_long(static_cast< long >(result));
32840 return resultobj;
32841 fail:
32842 return NULL;
32843 }
32844
32845
32846 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32847 PyObject *resultobj = 0;
32848 wxWindow *arg1 = (wxWindow *) 0 ;
32849 bool arg2 = (bool) true ;
32850 void *argp1 = 0 ;
32851 int res1 = 0 ;
32852 bool val2 ;
32853 int ecode2 = 0 ;
32854 PyObject * obj0 = 0 ;
32855 PyObject * obj1 = 0 ;
32856 char * kwnames[] = {
32857 (char *) "self",(char *) "modal", NULL
32858 };
32859
32860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32862 if (!SWIG_IsOK(res1)) {
32863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32864 }
32865 arg1 = reinterpret_cast< wxWindow * >(argp1);
32866 if (obj1) {
32867 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32868 if (!SWIG_IsOK(ecode2)) {
32869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32870 }
32871 arg2 = static_cast< bool >(val2);
32872 }
32873 {
32874 PyThreadState* __tstate = wxPyBeginAllowThreads();
32875 (arg1)->MakeModal(arg2);
32876 wxPyEndAllowThreads(__tstate);
32877 if (PyErr_Occurred()) SWIG_fail;
32878 }
32879 resultobj = SWIG_Py_Void();
32880 return resultobj;
32881 fail:
32882 return NULL;
32883 }
32884
32885
32886 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32887 PyObject *resultobj = 0;
32888 wxWindow *arg1 = (wxWindow *) 0 ;
32889 bool arg2 ;
32890 void *argp1 = 0 ;
32891 int res1 = 0 ;
32892 bool val2 ;
32893 int ecode2 = 0 ;
32894 PyObject * obj0 = 0 ;
32895 PyObject * obj1 = 0 ;
32896 char * kwnames[] = {
32897 (char *) "self",(char *) "enableTheme", NULL
32898 };
32899
32900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32902 if (!SWIG_IsOK(res1)) {
32903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32904 }
32905 arg1 = reinterpret_cast< wxWindow * >(argp1);
32906 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32907 if (!SWIG_IsOK(ecode2)) {
32908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32909 }
32910 arg2 = static_cast< bool >(val2);
32911 {
32912 PyThreadState* __tstate = wxPyBeginAllowThreads();
32913 (arg1)->SetThemeEnabled(arg2);
32914 wxPyEndAllowThreads(__tstate);
32915 if (PyErr_Occurred()) SWIG_fail;
32916 }
32917 resultobj = SWIG_Py_Void();
32918 return resultobj;
32919 fail:
32920 return NULL;
32921 }
32922
32923
32924 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32925 PyObject *resultobj = 0;
32926 wxWindow *arg1 = (wxWindow *) 0 ;
32927 bool result;
32928 void *argp1 = 0 ;
32929 int res1 = 0 ;
32930 PyObject *swig_obj[1] ;
32931
32932 if (!args) SWIG_fail;
32933 swig_obj[0] = args;
32934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32935 if (!SWIG_IsOK(res1)) {
32936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32937 }
32938 arg1 = reinterpret_cast< wxWindow * >(argp1);
32939 {
32940 PyThreadState* __tstate = wxPyBeginAllowThreads();
32941 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32942 wxPyEndAllowThreads(__tstate);
32943 if (PyErr_Occurred()) SWIG_fail;
32944 }
32945 {
32946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32947 }
32948 return resultobj;
32949 fail:
32950 return NULL;
32951 }
32952
32953
32954 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32955 PyObject *resultobj = 0;
32956 wxWindow *arg1 = (wxWindow *) 0 ;
32957 void *argp1 = 0 ;
32958 int res1 = 0 ;
32959 PyObject *swig_obj[1] ;
32960
32961 if (!args) SWIG_fail;
32962 swig_obj[0] = args;
32963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32964 if (!SWIG_IsOK(res1)) {
32965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32966 }
32967 arg1 = reinterpret_cast< wxWindow * >(argp1);
32968 {
32969 PyThreadState* __tstate = wxPyBeginAllowThreads();
32970 (arg1)->SetFocus();
32971 wxPyEndAllowThreads(__tstate);
32972 if (PyErr_Occurred()) SWIG_fail;
32973 }
32974 resultobj = SWIG_Py_Void();
32975 return resultobj;
32976 fail:
32977 return NULL;
32978 }
32979
32980
32981 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32982 PyObject *resultobj = 0;
32983 wxWindow *arg1 = (wxWindow *) 0 ;
32984 void *argp1 = 0 ;
32985 int res1 = 0 ;
32986 PyObject *swig_obj[1] ;
32987
32988 if (!args) SWIG_fail;
32989 swig_obj[0] = args;
32990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32991 if (!SWIG_IsOK(res1)) {
32992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32993 }
32994 arg1 = reinterpret_cast< wxWindow * >(argp1);
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 (arg1)->SetFocusFromKbd();
32998 wxPyEndAllowThreads(__tstate);
32999 if (PyErr_Occurred()) SWIG_fail;
33000 }
33001 resultobj = SWIG_Py_Void();
33002 return resultobj;
33003 fail:
33004 return NULL;
33005 }
33006
33007
33008 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33009 PyObject *resultobj = 0;
33010 wxWindow *result = 0 ;
33011
33012 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33013 {
33014 if (!wxPyCheckForApp()) SWIG_fail;
33015 PyThreadState* __tstate = wxPyBeginAllowThreads();
33016 result = (wxWindow *)wxWindow::FindFocus();
33017 wxPyEndAllowThreads(__tstate);
33018 if (PyErr_Occurred()) SWIG_fail;
33019 }
33020 {
33021 resultobj = wxPyMake_wxObject(result, 0);
33022 }
33023 return resultobj;
33024 fail:
33025 return NULL;
33026 }
33027
33028
33029 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33030 PyObject *resultobj = 0;
33031 wxWindow *arg1 = (wxWindow *) 0 ;
33032 bool result;
33033 void *argp1 = 0 ;
33034 int res1 = 0 ;
33035 PyObject *swig_obj[1] ;
33036
33037 if (!args) SWIG_fail;
33038 swig_obj[0] = args;
33039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33040 if (!SWIG_IsOK(res1)) {
33041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33042 }
33043 arg1 = reinterpret_cast< wxWindow * >(argp1);
33044 {
33045 PyThreadState* __tstate = wxPyBeginAllowThreads();
33046 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33047 wxPyEndAllowThreads(__tstate);
33048 if (PyErr_Occurred()) SWIG_fail;
33049 }
33050 {
33051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33052 }
33053 return resultobj;
33054 fail:
33055 return NULL;
33056 }
33057
33058
33059 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33060 PyObject *resultobj = 0;
33061 wxWindow *arg1 = (wxWindow *) 0 ;
33062 bool result;
33063 void *argp1 = 0 ;
33064 int res1 = 0 ;
33065 PyObject *swig_obj[1] ;
33066
33067 if (!args) SWIG_fail;
33068 swig_obj[0] = args;
33069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33070 if (!SWIG_IsOK(res1)) {
33071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33072 }
33073 arg1 = reinterpret_cast< wxWindow * >(argp1);
33074 {
33075 PyThreadState* __tstate = wxPyBeginAllowThreads();
33076 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33077 wxPyEndAllowThreads(__tstate);
33078 if (PyErr_Occurred()) SWIG_fail;
33079 }
33080 {
33081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33082 }
33083 return resultobj;
33084 fail:
33085 return NULL;
33086 }
33087
33088
33089 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33090 PyObject *resultobj = 0;
33091 wxWindow *arg1 = (wxWindow *) 0 ;
33092 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33093 bool result;
33094 void *argp1 = 0 ;
33095 int res1 = 0 ;
33096 int val2 ;
33097 int ecode2 = 0 ;
33098 PyObject * obj0 = 0 ;
33099 PyObject * obj1 = 0 ;
33100 char * kwnames[] = {
33101 (char *) "self",(char *) "flags", NULL
33102 };
33103
33104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33106 if (!SWIG_IsOK(res1)) {
33107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33108 }
33109 arg1 = reinterpret_cast< wxWindow * >(argp1);
33110 if (obj1) {
33111 ecode2 = SWIG_AsVal_int(obj1, &val2);
33112 if (!SWIG_IsOK(ecode2)) {
33113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33114 }
33115 arg2 = static_cast< int >(val2);
33116 }
33117 {
33118 PyThreadState* __tstate = wxPyBeginAllowThreads();
33119 result = (bool)(arg1)->Navigate(arg2);
33120 wxPyEndAllowThreads(__tstate);
33121 if (PyErr_Occurred()) SWIG_fail;
33122 }
33123 {
33124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33125 }
33126 return resultobj;
33127 fail:
33128 return NULL;
33129 }
33130
33131
33132 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33133 PyObject *resultobj = 0;
33134 wxWindow *arg1 = (wxWindow *) 0 ;
33135 wxWindow *arg2 = (wxWindow *) 0 ;
33136 void *argp1 = 0 ;
33137 int res1 = 0 ;
33138 void *argp2 = 0 ;
33139 int res2 = 0 ;
33140 PyObject * obj0 = 0 ;
33141 PyObject * obj1 = 0 ;
33142 char * kwnames[] = {
33143 (char *) "self",(char *) "win", NULL
33144 };
33145
33146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33148 if (!SWIG_IsOK(res1)) {
33149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33150 }
33151 arg1 = reinterpret_cast< wxWindow * >(argp1);
33152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33153 if (!SWIG_IsOK(res2)) {
33154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33155 }
33156 arg2 = reinterpret_cast< wxWindow * >(argp2);
33157 {
33158 PyThreadState* __tstate = wxPyBeginAllowThreads();
33159 (arg1)->MoveAfterInTabOrder(arg2);
33160 wxPyEndAllowThreads(__tstate);
33161 if (PyErr_Occurred()) SWIG_fail;
33162 }
33163 resultobj = SWIG_Py_Void();
33164 return resultobj;
33165 fail:
33166 return NULL;
33167 }
33168
33169
33170 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33171 PyObject *resultobj = 0;
33172 wxWindow *arg1 = (wxWindow *) 0 ;
33173 wxWindow *arg2 = (wxWindow *) 0 ;
33174 void *argp1 = 0 ;
33175 int res1 = 0 ;
33176 void *argp2 = 0 ;
33177 int res2 = 0 ;
33178 PyObject * obj0 = 0 ;
33179 PyObject * obj1 = 0 ;
33180 char * kwnames[] = {
33181 (char *) "self",(char *) "win", NULL
33182 };
33183
33184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33186 if (!SWIG_IsOK(res1)) {
33187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33188 }
33189 arg1 = reinterpret_cast< wxWindow * >(argp1);
33190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33191 if (!SWIG_IsOK(res2)) {
33192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33193 }
33194 arg2 = reinterpret_cast< wxWindow * >(argp2);
33195 {
33196 PyThreadState* __tstate = wxPyBeginAllowThreads();
33197 (arg1)->MoveBeforeInTabOrder(arg2);
33198 wxPyEndAllowThreads(__tstate);
33199 if (PyErr_Occurred()) SWIG_fail;
33200 }
33201 resultobj = SWIG_Py_Void();
33202 return resultobj;
33203 fail:
33204 return NULL;
33205 }
33206
33207
33208 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33209 PyObject *resultobj = 0;
33210 wxWindow *arg1 = (wxWindow *) 0 ;
33211 PyObject *result = 0 ;
33212 void *argp1 = 0 ;
33213 int res1 = 0 ;
33214 PyObject *swig_obj[1] ;
33215
33216 if (!args) SWIG_fail;
33217 swig_obj[0] = args;
33218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33219 if (!SWIG_IsOK(res1)) {
33220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33221 }
33222 arg1 = reinterpret_cast< wxWindow * >(argp1);
33223 {
33224 PyThreadState* __tstate = wxPyBeginAllowThreads();
33225 result = (PyObject *)wxWindow_GetChildren(arg1);
33226 wxPyEndAllowThreads(__tstate);
33227 if (PyErr_Occurred()) SWIG_fail;
33228 }
33229 resultobj = result;
33230 return resultobj;
33231 fail:
33232 return NULL;
33233 }
33234
33235
33236 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33237 PyObject *resultobj = 0;
33238 wxWindow *arg1 = (wxWindow *) 0 ;
33239 wxWindow *result = 0 ;
33240 void *argp1 = 0 ;
33241 int res1 = 0 ;
33242 PyObject *swig_obj[1] ;
33243
33244 if (!args) SWIG_fail;
33245 swig_obj[0] = args;
33246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33247 if (!SWIG_IsOK(res1)) {
33248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33249 }
33250 arg1 = reinterpret_cast< wxWindow * >(argp1);
33251 {
33252 PyThreadState* __tstate = wxPyBeginAllowThreads();
33253 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33254 wxPyEndAllowThreads(__tstate);
33255 if (PyErr_Occurred()) SWIG_fail;
33256 }
33257 {
33258 resultobj = wxPyMake_wxObject(result, 0);
33259 }
33260 return resultobj;
33261 fail:
33262 return NULL;
33263 }
33264
33265
33266 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33267 PyObject *resultobj = 0;
33268 wxWindow *arg1 = (wxWindow *) 0 ;
33269 wxWindow *result = 0 ;
33270 void *argp1 = 0 ;
33271 int res1 = 0 ;
33272 PyObject *swig_obj[1] ;
33273
33274 if (!args) SWIG_fail;
33275 swig_obj[0] = args;
33276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33277 if (!SWIG_IsOK(res1)) {
33278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33279 }
33280 arg1 = reinterpret_cast< wxWindow * >(argp1);
33281 {
33282 PyThreadState* __tstate = wxPyBeginAllowThreads();
33283 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33284 wxPyEndAllowThreads(__tstate);
33285 if (PyErr_Occurred()) SWIG_fail;
33286 }
33287 {
33288 resultobj = wxPyMake_wxObject(result, 0);
33289 }
33290 return resultobj;
33291 fail:
33292 return NULL;
33293 }
33294
33295
33296 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33297 PyObject *resultobj = 0;
33298 wxWindow *arg1 = (wxWindow *) 0 ;
33299 bool result;
33300 void *argp1 = 0 ;
33301 int res1 = 0 ;
33302 PyObject *swig_obj[1] ;
33303
33304 if (!args) SWIG_fail;
33305 swig_obj[0] = args;
33306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33307 if (!SWIG_IsOK(res1)) {
33308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33309 }
33310 arg1 = reinterpret_cast< wxWindow * >(argp1);
33311 {
33312 PyThreadState* __tstate = wxPyBeginAllowThreads();
33313 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33314 wxPyEndAllowThreads(__tstate);
33315 if (PyErr_Occurred()) SWIG_fail;
33316 }
33317 {
33318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33319 }
33320 return resultobj;
33321 fail:
33322 return NULL;
33323 }
33324
33325
33326 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33327 PyObject *resultobj = 0;
33328 wxWindow *arg1 = (wxWindow *) 0 ;
33329 wxWindow *arg2 = (wxWindow *) 0 ;
33330 bool result;
33331 void *argp1 = 0 ;
33332 int res1 = 0 ;
33333 void *argp2 = 0 ;
33334 int res2 = 0 ;
33335 PyObject * obj0 = 0 ;
33336 PyObject * obj1 = 0 ;
33337 char * kwnames[] = {
33338 (char *) "self",(char *) "newParent", NULL
33339 };
33340
33341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33343 if (!SWIG_IsOK(res1)) {
33344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33345 }
33346 arg1 = reinterpret_cast< wxWindow * >(argp1);
33347 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33348 if (!SWIG_IsOK(res2)) {
33349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33350 }
33351 arg2 = reinterpret_cast< wxWindow * >(argp2);
33352 {
33353 PyThreadState* __tstate = wxPyBeginAllowThreads();
33354 result = (bool)(arg1)->Reparent(arg2);
33355 wxPyEndAllowThreads(__tstate);
33356 if (PyErr_Occurred()) SWIG_fail;
33357 }
33358 {
33359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33360 }
33361 return resultobj;
33362 fail:
33363 return NULL;
33364 }
33365
33366
33367 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33368 PyObject *resultobj = 0;
33369 wxWindow *arg1 = (wxWindow *) 0 ;
33370 wxWindow *arg2 = (wxWindow *) 0 ;
33371 void *argp1 = 0 ;
33372 int res1 = 0 ;
33373 void *argp2 = 0 ;
33374 int res2 = 0 ;
33375 PyObject * obj0 = 0 ;
33376 PyObject * obj1 = 0 ;
33377 char * kwnames[] = {
33378 (char *) "self",(char *) "child", NULL
33379 };
33380
33381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33383 if (!SWIG_IsOK(res1)) {
33384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33385 }
33386 arg1 = reinterpret_cast< wxWindow * >(argp1);
33387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33388 if (!SWIG_IsOK(res2)) {
33389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33390 }
33391 arg2 = reinterpret_cast< wxWindow * >(argp2);
33392 {
33393 PyThreadState* __tstate = wxPyBeginAllowThreads();
33394 (arg1)->AddChild(arg2);
33395 wxPyEndAllowThreads(__tstate);
33396 if (PyErr_Occurred()) SWIG_fail;
33397 }
33398 resultobj = SWIG_Py_Void();
33399 return resultobj;
33400 fail:
33401 return NULL;
33402 }
33403
33404
33405 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33406 PyObject *resultobj = 0;
33407 wxWindow *arg1 = (wxWindow *) 0 ;
33408 wxWindow *arg2 = (wxWindow *) 0 ;
33409 void *argp1 = 0 ;
33410 int res1 = 0 ;
33411 void *argp2 = 0 ;
33412 int res2 = 0 ;
33413 PyObject * obj0 = 0 ;
33414 PyObject * obj1 = 0 ;
33415 char * kwnames[] = {
33416 (char *) "self",(char *) "child", NULL
33417 };
33418
33419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33421 if (!SWIG_IsOK(res1)) {
33422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33423 }
33424 arg1 = reinterpret_cast< wxWindow * >(argp1);
33425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33426 if (!SWIG_IsOK(res2)) {
33427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33428 }
33429 arg2 = reinterpret_cast< wxWindow * >(argp2);
33430 {
33431 PyThreadState* __tstate = wxPyBeginAllowThreads();
33432 (arg1)->RemoveChild(arg2);
33433 wxPyEndAllowThreads(__tstate);
33434 if (PyErr_Occurred()) SWIG_fail;
33435 }
33436 resultobj = SWIG_Py_Void();
33437 return resultobj;
33438 fail:
33439 return NULL;
33440 }
33441
33442
33443 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33444 PyObject *resultobj = 0;
33445 wxWindow *arg1 = (wxWindow *) 0 ;
33446 bool arg2 ;
33447 void *argp1 = 0 ;
33448 int res1 = 0 ;
33449 bool val2 ;
33450 int ecode2 = 0 ;
33451 PyObject * obj0 = 0 ;
33452 PyObject * obj1 = 0 ;
33453 char * kwnames[] = {
33454 (char *) "self",(char *) "on", NULL
33455 };
33456
33457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33459 if (!SWIG_IsOK(res1)) {
33460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33461 }
33462 arg1 = reinterpret_cast< wxWindow * >(argp1);
33463 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33464 if (!SWIG_IsOK(ecode2)) {
33465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33466 }
33467 arg2 = static_cast< bool >(val2);
33468 {
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 wxWindow_SetDoubleBuffered(arg1,arg2);
33471 wxPyEndAllowThreads(__tstate);
33472 if (PyErr_Occurred()) SWIG_fail;
33473 }
33474 resultobj = SWIG_Py_Void();
33475 return resultobj;
33476 fail:
33477 return NULL;
33478 }
33479
33480
33481 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33482 PyObject *resultobj = 0;
33483 wxWindow *arg1 = (wxWindow *) 0 ;
33484 long arg2 ;
33485 wxWindow *result = 0 ;
33486 void *argp1 = 0 ;
33487 int res1 = 0 ;
33488 long val2 ;
33489 int ecode2 = 0 ;
33490 PyObject * obj0 = 0 ;
33491 PyObject * obj1 = 0 ;
33492 char * kwnames[] = {
33493 (char *) "self",(char *) "winid", NULL
33494 };
33495
33496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33498 if (!SWIG_IsOK(res1)) {
33499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33500 }
33501 arg1 = reinterpret_cast< wxWindow * >(argp1);
33502 ecode2 = SWIG_AsVal_long(obj1, &val2);
33503 if (!SWIG_IsOK(ecode2)) {
33504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33505 }
33506 arg2 = static_cast< long >(val2);
33507 {
33508 PyThreadState* __tstate = wxPyBeginAllowThreads();
33509 result = (wxWindow *)(arg1)->FindWindow(arg2);
33510 wxPyEndAllowThreads(__tstate);
33511 if (PyErr_Occurred()) SWIG_fail;
33512 }
33513 {
33514 resultobj = wxPyMake_wxObject(result, 0);
33515 }
33516 return resultobj;
33517 fail:
33518 return NULL;
33519 }
33520
33521
33522 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33523 PyObject *resultobj = 0;
33524 wxWindow *arg1 = (wxWindow *) 0 ;
33525 wxString *arg2 = 0 ;
33526 wxWindow *result = 0 ;
33527 void *argp1 = 0 ;
33528 int res1 = 0 ;
33529 bool temp2 = false ;
33530 PyObject * obj0 = 0 ;
33531 PyObject * obj1 = 0 ;
33532 char * kwnames[] = {
33533 (char *) "self",(char *) "name", NULL
33534 };
33535
33536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33538 if (!SWIG_IsOK(res1)) {
33539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33540 }
33541 arg1 = reinterpret_cast< wxWindow * >(argp1);
33542 {
33543 arg2 = wxString_in_helper(obj1);
33544 if (arg2 == NULL) SWIG_fail;
33545 temp2 = true;
33546 }
33547 {
33548 PyThreadState* __tstate = wxPyBeginAllowThreads();
33549 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33550 wxPyEndAllowThreads(__tstate);
33551 if (PyErr_Occurred()) SWIG_fail;
33552 }
33553 {
33554 resultobj = wxPyMake_wxObject(result, 0);
33555 }
33556 {
33557 if (temp2)
33558 delete arg2;
33559 }
33560 return resultobj;
33561 fail:
33562 {
33563 if (temp2)
33564 delete arg2;
33565 }
33566 return NULL;
33567 }
33568
33569
33570 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33571 PyObject *resultobj = 0;
33572 wxWindow *arg1 = (wxWindow *) 0 ;
33573 wxEvtHandler *result = 0 ;
33574 void *argp1 = 0 ;
33575 int res1 = 0 ;
33576 PyObject *swig_obj[1] ;
33577
33578 if (!args) SWIG_fail;
33579 swig_obj[0] = args;
33580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33581 if (!SWIG_IsOK(res1)) {
33582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33583 }
33584 arg1 = reinterpret_cast< wxWindow * >(argp1);
33585 {
33586 PyThreadState* __tstate = wxPyBeginAllowThreads();
33587 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33588 wxPyEndAllowThreads(__tstate);
33589 if (PyErr_Occurred()) SWIG_fail;
33590 }
33591 {
33592 resultobj = wxPyMake_wxObject(result, 0);
33593 }
33594 return resultobj;
33595 fail:
33596 return NULL;
33597 }
33598
33599
33600 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33601 PyObject *resultobj = 0;
33602 wxWindow *arg1 = (wxWindow *) 0 ;
33603 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33604 void *argp1 = 0 ;
33605 int res1 = 0 ;
33606 void *argp2 = 0 ;
33607 int res2 = 0 ;
33608 PyObject * obj0 = 0 ;
33609 PyObject * obj1 = 0 ;
33610 char * kwnames[] = {
33611 (char *) "self",(char *) "handler", NULL
33612 };
33613
33614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33616 if (!SWIG_IsOK(res1)) {
33617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33618 }
33619 arg1 = reinterpret_cast< wxWindow * >(argp1);
33620 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33621 if (!SWIG_IsOK(res2)) {
33622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33623 }
33624 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33625 {
33626 PyThreadState* __tstate = wxPyBeginAllowThreads();
33627 (arg1)->SetEventHandler(arg2);
33628 wxPyEndAllowThreads(__tstate);
33629 if (PyErr_Occurred()) SWIG_fail;
33630 }
33631 resultobj = SWIG_Py_Void();
33632 return resultobj;
33633 fail:
33634 return NULL;
33635 }
33636
33637
33638 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33639 PyObject *resultobj = 0;
33640 wxWindow *arg1 = (wxWindow *) 0 ;
33641 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33642 void *argp1 = 0 ;
33643 int res1 = 0 ;
33644 void *argp2 = 0 ;
33645 int res2 = 0 ;
33646 PyObject * obj0 = 0 ;
33647 PyObject * obj1 = 0 ;
33648 char * kwnames[] = {
33649 (char *) "self",(char *) "handler", NULL
33650 };
33651
33652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33654 if (!SWIG_IsOK(res1)) {
33655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33656 }
33657 arg1 = reinterpret_cast< wxWindow * >(argp1);
33658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33659 if (!SWIG_IsOK(res2)) {
33660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33661 }
33662 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33663 {
33664 PyThreadState* __tstate = wxPyBeginAllowThreads();
33665 (arg1)->PushEventHandler(arg2);
33666 wxPyEndAllowThreads(__tstate);
33667 if (PyErr_Occurred()) SWIG_fail;
33668 }
33669 resultobj = SWIG_Py_Void();
33670 return resultobj;
33671 fail:
33672 return NULL;
33673 }
33674
33675
33676 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33677 PyObject *resultobj = 0;
33678 wxWindow *arg1 = (wxWindow *) 0 ;
33679 bool arg2 = (bool) false ;
33680 wxEvtHandler *result = 0 ;
33681 void *argp1 = 0 ;
33682 int res1 = 0 ;
33683 bool val2 ;
33684 int ecode2 = 0 ;
33685 PyObject * obj0 = 0 ;
33686 PyObject * obj1 = 0 ;
33687 char * kwnames[] = {
33688 (char *) "self",(char *) "deleteHandler", NULL
33689 };
33690
33691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33693 if (!SWIG_IsOK(res1)) {
33694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33695 }
33696 arg1 = reinterpret_cast< wxWindow * >(argp1);
33697 if (obj1) {
33698 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33699 if (!SWIG_IsOK(ecode2)) {
33700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33701 }
33702 arg2 = static_cast< bool >(val2);
33703 }
33704 {
33705 PyThreadState* __tstate = wxPyBeginAllowThreads();
33706 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33707 wxPyEndAllowThreads(__tstate);
33708 if (PyErr_Occurred()) SWIG_fail;
33709 }
33710 {
33711 resultobj = wxPyMake_wxObject(result, 0);
33712 }
33713 return resultobj;
33714 fail:
33715 return NULL;
33716 }
33717
33718
33719 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33720 PyObject *resultobj = 0;
33721 wxWindow *arg1 = (wxWindow *) 0 ;
33722 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33723 bool result;
33724 void *argp1 = 0 ;
33725 int res1 = 0 ;
33726 void *argp2 = 0 ;
33727 int res2 = 0 ;
33728 PyObject * obj0 = 0 ;
33729 PyObject * obj1 = 0 ;
33730 char * kwnames[] = {
33731 (char *) "self",(char *) "handler", NULL
33732 };
33733
33734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33736 if (!SWIG_IsOK(res1)) {
33737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33738 }
33739 arg1 = reinterpret_cast< wxWindow * >(argp1);
33740 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33741 if (!SWIG_IsOK(res2)) {
33742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33743 }
33744 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33745 {
33746 PyThreadState* __tstate = wxPyBeginAllowThreads();
33747 result = (bool)(arg1)->RemoveEventHandler(arg2);
33748 wxPyEndAllowThreads(__tstate);
33749 if (PyErr_Occurred()) SWIG_fail;
33750 }
33751 {
33752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33753 }
33754 return resultobj;
33755 fail:
33756 return NULL;
33757 }
33758
33759
33760 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33761 PyObject *resultobj = 0;
33762 wxWindow *arg1 = (wxWindow *) 0 ;
33763 wxValidator *arg2 = 0 ;
33764 void *argp1 = 0 ;
33765 int res1 = 0 ;
33766 void *argp2 = 0 ;
33767 int res2 = 0 ;
33768 PyObject * obj0 = 0 ;
33769 PyObject * obj1 = 0 ;
33770 char * kwnames[] = {
33771 (char *) "self",(char *) "validator", NULL
33772 };
33773
33774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33776 if (!SWIG_IsOK(res1)) {
33777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33778 }
33779 arg1 = reinterpret_cast< wxWindow * >(argp1);
33780 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33781 if (!SWIG_IsOK(res2)) {
33782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33783 }
33784 if (!argp2) {
33785 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33786 }
33787 arg2 = reinterpret_cast< wxValidator * >(argp2);
33788 {
33789 PyThreadState* __tstate = wxPyBeginAllowThreads();
33790 (arg1)->SetValidator((wxValidator const &)*arg2);
33791 wxPyEndAllowThreads(__tstate);
33792 if (PyErr_Occurred()) SWIG_fail;
33793 }
33794 resultobj = SWIG_Py_Void();
33795 return resultobj;
33796 fail:
33797 return NULL;
33798 }
33799
33800
33801 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33802 PyObject *resultobj = 0;
33803 wxWindow *arg1 = (wxWindow *) 0 ;
33804 wxValidator *result = 0 ;
33805 void *argp1 = 0 ;
33806 int res1 = 0 ;
33807 PyObject *swig_obj[1] ;
33808
33809 if (!args) SWIG_fail;
33810 swig_obj[0] = args;
33811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33812 if (!SWIG_IsOK(res1)) {
33813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33814 }
33815 arg1 = reinterpret_cast< wxWindow * >(argp1);
33816 {
33817 PyThreadState* __tstate = wxPyBeginAllowThreads();
33818 result = (wxValidator *)(arg1)->GetValidator();
33819 wxPyEndAllowThreads(__tstate);
33820 if (PyErr_Occurred()) SWIG_fail;
33821 }
33822 {
33823 resultobj = wxPyMake_wxObject(result, (bool)0);
33824 }
33825 return resultobj;
33826 fail:
33827 return NULL;
33828 }
33829
33830
33831 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33832 PyObject *resultobj = 0;
33833 wxWindow *arg1 = (wxWindow *) 0 ;
33834 bool result;
33835 void *argp1 = 0 ;
33836 int res1 = 0 ;
33837 PyObject *swig_obj[1] ;
33838
33839 if (!args) SWIG_fail;
33840 swig_obj[0] = args;
33841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33842 if (!SWIG_IsOK(res1)) {
33843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33844 }
33845 arg1 = reinterpret_cast< wxWindow * >(argp1);
33846 {
33847 PyThreadState* __tstate = wxPyBeginAllowThreads();
33848 result = (bool)(arg1)->Validate();
33849 wxPyEndAllowThreads(__tstate);
33850 if (PyErr_Occurred()) SWIG_fail;
33851 }
33852 {
33853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33854 }
33855 return resultobj;
33856 fail:
33857 return NULL;
33858 }
33859
33860
33861 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33862 PyObject *resultobj = 0;
33863 wxWindow *arg1 = (wxWindow *) 0 ;
33864 bool result;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 PyObject *swig_obj[1] ;
33868
33869 if (!args) SWIG_fail;
33870 swig_obj[0] = args;
33871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33872 if (!SWIG_IsOK(res1)) {
33873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33874 }
33875 arg1 = reinterpret_cast< wxWindow * >(argp1);
33876 {
33877 PyThreadState* __tstate = wxPyBeginAllowThreads();
33878 result = (bool)(arg1)->TransferDataToWindow();
33879 wxPyEndAllowThreads(__tstate);
33880 if (PyErr_Occurred()) SWIG_fail;
33881 }
33882 {
33883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33884 }
33885 return resultobj;
33886 fail:
33887 return NULL;
33888 }
33889
33890
33891 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33892 PyObject *resultobj = 0;
33893 wxWindow *arg1 = (wxWindow *) 0 ;
33894 bool result;
33895 void *argp1 = 0 ;
33896 int res1 = 0 ;
33897 PyObject *swig_obj[1] ;
33898
33899 if (!args) SWIG_fail;
33900 swig_obj[0] = args;
33901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33902 if (!SWIG_IsOK(res1)) {
33903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33904 }
33905 arg1 = reinterpret_cast< wxWindow * >(argp1);
33906 {
33907 PyThreadState* __tstate = wxPyBeginAllowThreads();
33908 result = (bool)(arg1)->TransferDataFromWindow();
33909 wxPyEndAllowThreads(__tstate);
33910 if (PyErr_Occurred()) SWIG_fail;
33911 }
33912 {
33913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33914 }
33915 return resultobj;
33916 fail:
33917 return NULL;
33918 }
33919
33920
33921 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33922 PyObject *resultobj = 0;
33923 wxWindow *arg1 = (wxWindow *) 0 ;
33924 void *argp1 = 0 ;
33925 int res1 = 0 ;
33926 PyObject *swig_obj[1] ;
33927
33928 if (!args) SWIG_fail;
33929 swig_obj[0] = args;
33930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33931 if (!SWIG_IsOK(res1)) {
33932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33933 }
33934 arg1 = reinterpret_cast< wxWindow * >(argp1);
33935 {
33936 PyThreadState* __tstate = wxPyBeginAllowThreads();
33937 (arg1)->InitDialog();
33938 wxPyEndAllowThreads(__tstate);
33939 if (PyErr_Occurred()) SWIG_fail;
33940 }
33941 resultobj = SWIG_Py_Void();
33942 return resultobj;
33943 fail:
33944 return NULL;
33945 }
33946
33947
33948 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33949 PyObject *resultobj = 0;
33950 wxWindow *arg1 = (wxWindow *) 0 ;
33951 wxAcceleratorTable *arg2 = 0 ;
33952 void *argp1 = 0 ;
33953 int res1 = 0 ;
33954 void *argp2 = 0 ;
33955 int res2 = 0 ;
33956 PyObject * obj0 = 0 ;
33957 PyObject * obj1 = 0 ;
33958 char * kwnames[] = {
33959 (char *) "self",(char *) "accel", NULL
33960 };
33961
33962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33966 }
33967 arg1 = reinterpret_cast< wxWindow * >(argp1);
33968 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33969 if (!SWIG_IsOK(res2)) {
33970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33971 }
33972 if (!argp2) {
33973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33974 }
33975 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33976 {
33977 PyThreadState* __tstate = wxPyBeginAllowThreads();
33978 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33979 wxPyEndAllowThreads(__tstate);
33980 if (PyErr_Occurred()) SWIG_fail;
33981 }
33982 resultobj = SWIG_Py_Void();
33983 return resultobj;
33984 fail:
33985 return NULL;
33986 }
33987
33988
33989 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33990 PyObject *resultobj = 0;
33991 wxWindow *arg1 = (wxWindow *) 0 ;
33992 wxAcceleratorTable *result = 0 ;
33993 void *argp1 = 0 ;
33994 int res1 = 0 ;
33995 PyObject *swig_obj[1] ;
33996
33997 if (!args) SWIG_fail;
33998 swig_obj[0] = args;
33999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34000 if (!SWIG_IsOK(res1)) {
34001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34002 }
34003 arg1 = reinterpret_cast< wxWindow * >(argp1);
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34007 wxPyEndAllowThreads(__tstate);
34008 if (PyErr_Occurred()) SWIG_fail;
34009 }
34010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34011 return resultobj;
34012 fail:
34013 return NULL;
34014 }
34015
34016
34017 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34018 PyObject *resultobj = 0;
34019 wxWindow *arg1 = (wxWindow *) 0 ;
34020 int arg2 ;
34021 int arg3 ;
34022 int arg4 ;
34023 bool result;
34024 void *argp1 = 0 ;
34025 int res1 = 0 ;
34026 int val2 ;
34027 int ecode2 = 0 ;
34028 int val3 ;
34029 int ecode3 = 0 ;
34030 int val4 ;
34031 int ecode4 = 0 ;
34032 PyObject * obj0 = 0 ;
34033 PyObject * obj1 = 0 ;
34034 PyObject * obj2 = 0 ;
34035 PyObject * obj3 = 0 ;
34036 char * kwnames[] = {
34037 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34038 };
34039
34040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34042 if (!SWIG_IsOK(res1)) {
34043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34044 }
34045 arg1 = reinterpret_cast< wxWindow * >(argp1);
34046 ecode2 = SWIG_AsVal_int(obj1, &val2);
34047 if (!SWIG_IsOK(ecode2)) {
34048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34049 }
34050 arg2 = static_cast< int >(val2);
34051 ecode3 = SWIG_AsVal_int(obj2, &val3);
34052 if (!SWIG_IsOK(ecode3)) {
34053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34054 }
34055 arg3 = static_cast< int >(val3);
34056 ecode4 = SWIG_AsVal_int(obj3, &val4);
34057 if (!SWIG_IsOK(ecode4)) {
34058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34059 }
34060 arg4 = static_cast< int >(val4);
34061 {
34062 PyThreadState* __tstate = wxPyBeginAllowThreads();
34063 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34064 wxPyEndAllowThreads(__tstate);
34065 if (PyErr_Occurred()) SWIG_fail;
34066 }
34067 {
34068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34069 }
34070 return resultobj;
34071 fail:
34072 return NULL;
34073 }
34074
34075
34076 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34077 PyObject *resultobj = 0;
34078 wxWindow *arg1 = (wxWindow *) 0 ;
34079 int arg2 ;
34080 bool result;
34081 void *argp1 = 0 ;
34082 int res1 = 0 ;
34083 int val2 ;
34084 int ecode2 = 0 ;
34085 PyObject * obj0 = 0 ;
34086 PyObject * obj1 = 0 ;
34087 char * kwnames[] = {
34088 (char *) "self",(char *) "hotkeyId", NULL
34089 };
34090
34091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34093 if (!SWIG_IsOK(res1)) {
34094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34095 }
34096 arg1 = reinterpret_cast< wxWindow * >(argp1);
34097 ecode2 = SWIG_AsVal_int(obj1, &val2);
34098 if (!SWIG_IsOK(ecode2)) {
34099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34100 }
34101 arg2 = static_cast< int >(val2);
34102 {
34103 PyThreadState* __tstate = wxPyBeginAllowThreads();
34104 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34105 wxPyEndAllowThreads(__tstate);
34106 if (PyErr_Occurred()) SWIG_fail;
34107 }
34108 {
34109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34110 }
34111 return resultobj;
34112 fail:
34113 return NULL;
34114 }
34115
34116
34117 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34118 PyObject *resultobj = 0;
34119 wxWindow *arg1 = (wxWindow *) 0 ;
34120 wxPoint *arg2 = 0 ;
34121 wxPoint result;
34122 void *argp1 = 0 ;
34123 int res1 = 0 ;
34124 wxPoint temp2 ;
34125 PyObject * obj0 = 0 ;
34126 PyObject * obj1 = 0 ;
34127 char * kwnames[] = {
34128 (char *) "self",(char *) "pt", NULL
34129 };
34130
34131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34133 if (!SWIG_IsOK(res1)) {
34134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34135 }
34136 arg1 = reinterpret_cast< wxWindow * >(argp1);
34137 {
34138 arg2 = &temp2;
34139 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34140 }
34141 {
34142 PyThreadState* __tstate = wxPyBeginAllowThreads();
34143 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34144 wxPyEndAllowThreads(__tstate);
34145 if (PyErr_Occurred()) SWIG_fail;
34146 }
34147 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34148 return resultobj;
34149 fail:
34150 return NULL;
34151 }
34152
34153
34154 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34155 PyObject *resultobj = 0;
34156 wxWindow *arg1 = (wxWindow *) 0 ;
34157 wxSize *arg2 = 0 ;
34158 wxSize result;
34159 void *argp1 = 0 ;
34160 int res1 = 0 ;
34161 wxSize temp2 ;
34162 PyObject * obj0 = 0 ;
34163 PyObject * obj1 = 0 ;
34164 char * kwnames[] = {
34165 (char *) "self",(char *) "sz", NULL
34166 };
34167
34168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34170 if (!SWIG_IsOK(res1)) {
34171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34172 }
34173 arg1 = reinterpret_cast< wxWindow * >(argp1);
34174 {
34175 arg2 = &temp2;
34176 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34177 }
34178 {
34179 PyThreadState* __tstate = wxPyBeginAllowThreads();
34180 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34181 wxPyEndAllowThreads(__tstate);
34182 if (PyErr_Occurred()) SWIG_fail;
34183 }
34184 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34185 return resultobj;
34186 fail:
34187 return NULL;
34188 }
34189
34190
34191 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34192 PyObject *resultobj = 0;
34193 wxWindow *arg1 = (wxWindow *) 0 ;
34194 wxPoint *arg2 = 0 ;
34195 wxPoint result;
34196 void *argp1 = 0 ;
34197 int res1 = 0 ;
34198 wxPoint temp2 ;
34199 PyObject * obj0 = 0 ;
34200 PyObject * obj1 = 0 ;
34201 char * kwnames[] = {
34202 (char *) "self",(char *) "pt", NULL
34203 };
34204
34205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34207 if (!SWIG_IsOK(res1)) {
34208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34209 }
34210 arg1 = reinterpret_cast< wxWindow * >(argp1);
34211 {
34212 arg2 = &temp2;
34213 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34214 }
34215 {
34216 PyThreadState* __tstate = wxPyBeginAllowThreads();
34217 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34218 wxPyEndAllowThreads(__tstate);
34219 if (PyErr_Occurred()) SWIG_fail;
34220 }
34221 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34222 return resultobj;
34223 fail:
34224 return NULL;
34225 }
34226
34227
34228 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34229 PyObject *resultobj = 0;
34230 wxWindow *arg1 = (wxWindow *) 0 ;
34231 wxSize *arg2 = 0 ;
34232 wxSize result;
34233 void *argp1 = 0 ;
34234 int res1 = 0 ;
34235 wxSize temp2 ;
34236 PyObject * obj0 = 0 ;
34237 PyObject * obj1 = 0 ;
34238 char * kwnames[] = {
34239 (char *) "self",(char *) "sz", NULL
34240 };
34241
34242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34244 if (!SWIG_IsOK(res1)) {
34245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34246 }
34247 arg1 = reinterpret_cast< wxWindow * >(argp1);
34248 {
34249 arg2 = &temp2;
34250 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34251 }
34252 {
34253 PyThreadState* __tstate = wxPyBeginAllowThreads();
34254 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34255 wxPyEndAllowThreads(__tstate);
34256 if (PyErr_Occurred()) SWIG_fail;
34257 }
34258 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34259 return resultobj;
34260 fail:
34261 return NULL;
34262 }
34263
34264
34265 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34266 PyObject *resultobj = 0;
34267 wxWindow *arg1 = (wxWindow *) 0 ;
34268 wxPoint *arg2 = 0 ;
34269 wxPoint result;
34270 void *argp1 = 0 ;
34271 int res1 = 0 ;
34272 wxPoint temp2 ;
34273 PyObject * obj0 = 0 ;
34274 PyObject * obj1 = 0 ;
34275 char * kwnames[] = {
34276 (char *) "self",(char *) "pt", NULL
34277 };
34278
34279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34281 if (!SWIG_IsOK(res1)) {
34282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34283 }
34284 arg1 = reinterpret_cast< wxWindow * >(argp1);
34285 {
34286 arg2 = &temp2;
34287 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34288 }
34289 {
34290 PyThreadState* __tstate = wxPyBeginAllowThreads();
34291 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34292 wxPyEndAllowThreads(__tstate);
34293 if (PyErr_Occurred()) SWIG_fail;
34294 }
34295 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34296 return resultobj;
34297 fail:
34298 return NULL;
34299 }
34300
34301
34302 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34303 PyObject *resultobj = 0;
34304 wxWindow *arg1 = (wxWindow *) 0 ;
34305 wxSize *arg2 = 0 ;
34306 wxSize result;
34307 void *argp1 = 0 ;
34308 int res1 = 0 ;
34309 wxSize temp2 ;
34310 PyObject * obj0 = 0 ;
34311 PyObject * obj1 = 0 ;
34312 char * kwnames[] = {
34313 (char *) "self",(char *) "sz", NULL
34314 };
34315
34316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34318 if (!SWIG_IsOK(res1)) {
34319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34320 }
34321 arg1 = reinterpret_cast< wxWindow * >(argp1);
34322 {
34323 arg2 = &temp2;
34324 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34325 }
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34340 PyObject *resultobj = 0;
34341 wxWindow *arg1 = (wxWindow *) 0 ;
34342 int arg2 ;
34343 int arg3 ;
34344 void *argp1 = 0 ;
34345 int res1 = 0 ;
34346 int val2 ;
34347 int ecode2 = 0 ;
34348 int val3 ;
34349 int ecode3 = 0 ;
34350 PyObject * obj0 = 0 ;
34351 PyObject * obj1 = 0 ;
34352 PyObject * obj2 = 0 ;
34353 char * kwnames[] = {
34354 (char *) "self",(char *) "x",(char *) "y", NULL
34355 };
34356
34357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34359 if (!SWIG_IsOK(res1)) {
34360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34361 }
34362 arg1 = reinterpret_cast< wxWindow * >(argp1);
34363 ecode2 = SWIG_AsVal_int(obj1, &val2);
34364 if (!SWIG_IsOK(ecode2)) {
34365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34366 }
34367 arg2 = static_cast< int >(val2);
34368 ecode3 = SWIG_AsVal_int(obj2, &val3);
34369 if (!SWIG_IsOK(ecode3)) {
34370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34371 }
34372 arg3 = static_cast< int >(val3);
34373 {
34374 PyThreadState* __tstate = wxPyBeginAllowThreads();
34375 (arg1)->WarpPointer(arg2,arg3);
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 resultobj = SWIG_Py_Void();
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34387 PyObject *resultobj = 0;
34388 wxWindow *arg1 = (wxWindow *) 0 ;
34389 void *argp1 = 0 ;
34390 int res1 = 0 ;
34391 PyObject *swig_obj[1] ;
34392
34393 if (!args) SWIG_fail;
34394 swig_obj[0] = args;
34395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34398 }
34399 arg1 = reinterpret_cast< wxWindow * >(argp1);
34400 {
34401 PyThreadState* __tstate = wxPyBeginAllowThreads();
34402 (arg1)->CaptureMouse();
34403 wxPyEndAllowThreads(__tstate);
34404 if (PyErr_Occurred()) SWIG_fail;
34405 }
34406 resultobj = SWIG_Py_Void();
34407 return resultobj;
34408 fail:
34409 return NULL;
34410 }
34411
34412
34413 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34414 PyObject *resultobj = 0;
34415 wxWindow *arg1 = (wxWindow *) 0 ;
34416 void *argp1 = 0 ;
34417 int res1 = 0 ;
34418 PyObject *swig_obj[1] ;
34419
34420 if (!args) SWIG_fail;
34421 swig_obj[0] = args;
34422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34423 if (!SWIG_IsOK(res1)) {
34424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34425 }
34426 arg1 = reinterpret_cast< wxWindow * >(argp1);
34427 {
34428 PyThreadState* __tstate = wxPyBeginAllowThreads();
34429 (arg1)->ReleaseMouse();
34430 wxPyEndAllowThreads(__tstate);
34431 if (PyErr_Occurred()) SWIG_fail;
34432 }
34433 resultobj = SWIG_Py_Void();
34434 return resultobj;
34435 fail:
34436 return NULL;
34437 }
34438
34439
34440 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34441 PyObject *resultobj = 0;
34442 wxWindow *result = 0 ;
34443
34444 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34445 {
34446 if (!wxPyCheckForApp()) SWIG_fail;
34447 PyThreadState* __tstate = wxPyBeginAllowThreads();
34448 result = (wxWindow *)wxWindow::GetCapture();
34449 wxPyEndAllowThreads(__tstate);
34450 if (PyErr_Occurred()) SWIG_fail;
34451 }
34452 {
34453 resultobj = wxPyMake_wxObject(result, 0);
34454 }
34455 return resultobj;
34456 fail:
34457 return NULL;
34458 }
34459
34460
34461 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34462 PyObject *resultobj = 0;
34463 wxWindow *arg1 = (wxWindow *) 0 ;
34464 bool result;
34465 void *argp1 = 0 ;
34466 int res1 = 0 ;
34467 PyObject *swig_obj[1] ;
34468
34469 if (!args) SWIG_fail;
34470 swig_obj[0] = args;
34471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34472 if (!SWIG_IsOK(res1)) {
34473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34474 }
34475 arg1 = reinterpret_cast< wxWindow * >(argp1);
34476 {
34477 PyThreadState* __tstate = wxPyBeginAllowThreads();
34478 result = (bool)((wxWindow const *)arg1)->HasCapture();
34479 wxPyEndAllowThreads(__tstate);
34480 if (PyErr_Occurred()) SWIG_fail;
34481 }
34482 {
34483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34484 }
34485 return resultobj;
34486 fail:
34487 return NULL;
34488 }
34489
34490
34491 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34492 PyObject *resultobj = 0;
34493 wxWindow *arg1 = (wxWindow *) 0 ;
34494 bool arg2 = (bool) true ;
34495 wxRect *arg3 = (wxRect *) NULL ;
34496 void *argp1 = 0 ;
34497 int res1 = 0 ;
34498 bool val2 ;
34499 int ecode2 = 0 ;
34500 void *argp3 = 0 ;
34501 int res3 = 0 ;
34502 PyObject * obj0 = 0 ;
34503 PyObject * obj1 = 0 ;
34504 PyObject * obj2 = 0 ;
34505 char * kwnames[] = {
34506 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34507 };
34508
34509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34511 if (!SWIG_IsOK(res1)) {
34512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34513 }
34514 arg1 = reinterpret_cast< wxWindow * >(argp1);
34515 if (obj1) {
34516 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34517 if (!SWIG_IsOK(ecode2)) {
34518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34519 }
34520 arg2 = static_cast< bool >(val2);
34521 }
34522 if (obj2) {
34523 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34524 if (!SWIG_IsOK(res3)) {
34525 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34526 }
34527 arg3 = reinterpret_cast< wxRect * >(argp3);
34528 }
34529 {
34530 PyThreadState* __tstate = wxPyBeginAllowThreads();
34531 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34532 wxPyEndAllowThreads(__tstate);
34533 if (PyErr_Occurred()) SWIG_fail;
34534 }
34535 resultobj = SWIG_Py_Void();
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34543 PyObject *resultobj = 0;
34544 wxWindow *arg1 = (wxWindow *) 0 ;
34545 wxRect *arg2 = 0 ;
34546 bool arg3 = (bool) true ;
34547 void *argp1 = 0 ;
34548 int res1 = 0 ;
34549 wxRect temp2 ;
34550 bool val3 ;
34551 int ecode3 = 0 ;
34552 PyObject * obj0 = 0 ;
34553 PyObject * obj1 = 0 ;
34554 PyObject * obj2 = 0 ;
34555 char * kwnames[] = {
34556 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34557 };
34558
34559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34561 if (!SWIG_IsOK(res1)) {
34562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34563 }
34564 arg1 = reinterpret_cast< wxWindow * >(argp1);
34565 {
34566 arg2 = &temp2;
34567 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34568 }
34569 if (obj2) {
34570 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34571 if (!SWIG_IsOK(ecode3)) {
34572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34573 }
34574 arg3 = static_cast< bool >(val3);
34575 }
34576 {
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 resultobj = SWIG_Py_Void();
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34590 PyObject *resultobj = 0;
34591 wxWindow *arg1 = (wxWindow *) 0 ;
34592 void *argp1 = 0 ;
34593 int res1 = 0 ;
34594 PyObject *swig_obj[1] ;
34595
34596 if (!args) SWIG_fail;
34597 swig_obj[0] = args;
34598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34599 if (!SWIG_IsOK(res1)) {
34600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34601 }
34602 arg1 = reinterpret_cast< wxWindow * >(argp1);
34603 {
34604 PyThreadState* __tstate = wxPyBeginAllowThreads();
34605 (arg1)->Update();
34606 wxPyEndAllowThreads(__tstate);
34607 if (PyErr_Occurred()) SWIG_fail;
34608 }
34609 resultobj = SWIG_Py_Void();
34610 return resultobj;
34611 fail:
34612 return NULL;
34613 }
34614
34615
34616 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34617 PyObject *resultobj = 0;
34618 wxWindow *arg1 = (wxWindow *) 0 ;
34619 void *argp1 = 0 ;
34620 int res1 = 0 ;
34621 PyObject *swig_obj[1] ;
34622
34623 if (!args) SWIG_fail;
34624 swig_obj[0] = args;
34625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34626 if (!SWIG_IsOK(res1)) {
34627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34628 }
34629 arg1 = reinterpret_cast< wxWindow * >(argp1);
34630 {
34631 PyThreadState* __tstate = wxPyBeginAllowThreads();
34632 (arg1)->ClearBackground();
34633 wxPyEndAllowThreads(__tstate);
34634 if (PyErr_Occurred()) SWIG_fail;
34635 }
34636 resultobj = SWIG_Py_Void();
34637 return resultobj;
34638 fail:
34639 return NULL;
34640 }
34641
34642
34643 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34644 PyObject *resultobj = 0;
34645 wxWindow *arg1 = (wxWindow *) 0 ;
34646 void *argp1 = 0 ;
34647 int res1 = 0 ;
34648 PyObject *swig_obj[1] ;
34649
34650 if (!args) SWIG_fail;
34651 swig_obj[0] = args;
34652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34653 if (!SWIG_IsOK(res1)) {
34654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34655 }
34656 arg1 = reinterpret_cast< wxWindow * >(argp1);
34657 {
34658 PyThreadState* __tstate = wxPyBeginAllowThreads();
34659 (arg1)->Freeze();
34660 wxPyEndAllowThreads(__tstate);
34661 if (PyErr_Occurred()) SWIG_fail;
34662 }
34663 resultobj = SWIG_Py_Void();
34664 return resultobj;
34665 fail:
34666 return NULL;
34667 }
34668
34669
34670 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34671 PyObject *resultobj = 0;
34672 wxWindow *arg1 = (wxWindow *) 0 ;
34673 void *argp1 = 0 ;
34674 int res1 = 0 ;
34675 PyObject *swig_obj[1] ;
34676
34677 if (!args) SWIG_fail;
34678 swig_obj[0] = args;
34679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34680 if (!SWIG_IsOK(res1)) {
34681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34682 }
34683 arg1 = reinterpret_cast< wxWindow * >(argp1);
34684 {
34685 PyThreadState* __tstate = wxPyBeginAllowThreads();
34686 (arg1)->Thaw();
34687 wxPyEndAllowThreads(__tstate);
34688 if (PyErr_Occurred()) SWIG_fail;
34689 }
34690 resultobj = SWIG_Py_Void();
34691 return resultobj;
34692 fail:
34693 return NULL;
34694 }
34695
34696
34697 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34698 PyObject *resultobj = 0;
34699 wxWindow *arg1 = (wxWindow *) 0 ;
34700 wxDC *arg2 = 0 ;
34701 void *argp1 = 0 ;
34702 int res1 = 0 ;
34703 void *argp2 = 0 ;
34704 int res2 = 0 ;
34705 PyObject * obj0 = 0 ;
34706 PyObject * obj1 = 0 ;
34707 char * kwnames[] = {
34708 (char *) "self",(char *) "dc", NULL
34709 };
34710
34711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34713 if (!SWIG_IsOK(res1)) {
34714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34715 }
34716 arg1 = reinterpret_cast< wxWindow * >(argp1);
34717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34718 if (!SWIG_IsOK(res2)) {
34719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34720 }
34721 if (!argp2) {
34722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34723 }
34724 arg2 = reinterpret_cast< wxDC * >(argp2);
34725 {
34726 PyThreadState* __tstate = wxPyBeginAllowThreads();
34727 (arg1)->PrepareDC(*arg2);
34728 wxPyEndAllowThreads(__tstate);
34729 if (PyErr_Occurred()) SWIG_fail;
34730 }
34731 resultobj = SWIG_Py_Void();
34732 return resultobj;
34733 fail:
34734 return NULL;
34735 }
34736
34737
34738 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34739 PyObject *resultobj = 0;
34740 wxWindow *arg1 = (wxWindow *) 0 ;
34741 wxRegion *result = 0 ;
34742 void *argp1 = 0 ;
34743 int res1 = 0 ;
34744 PyObject *swig_obj[1] ;
34745
34746 if (!args) SWIG_fail;
34747 swig_obj[0] = args;
34748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34749 if (!SWIG_IsOK(res1)) {
34750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34751 }
34752 arg1 = reinterpret_cast< wxWindow * >(argp1);
34753 {
34754 PyThreadState* __tstate = wxPyBeginAllowThreads();
34755 {
34756 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34757 result = (wxRegion *) &_result_ref;
34758 }
34759 wxPyEndAllowThreads(__tstate);
34760 if (PyErr_Occurred()) SWIG_fail;
34761 }
34762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34763 return resultobj;
34764 fail:
34765 return NULL;
34766 }
34767
34768
34769 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34770 PyObject *resultobj = 0;
34771 wxWindow *arg1 = (wxWindow *) 0 ;
34772 wxRect result;
34773 void *argp1 = 0 ;
34774 int res1 = 0 ;
34775 PyObject *swig_obj[1] ;
34776
34777 if (!args) SWIG_fail;
34778 swig_obj[0] = args;
34779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34780 if (!SWIG_IsOK(res1)) {
34781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34782 }
34783 arg1 = reinterpret_cast< wxWindow * >(argp1);
34784 {
34785 PyThreadState* __tstate = wxPyBeginAllowThreads();
34786 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34787 wxPyEndAllowThreads(__tstate);
34788 if (PyErr_Occurred()) SWIG_fail;
34789 }
34790 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34791 return resultobj;
34792 fail:
34793 return NULL;
34794 }
34795
34796
34797 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34798 PyObject *resultobj = 0;
34799 wxWindow *arg1 = (wxWindow *) 0 ;
34800 int arg2 ;
34801 int arg3 ;
34802 int arg4 = (int) 1 ;
34803 int arg5 = (int) 1 ;
34804 bool result;
34805 void *argp1 = 0 ;
34806 int res1 = 0 ;
34807 int val2 ;
34808 int ecode2 = 0 ;
34809 int val3 ;
34810 int ecode3 = 0 ;
34811 int val4 ;
34812 int ecode4 = 0 ;
34813 int val5 ;
34814 int ecode5 = 0 ;
34815 PyObject * obj0 = 0 ;
34816 PyObject * obj1 = 0 ;
34817 PyObject * obj2 = 0 ;
34818 PyObject * obj3 = 0 ;
34819 PyObject * obj4 = 0 ;
34820 char * kwnames[] = {
34821 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34822 };
34823
34824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34826 if (!SWIG_IsOK(res1)) {
34827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34828 }
34829 arg1 = reinterpret_cast< wxWindow * >(argp1);
34830 ecode2 = SWIG_AsVal_int(obj1, &val2);
34831 if (!SWIG_IsOK(ecode2)) {
34832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34833 }
34834 arg2 = static_cast< int >(val2);
34835 ecode3 = SWIG_AsVal_int(obj2, &val3);
34836 if (!SWIG_IsOK(ecode3)) {
34837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34838 }
34839 arg3 = static_cast< int >(val3);
34840 if (obj3) {
34841 ecode4 = SWIG_AsVal_int(obj3, &val4);
34842 if (!SWIG_IsOK(ecode4)) {
34843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34844 }
34845 arg4 = static_cast< int >(val4);
34846 }
34847 if (obj4) {
34848 ecode5 = SWIG_AsVal_int(obj4, &val5);
34849 if (!SWIG_IsOK(ecode5)) {
34850 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34851 }
34852 arg5 = static_cast< int >(val5);
34853 }
34854 {
34855 PyThreadState* __tstate = wxPyBeginAllowThreads();
34856 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34857 wxPyEndAllowThreads(__tstate);
34858 if (PyErr_Occurred()) SWIG_fail;
34859 }
34860 {
34861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34862 }
34863 return resultobj;
34864 fail:
34865 return NULL;
34866 }
34867
34868
34869 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34870 PyObject *resultobj = 0;
34871 wxWindow *arg1 = (wxWindow *) 0 ;
34872 wxPoint *arg2 = 0 ;
34873 bool result;
34874 void *argp1 = 0 ;
34875 int res1 = 0 ;
34876 wxPoint temp2 ;
34877 PyObject * obj0 = 0 ;
34878 PyObject * obj1 = 0 ;
34879 char * kwnames[] = {
34880 (char *) "self",(char *) "pt", NULL
34881 };
34882
34883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34885 if (!SWIG_IsOK(res1)) {
34886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34887 }
34888 arg1 = reinterpret_cast< wxWindow * >(argp1);
34889 {
34890 arg2 = &temp2;
34891 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34892 }
34893 {
34894 PyThreadState* __tstate = wxPyBeginAllowThreads();
34895 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 {
34900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34901 }
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34909 PyObject *resultobj = 0;
34910 wxWindow *arg1 = (wxWindow *) 0 ;
34911 wxRect *arg2 = 0 ;
34912 bool result;
34913 void *argp1 = 0 ;
34914 int res1 = 0 ;
34915 wxRect temp2 ;
34916 PyObject * obj0 = 0 ;
34917 PyObject * obj1 = 0 ;
34918 char * kwnames[] = {
34919 (char *) "self",(char *) "rect", NULL
34920 };
34921
34922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34924 if (!SWIG_IsOK(res1)) {
34925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34926 }
34927 arg1 = reinterpret_cast< wxWindow * >(argp1);
34928 {
34929 arg2 = &temp2;
34930 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34931 }
34932 {
34933 PyThreadState* __tstate = wxPyBeginAllowThreads();
34934 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34935 wxPyEndAllowThreads(__tstate);
34936 if (PyErr_Occurred()) SWIG_fail;
34937 }
34938 {
34939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34940 }
34941 return resultobj;
34942 fail:
34943 return NULL;
34944 }
34945
34946
34947 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34948 PyObject *resultobj = 0;
34949 wxWindow *arg1 = (wxWindow *) 0 ;
34950 SwigValueWrapper<wxVisualAttributes > result;
34951 void *argp1 = 0 ;
34952 int res1 = 0 ;
34953 PyObject *swig_obj[1] ;
34954
34955 if (!args) SWIG_fail;
34956 swig_obj[0] = args;
34957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34958 if (!SWIG_IsOK(res1)) {
34959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34960 }
34961 arg1 = reinterpret_cast< wxWindow * >(argp1);
34962 {
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34969 return resultobj;
34970 fail:
34971 return NULL;
34972 }
34973
34974
34975 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34976 PyObject *resultobj = 0;
34977 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34978 SwigValueWrapper<wxVisualAttributes > result;
34979 int val1 ;
34980 int ecode1 = 0 ;
34981 PyObject * obj0 = 0 ;
34982 char * kwnames[] = {
34983 (char *) "variant", NULL
34984 };
34985
34986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34987 if (obj0) {
34988 ecode1 = SWIG_AsVal_int(obj0, &val1);
34989 if (!SWIG_IsOK(ecode1)) {
34990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34991 }
34992 arg1 = static_cast< wxWindowVariant >(val1);
34993 }
34994 {
34995 if (!wxPyCheckForApp()) SWIG_fail;
34996 PyThreadState* __tstate = wxPyBeginAllowThreads();
34997 result = wxWindow::GetClassDefaultAttributes(arg1);
34998 wxPyEndAllowThreads(__tstate);
34999 if (PyErr_Occurred()) SWIG_fail;
35000 }
35001 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35002 return resultobj;
35003 fail:
35004 return NULL;
35005 }
35006
35007
35008 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35009 PyObject *resultobj = 0;
35010 wxWindow *arg1 = (wxWindow *) 0 ;
35011 wxColour *arg2 = 0 ;
35012 bool result;
35013 void *argp1 = 0 ;
35014 int res1 = 0 ;
35015 wxColour temp2 ;
35016 PyObject * obj0 = 0 ;
35017 PyObject * obj1 = 0 ;
35018 char * kwnames[] = {
35019 (char *) "self",(char *) "colour", NULL
35020 };
35021
35022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35024 if (!SWIG_IsOK(res1)) {
35025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35026 }
35027 arg1 = reinterpret_cast< wxWindow * >(argp1);
35028 {
35029 arg2 = &temp2;
35030 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35031 }
35032 {
35033 PyThreadState* __tstate = wxPyBeginAllowThreads();
35034 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35035 wxPyEndAllowThreads(__tstate);
35036 if (PyErr_Occurred()) SWIG_fail;
35037 }
35038 {
35039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35040 }
35041 return resultobj;
35042 fail:
35043 return NULL;
35044 }
35045
35046
35047 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35048 PyObject *resultobj = 0;
35049 wxWindow *arg1 = (wxWindow *) 0 ;
35050 wxColour *arg2 = 0 ;
35051 void *argp1 = 0 ;
35052 int res1 = 0 ;
35053 wxColour temp2 ;
35054 PyObject * obj0 = 0 ;
35055 PyObject * obj1 = 0 ;
35056 char * kwnames[] = {
35057 (char *) "self",(char *) "colour", NULL
35058 };
35059
35060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35062 if (!SWIG_IsOK(res1)) {
35063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35064 }
35065 arg1 = reinterpret_cast< wxWindow * >(argp1);
35066 {
35067 arg2 = &temp2;
35068 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35069 }
35070 {
35071 PyThreadState* __tstate = wxPyBeginAllowThreads();
35072 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35073 wxPyEndAllowThreads(__tstate);
35074 if (PyErr_Occurred()) SWIG_fail;
35075 }
35076 resultobj = SWIG_Py_Void();
35077 return resultobj;
35078 fail:
35079 return NULL;
35080 }
35081
35082
35083 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35084 PyObject *resultobj = 0;
35085 wxWindow *arg1 = (wxWindow *) 0 ;
35086 wxColour *arg2 = 0 ;
35087 bool result;
35088 void *argp1 = 0 ;
35089 int res1 = 0 ;
35090 wxColour temp2 ;
35091 PyObject * obj0 = 0 ;
35092 PyObject * obj1 = 0 ;
35093 char * kwnames[] = {
35094 (char *) "self",(char *) "colour", NULL
35095 };
35096
35097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35099 if (!SWIG_IsOK(res1)) {
35100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35101 }
35102 arg1 = reinterpret_cast< wxWindow * >(argp1);
35103 {
35104 arg2 = &temp2;
35105 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35106 }
35107 {
35108 PyThreadState* __tstate = wxPyBeginAllowThreads();
35109 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35110 wxPyEndAllowThreads(__tstate);
35111 if (PyErr_Occurred()) SWIG_fail;
35112 }
35113 {
35114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35115 }
35116 return resultobj;
35117 fail:
35118 return NULL;
35119 }
35120
35121
35122 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35123 PyObject *resultobj = 0;
35124 wxWindow *arg1 = (wxWindow *) 0 ;
35125 wxColour *arg2 = 0 ;
35126 void *argp1 = 0 ;
35127 int res1 = 0 ;
35128 wxColour temp2 ;
35129 PyObject * obj0 = 0 ;
35130 PyObject * obj1 = 0 ;
35131 char * kwnames[] = {
35132 (char *) "self",(char *) "colour", NULL
35133 };
35134
35135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35137 if (!SWIG_IsOK(res1)) {
35138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35139 }
35140 arg1 = reinterpret_cast< wxWindow * >(argp1);
35141 {
35142 arg2 = &temp2;
35143 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35144 }
35145 {
35146 PyThreadState* __tstate = wxPyBeginAllowThreads();
35147 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35148 wxPyEndAllowThreads(__tstate);
35149 if (PyErr_Occurred()) SWIG_fail;
35150 }
35151 resultobj = SWIG_Py_Void();
35152 return resultobj;
35153 fail:
35154 return NULL;
35155 }
35156
35157
35158 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35159 PyObject *resultobj = 0;
35160 wxWindow *arg1 = (wxWindow *) 0 ;
35161 wxColour result;
35162 void *argp1 = 0 ;
35163 int res1 = 0 ;
35164 PyObject *swig_obj[1] ;
35165
35166 if (!args) SWIG_fail;
35167 swig_obj[0] = args;
35168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35169 if (!SWIG_IsOK(res1)) {
35170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35171 }
35172 arg1 = reinterpret_cast< wxWindow * >(argp1);
35173 {
35174 PyThreadState* __tstate = wxPyBeginAllowThreads();
35175 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35176 wxPyEndAllowThreads(__tstate);
35177 if (PyErr_Occurred()) SWIG_fail;
35178 }
35179 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35180 return resultobj;
35181 fail:
35182 return NULL;
35183 }
35184
35185
35186 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35187 PyObject *resultobj = 0;
35188 wxWindow *arg1 = (wxWindow *) 0 ;
35189 wxColour result;
35190 void *argp1 = 0 ;
35191 int res1 = 0 ;
35192 PyObject *swig_obj[1] ;
35193
35194 if (!args) SWIG_fail;
35195 swig_obj[0] = args;
35196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35197 if (!SWIG_IsOK(res1)) {
35198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35199 }
35200 arg1 = reinterpret_cast< wxWindow * >(argp1);
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 result = ((wxWindow const *)arg1)->GetForegroundColour();
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35215 PyObject *resultobj = 0;
35216 wxWindow *arg1 = (wxWindow *) 0 ;
35217 bool result;
35218 void *argp1 = 0 ;
35219 int res1 = 0 ;
35220 PyObject *swig_obj[1] ;
35221
35222 if (!args) SWIG_fail;
35223 swig_obj[0] = args;
35224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35225 if (!SWIG_IsOK(res1)) {
35226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35227 }
35228 arg1 = reinterpret_cast< wxWindow * >(argp1);
35229 {
35230 PyThreadState* __tstate = wxPyBeginAllowThreads();
35231 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35232 wxPyEndAllowThreads(__tstate);
35233 if (PyErr_Occurred()) SWIG_fail;
35234 }
35235 {
35236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35237 }
35238 return resultobj;
35239 fail:
35240 return NULL;
35241 }
35242
35243
35244 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35245 PyObject *resultobj = 0;
35246 wxWindow *arg1 = (wxWindow *) 0 ;
35247 bool result;
35248 void *argp1 = 0 ;
35249 int res1 = 0 ;
35250 PyObject *swig_obj[1] ;
35251
35252 if (!args) SWIG_fail;
35253 swig_obj[0] = args;
35254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35255 if (!SWIG_IsOK(res1)) {
35256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35257 }
35258 arg1 = reinterpret_cast< wxWindow * >(argp1);
35259 {
35260 PyThreadState* __tstate = wxPyBeginAllowThreads();
35261 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35262 wxPyEndAllowThreads(__tstate);
35263 if (PyErr_Occurred()) SWIG_fail;
35264 }
35265 {
35266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35267 }
35268 return resultobj;
35269 fail:
35270 return NULL;
35271 }
35272
35273
35274 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35275 PyObject *resultobj = 0;
35276 wxWindow *arg1 = (wxWindow *) 0 ;
35277 wxBackgroundStyle arg2 ;
35278 bool result;
35279 void *argp1 = 0 ;
35280 int res1 = 0 ;
35281 int val2 ;
35282 int ecode2 = 0 ;
35283 PyObject * obj0 = 0 ;
35284 PyObject * obj1 = 0 ;
35285 char * kwnames[] = {
35286 (char *) "self",(char *) "style", NULL
35287 };
35288
35289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35291 if (!SWIG_IsOK(res1)) {
35292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35293 }
35294 arg1 = reinterpret_cast< wxWindow * >(argp1);
35295 ecode2 = SWIG_AsVal_int(obj1, &val2);
35296 if (!SWIG_IsOK(ecode2)) {
35297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35298 }
35299 arg2 = static_cast< wxBackgroundStyle >(val2);
35300 {
35301 PyThreadState* __tstate = wxPyBeginAllowThreads();
35302 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35303 wxPyEndAllowThreads(__tstate);
35304 if (PyErr_Occurred()) SWIG_fail;
35305 }
35306 {
35307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35308 }
35309 return resultobj;
35310 fail:
35311 return NULL;
35312 }
35313
35314
35315 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35316 PyObject *resultobj = 0;
35317 wxWindow *arg1 = (wxWindow *) 0 ;
35318 wxBackgroundStyle result;
35319 void *argp1 = 0 ;
35320 int res1 = 0 ;
35321 PyObject *swig_obj[1] ;
35322
35323 if (!args) SWIG_fail;
35324 swig_obj[0] = args;
35325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35326 if (!SWIG_IsOK(res1)) {
35327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35328 }
35329 arg1 = reinterpret_cast< wxWindow * >(argp1);
35330 {
35331 PyThreadState* __tstate = wxPyBeginAllowThreads();
35332 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 resultobj = SWIG_From_int(static_cast< int >(result));
35337 return resultobj;
35338 fail:
35339 return NULL;
35340 }
35341
35342
35343 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35344 PyObject *resultobj = 0;
35345 wxWindow *arg1 = (wxWindow *) 0 ;
35346 bool result;
35347 void *argp1 = 0 ;
35348 int res1 = 0 ;
35349 PyObject *swig_obj[1] ;
35350
35351 if (!args) SWIG_fail;
35352 swig_obj[0] = args;
35353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35354 if (!SWIG_IsOK(res1)) {
35355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35356 }
35357 arg1 = reinterpret_cast< wxWindow * >(argp1);
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 result = (bool)(arg1)->HasTransparentBackground();
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 {
35365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35366 }
35367 return resultobj;
35368 fail:
35369 return NULL;
35370 }
35371
35372
35373 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35374 PyObject *resultobj = 0;
35375 wxWindow *arg1 = (wxWindow *) 0 ;
35376 wxCursor *arg2 = 0 ;
35377 bool result;
35378 void *argp1 = 0 ;
35379 int res1 = 0 ;
35380 void *argp2 = 0 ;
35381 int res2 = 0 ;
35382 PyObject * obj0 = 0 ;
35383 PyObject * obj1 = 0 ;
35384 char * kwnames[] = {
35385 (char *) "self",(char *) "cursor", NULL
35386 };
35387
35388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35390 if (!SWIG_IsOK(res1)) {
35391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35392 }
35393 arg1 = reinterpret_cast< wxWindow * >(argp1);
35394 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35395 if (!SWIG_IsOK(res2)) {
35396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35397 }
35398 if (!argp2) {
35399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35400 }
35401 arg2 = reinterpret_cast< wxCursor * >(argp2);
35402 {
35403 PyThreadState* __tstate = wxPyBeginAllowThreads();
35404 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35405 wxPyEndAllowThreads(__tstate);
35406 if (PyErr_Occurred()) SWIG_fail;
35407 }
35408 {
35409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35410 }
35411 return resultobj;
35412 fail:
35413 return NULL;
35414 }
35415
35416
35417 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35418 PyObject *resultobj = 0;
35419 wxWindow *arg1 = (wxWindow *) 0 ;
35420 wxCursor result;
35421 void *argp1 = 0 ;
35422 int res1 = 0 ;
35423 PyObject *swig_obj[1] ;
35424
35425 if (!args) SWIG_fail;
35426 swig_obj[0] = args;
35427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35428 if (!SWIG_IsOK(res1)) {
35429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35430 }
35431 arg1 = reinterpret_cast< wxWindow * >(argp1);
35432 {
35433 PyThreadState* __tstate = wxPyBeginAllowThreads();
35434 result = (arg1)->GetCursor();
35435 wxPyEndAllowThreads(__tstate);
35436 if (PyErr_Occurred()) SWIG_fail;
35437 }
35438 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35439 return resultobj;
35440 fail:
35441 return NULL;
35442 }
35443
35444
35445 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35446 PyObject *resultobj = 0;
35447 wxWindow *arg1 = (wxWindow *) 0 ;
35448 wxFont *arg2 = 0 ;
35449 bool result;
35450 void *argp1 = 0 ;
35451 int res1 = 0 ;
35452 void *argp2 = 0 ;
35453 int res2 = 0 ;
35454 PyObject * obj0 = 0 ;
35455 PyObject * obj1 = 0 ;
35456 char * kwnames[] = {
35457 (char *) "self",(char *) "font", NULL
35458 };
35459
35460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35462 if (!SWIG_IsOK(res1)) {
35463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35464 }
35465 arg1 = reinterpret_cast< wxWindow * >(argp1);
35466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35467 if (!SWIG_IsOK(res2)) {
35468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35469 }
35470 if (!argp2) {
35471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35472 }
35473 arg2 = reinterpret_cast< wxFont * >(argp2);
35474 {
35475 PyThreadState* __tstate = wxPyBeginAllowThreads();
35476 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35477 wxPyEndAllowThreads(__tstate);
35478 if (PyErr_Occurred()) SWIG_fail;
35479 }
35480 {
35481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35482 }
35483 return resultobj;
35484 fail:
35485 return NULL;
35486 }
35487
35488
35489 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35490 PyObject *resultobj = 0;
35491 wxWindow *arg1 = (wxWindow *) 0 ;
35492 wxFont *arg2 = 0 ;
35493 void *argp1 = 0 ;
35494 int res1 = 0 ;
35495 void *argp2 = 0 ;
35496 int res2 = 0 ;
35497 PyObject * obj0 = 0 ;
35498 PyObject * obj1 = 0 ;
35499 char * kwnames[] = {
35500 (char *) "self",(char *) "font", NULL
35501 };
35502
35503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35505 if (!SWIG_IsOK(res1)) {
35506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35507 }
35508 arg1 = reinterpret_cast< wxWindow * >(argp1);
35509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35510 if (!SWIG_IsOK(res2)) {
35511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35512 }
35513 if (!argp2) {
35514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35515 }
35516 arg2 = reinterpret_cast< wxFont * >(argp2);
35517 {
35518 PyThreadState* __tstate = wxPyBeginAllowThreads();
35519 (arg1)->SetOwnFont((wxFont const &)*arg2);
35520 wxPyEndAllowThreads(__tstate);
35521 if (PyErr_Occurred()) SWIG_fail;
35522 }
35523 resultobj = SWIG_Py_Void();
35524 return resultobj;
35525 fail:
35526 return NULL;
35527 }
35528
35529
35530 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35531 PyObject *resultobj = 0;
35532 wxWindow *arg1 = (wxWindow *) 0 ;
35533 wxFont result;
35534 void *argp1 = 0 ;
35535 int res1 = 0 ;
35536 PyObject *swig_obj[1] ;
35537
35538 if (!args) SWIG_fail;
35539 swig_obj[0] = args;
35540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35541 if (!SWIG_IsOK(res1)) {
35542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35543 }
35544 arg1 = reinterpret_cast< wxWindow * >(argp1);
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 result = (arg1)->GetFont();
35548 wxPyEndAllowThreads(__tstate);
35549 if (PyErr_Occurred()) SWIG_fail;
35550 }
35551 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35552 return resultobj;
35553 fail:
35554 return NULL;
35555 }
35556
35557
35558 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35559 PyObject *resultobj = 0;
35560 wxWindow *arg1 = (wxWindow *) 0 ;
35561 wxCaret *arg2 = (wxCaret *) 0 ;
35562 void *argp1 = 0 ;
35563 int res1 = 0 ;
35564 int res2 = 0 ;
35565 PyObject * obj0 = 0 ;
35566 PyObject * obj1 = 0 ;
35567 char * kwnames[] = {
35568 (char *) "self",(char *) "caret", NULL
35569 };
35570
35571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35573 if (!SWIG_IsOK(res1)) {
35574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35575 }
35576 arg1 = reinterpret_cast< wxWindow * >(argp1);
35577 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35578 if (!SWIG_IsOK(res2)) {
35579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35580 }
35581 {
35582 PyThreadState* __tstate = wxPyBeginAllowThreads();
35583 (arg1)->SetCaret(arg2);
35584 wxPyEndAllowThreads(__tstate);
35585 if (PyErr_Occurred()) SWIG_fail;
35586 }
35587 resultobj = SWIG_Py_Void();
35588 return resultobj;
35589 fail:
35590 return NULL;
35591 }
35592
35593
35594 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35595 PyObject *resultobj = 0;
35596 wxWindow *arg1 = (wxWindow *) 0 ;
35597 wxCaret *result = 0 ;
35598 void *argp1 = 0 ;
35599 int res1 = 0 ;
35600 PyObject *swig_obj[1] ;
35601
35602 if (!args) SWIG_fail;
35603 swig_obj[0] = args;
35604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35605 if (!SWIG_IsOK(res1)) {
35606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35607 }
35608 arg1 = reinterpret_cast< wxWindow * >(argp1);
35609 {
35610 PyThreadState* __tstate = wxPyBeginAllowThreads();
35611 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35612 wxPyEndAllowThreads(__tstate);
35613 if (PyErr_Occurred()) SWIG_fail;
35614 }
35615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35616 return resultobj;
35617 fail:
35618 return NULL;
35619 }
35620
35621
35622 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35623 PyObject *resultobj = 0;
35624 wxWindow *arg1 = (wxWindow *) 0 ;
35625 int result;
35626 void *argp1 = 0 ;
35627 int res1 = 0 ;
35628 PyObject *swig_obj[1] ;
35629
35630 if (!args) SWIG_fail;
35631 swig_obj[0] = args;
35632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35633 if (!SWIG_IsOK(res1)) {
35634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35635 }
35636 arg1 = reinterpret_cast< wxWindow * >(argp1);
35637 {
35638 PyThreadState* __tstate = wxPyBeginAllowThreads();
35639 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35640 wxPyEndAllowThreads(__tstate);
35641 if (PyErr_Occurred()) SWIG_fail;
35642 }
35643 resultobj = SWIG_From_int(static_cast< int >(result));
35644 return resultobj;
35645 fail:
35646 return NULL;
35647 }
35648
35649
35650 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35651 PyObject *resultobj = 0;
35652 wxWindow *arg1 = (wxWindow *) 0 ;
35653 int result;
35654 void *argp1 = 0 ;
35655 int res1 = 0 ;
35656 PyObject *swig_obj[1] ;
35657
35658 if (!args) SWIG_fail;
35659 swig_obj[0] = args;
35660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35661 if (!SWIG_IsOK(res1)) {
35662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35663 }
35664 arg1 = reinterpret_cast< wxWindow * >(argp1);
35665 {
35666 PyThreadState* __tstate = wxPyBeginAllowThreads();
35667 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35668 wxPyEndAllowThreads(__tstate);
35669 if (PyErr_Occurred()) SWIG_fail;
35670 }
35671 resultobj = SWIG_From_int(static_cast< int >(result));
35672 return resultobj;
35673 fail:
35674 return NULL;
35675 }
35676
35677
35678 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35679 PyObject *resultobj = 0;
35680 wxWindow *arg1 = (wxWindow *) 0 ;
35681 wxString *arg2 = 0 ;
35682 int *arg3 = (int *) 0 ;
35683 int *arg4 = (int *) 0 ;
35684 void *argp1 = 0 ;
35685 int res1 = 0 ;
35686 bool temp2 = false ;
35687 int temp3 ;
35688 int res3 = SWIG_TMPOBJ ;
35689 int temp4 ;
35690 int res4 = SWIG_TMPOBJ ;
35691 PyObject * obj0 = 0 ;
35692 PyObject * obj1 = 0 ;
35693 char * kwnames[] = {
35694 (char *) "self",(char *) "string", NULL
35695 };
35696
35697 arg3 = &temp3;
35698 arg4 = &temp4;
35699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35701 if (!SWIG_IsOK(res1)) {
35702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35703 }
35704 arg1 = reinterpret_cast< wxWindow * >(argp1);
35705 {
35706 arg2 = wxString_in_helper(obj1);
35707 if (arg2 == NULL) SWIG_fail;
35708 temp2 = true;
35709 }
35710 {
35711 PyThreadState* __tstate = wxPyBeginAllowThreads();
35712 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35713 wxPyEndAllowThreads(__tstate);
35714 if (PyErr_Occurred()) SWIG_fail;
35715 }
35716 resultobj = SWIG_Py_Void();
35717 if (SWIG_IsTmpObj(res3)) {
35718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35719 } else {
35720 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35722 }
35723 if (SWIG_IsTmpObj(res4)) {
35724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35725 } else {
35726 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35728 }
35729 {
35730 if (temp2)
35731 delete arg2;
35732 }
35733 return resultobj;
35734 fail:
35735 {
35736 if (temp2)
35737 delete arg2;
35738 }
35739 return NULL;
35740 }
35741
35742
35743 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35744 PyObject *resultobj = 0;
35745 wxWindow *arg1 = (wxWindow *) 0 ;
35746 wxString *arg2 = 0 ;
35747 int *arg3 = (int *) 0 ;
35748 int *arg4 = (int *) 0 ;
35749 int *arg5 = (int *) 0 ;
35750 int *arg6 = (int *) 0 ;
35751 wxFont *arg7 = (wxFont *) NULL ;
35752 void *argp1 = 0 ;
35753 int res1 = 0 ;
35754 bool temp2 = false ;
35755 int temp3 ;
35756 int res3 = SWIG_TMPOBJ ;
35757 int temp4 ;
35758 int res4 = SWIG_TMPOBJ ;
35759 int temp5 ;
35760 int res5 = SWIG_TMPOBJ ;
35761 int temp6 ;
35762 int res6 = SWIG_TMPOBJ ;
35763 void *argp7 = 0 ;
35764 int res7 = 0 ;
35765 PyObject * obj0 = 0 ;
35766 PyObject * obj1 = 0 ;
35767 PyObject * obj2 = 0 ;
35768 char * kwnames[] = {
35769 (char *) "self",(char *) "string",(char *) "font", NULL
35770 };
35771
35772 arg3 = &temp3;
35773 arg4 = &temp4;
35774 arg5 = &temp5;
35775 arg6 = &temp6;
35776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35778 if (!SWIG_IsOK(res1)) {
35779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35780 }
35781 arg1 = reinterpret_cast< wxWindow * >(argp1);
35782 {
35783 arg2 = wxString_in_helper(obj1);
35784 if (arg2 == NULL) SWIG_fail;
35785 temp2 = true;
35786 }
35787 if (obj2) {
35788 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35789 if (!SWIG_IsOK(res7)) {
35790 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35791 }
35792 arg7 = reinterpret_cast< wxFont * >(argp7);
35793 }
35794 {
35795 PyThreadState* __tstate = wxPyBeginAllowThreads();
35796 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35797 wxPyEndAllowThreads(__tstate);
35798 if (PyErr_Occurred()) SWIG_fail;
35799 }
35800 resultobj = SWIG_Py_Void();
35801 if (SWIG_IsTmpObj(res3)) {
35802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35803 } else {
35804 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35806 }
35807 if (SWIG_IsTmpObj(res4)) {
35808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35809 } else {
35810 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35812 }
35813 if (SWIG_IsTmpObj(res5)) {
35814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35815 } else {
35816 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35818 }
35819 if (SWIG_IsTmpObj(res6)) {
35820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35821 } else {
35822 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35824 }
35825 {
35826 if (temp2)
35827 delete arg2;
35828 }
35829 return resultobj;
35830 fail:
35831 {
35832 if (temp2)
35833 delete arg2;
35834 }
35835 return NULL;
35836 }
35837
35838
35839 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35840 PyObject *resultobj = 0;
35841 wxWindow *arg1 = (wxWindow *) 0 ;
35842 int *arg2 = (int *) 0 ;
35843 int *arg3 = (int *) 0 ;
35844 void *argp1 = 0 ;
35845 int res1 = 0 ;
35846 int temp2 ;
35847 int res2 = 0 ;
35848 int temp3 ;
35849 int res3 = 0 ;
35850 PyObject * obj0 = 0 ;
35851 PyObject * obj1 = 0 ;
35852 PyObject * obj2 = 0 ;
35853 char * kwnames[] = {
35854 (char *) "self",(char *) "x",(char *) "y", NULL
35855 };
35856
35857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35859 if (!SWIG_IsOK(res1)) {
35860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35861 }
35862 arg1 = reinterpret_cast< wxWindow * >(argp1);
35863 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35864 int val;
35865 int ecode = SWIG_AsVal_int(obj1, &val);
35866 if (!SWIG_IsOK(ecode)) {
35867 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35868 }
35869 temp2 = static_cast< int >(val);
35870 arg2 = &temp2;
35871 res2 = SWIG_AddTmpMask(ecode);
35872 }
35873 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35874 int val;
35875 int ecode = SWIG_AsVal_int(obj2, &val);
35876 if (!SWIG_IsOK(ecode)) {
35877 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35878 }
35879 temp3 = static_cast< int >(val);
35880 arg3 = &temp3;
35881 res3 = SWIG_AddTmpMask(ecode);
35882 }
35883 {
35884 PyThreadState* __tstate = wxPyBeginAllowThreads();
35885 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35886 wxPyEndAllowThreads(__tstate);
35887 if (PyErr_Occurred()) SWIG_fail;
35888 }
35889 resultobj = SWIG_Py_Void();
35890 if (SWIG_IsTmpObj(res2)) {
35891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35892 } else {
35893 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35895 }
35896 if (SWIG_IsTmpObj(res3)) {
35897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35898 } else {
35899 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35901 }
35902 return resultobj;
35903 fail:
35904 return NULL;
35905 }
35906
35907
35908 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35909 PyObject *resultobj = 0;
35910 wxWindow *arg1 = (wxWindow *) 0 ;
35911 int *arg2 = (int *) 0 ;
35912 int *arg3 = (int *) 0 ;
35913 void *argp1 = 0 ;
35914 int res1 = 0 ;
35915 int temp2 ;
35916 int res2 = 0 ;
35917 int temp3 ;
35918 int res3 = 0 ;
35919 PyObject * obj0 = 0 ;
35920 PyObject * obj1 = 0 ;
35921 PyObject * obj2 = 0 ;
35922 char * kwnames[] = {
35923 (char *) "self",(char *) "x",(char *) "y", NULL
35924 };
35925
35926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35928 if (!SWIG_IsOK(res1)) {
35929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35930 }
35931 arg1 = reinterpret_cast< wxWindow * >(argp1);
35932 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35933 int val;
35934 int ecode = SWIG_AsVal_int(obj1, &val);
35935 if (!SWIG_IsOK(ecode)) {
35936 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35937 }
35938 temp2 = static_cast< int >(val);
35939 arg2 = &temp2;
35940 res2 = SWIG_AddTmpMask(ecode);
35941 }
35942 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35943 int val;
35944 int ecode = SWIG_AsVal_int(obj2, &val);
35945 if (!SWIG_IsOK(ecode)) {
35946 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35947 }
35948 temp3 = static_cast< int >(val);
35949 arg3 = &temp3;
35950 res3 = SWIG_AddTmpMask(ecode);
35951 }
35952 {
35953 PyThreadState* __tstate = wxPyBeginAllowThreads();
35954 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35955 wxPyEndAllowThreads(__tstate);
35956 if (PyErr_Occurred()) SWIG_fail;
35957 }
35958 resultobj = SWIG_Py_Void();
35959 if (SWIG_IsTmpObj(res2)) {
35960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35961 } else {
35962 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35964 }
35965 if (SWIG_IsTmpObj(res3)) {
35966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35967 } else {
35968 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35970 }
35971 return resultobj;
35972 fail:
35973 return NULL;
35974 }
35975
35976
35977 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35978 PyObject *resultobj = 0;
35979 wxWindow *arg1 = (wxWindow *) 0 ;
35980 wxPoint *arg2 = 0 ;
35981 wxPoint result;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 wxPoint temp2 ;
35985 PyObject * obj0 = 0 ;
35986 PyObject * obj1 = 0 ;
35987 char * kwnames[] = {
35988 (char *) "self",(char *) "pt", NULL
35989 };
35990
35991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35993 if (!SWIG_IsOK(res1)) {
35994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35995 }
35996 arg1 = reinterpret_cast< wxWindow * >(argp1);
35997 {
35998 arg2 = &temp2;
35999 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36000 }
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36004 wxPyEndAllowThreads(__tstate);
36005 if (PyErr_Occurred()) SWIG_fail;
36006 }
36007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36008 return resultobj;
36009 fail:
36010 return NULL;
36011 }
36012
36013
36014 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36015 PyObject *resultobj = 0;
36016 wxWindow *arg1 = (wxWindow *) 0 ;
36017 wxPoint *arg2 = 0 ;
36018 wxPoint result;
36019 void *argp1 = 0 ;
36020 int res1 = 0 ;
36021 wxPoint temp2 ;
36022 PyObject * obj0 = 0 ;
36023 PyObject * obj1 = 0 ;
36024 char * kwnames[] = {
36025 (char *) "self",(char *) "pt", NULL
36026 };
36027
36028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36030 if (!SWIG_IsOK(res1)) {
36031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36032 }
36033 arg1 = reinterpret_cast< wxWindow * >(argp1);
36034 {
36035 arg2 = &temp2;
36036 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36037 }
36038 {
36039 PyThreadState* __tstate = wxPyBeginAllowThreads();
36040 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36041 wxPyEndAllowThreads(__tstate);
36042 if (PyErr_Occurred()) SWIG_fail;
36043 }
36044 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36045 return resultobj;
36046 fail:
36047 return NULL;
36048 }
36049
36050
36051 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36052 PyObject *resultobj = 0;
36053 wxWindow *arg1 = (wxWindow *) 0 ;
36054 int arg2 ;
36055 int arg3 ;
36056 wxHitTest result;
36057 void *argp1 = 0 ;
36058 int res1 = 0 ;
36059 int val2 ;
36060 int ecode2 = 0 ;
36061 int val3 ;
36062 int ecode3 = 0 ;
36063 PyObject * obj0 = 0 ;
36064 PyObject * obj1 = 0 ;
36065 PyObject * obj2 = 0 ;
36066 char * kwnames[] = {
36067 (char *) "self",(char *) "x",(char *) "y", NULL
36068 };
36069
36070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36072 if (!SWIG_IsOK(res1)) {
36073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36074 }
36075 arg1 = reinterpret_cast< wxWindow * >(argp1);
36076 ecode2 = SWIG_AsVal_int(obj1, &val2);
36077 if (!SWIG_IsOK(ecode2)) {
36078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36079 }
36080 arg2 = static_cast< int >(val2);
36081 ecode3 = SWIG_AsVal_int(obj2, &val3);
36082 if (!SWIG_IsOK(ecode3)) {
36083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36084 }
36085 arg3 = static_cast< int >(val3);
36086 {
36087 PyThreadState* __tstate = wxPyBeginAllowThreads();
36088 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36089 wxPyEndAllowThreads(__tstate);
36090 if (PyErr_Occurred()) SWIG_fail;
36091 }
36092 resultobj = SWIG_From_int(static_cast< int >(result));
36093 return resultobj;
36094 fail:
36095 return NULL;
36096 }
36097
36098
36099 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36100 PyObject *resultobj = 0;
36101 wxWindow *arg1 = (wxWindow *) 0 ;
36102 wxPoint *arg2 = 0 ;
36103 wxHitTest result;
36104 void *argp1 = 0 ;
36105 int res1 = 0 ;
36106 wxPoint temp2 ;
36107 PyObject * obj0 = 0 ;
36108 PyObject * obj1 = 0 ;
36109 char * kwnames[] = {
36110 (char *) "self",(char *) "pt", NULL
36111 };
36112
36113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36115 if (!SWIG_IsOK(res1)) {
36116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36117 }
36118 arg1 = reinterpret_cast< wxWindow * >(argp1);
36119 {
36120 arg2 = &temp2;
36121 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36122 }
36123 {
36124 PyThreadState* __tstate = wxPyBeginAllowThreads();
36125 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36126 wxPyEndAllowThreads(__tstate);
36127 if (PyErr_Occurred()) SWIG_fail;
36128 }
36129 resultobj = SWIG_From_int(static_cast< int >(result));
36130 return resultobj;
36131 fail:
36132 return NULL;
36133 }
36134
36135
36136 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36137 PyObject *resultobj = 0;
36138 wxWindow *arg1 = (wxWindow *) 0 ;
36139 long arg2 ;
36140 wxBorder result;
36141 void *argp1 = 0 ;
36142 int res1 = 0 ;
36143 long val2 ;
36144 int ecode2 = 0 ;
36145
36146 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36148 if (!SWIG_IsOK(res1)) {
36149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36150 }
36151 arg1 = reinterpret_cast< wxWindow * >(argp1);
36152 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36153 if (!SWIG_IsOK(ecode2)) {
36154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36155 }
36156 arg2 = static_cast< long >(val2);
36157 {
36158 PyThreadState* __tstate = wxPyBeginAllowThreads();
36159 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36160 wxPyEndAllowThreads(__tstate);
36161 if (PyErr_Occurred()) SWIG_fail;
36162 }
36163 resultobj = SWIG_From_int(static_cast< int >(result));
36164 return resultobj;
36165 fail:
36166 return NULL;
36167 }
36168
36169
36170 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36171 PyObject *resultobj = 0;
36172 wxWindow *arg1 = (wxWindow *) 0 ;
36173 wxBorder result;
36174 void *argp1 = 0 ;
36175 int res1 = 0 ;
36176
36177 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36179 if (!SWIG_IsOK(res1)) {
36180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36181 }
36182 arg1 = reinterpret_cast< wxWindow * >(argp1);
36183 {
36184 PyThreadState* __tstate = wxPyBeginAllowThreads();
36185 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36186 wxPyEndAllowThreads(__tstate);
36187 if (PyErr_Occurred()) SWIG_fail;
36188 }
36189 resultobj = SWIG_From_int(static_cast< int >(result));
36190 return resultobj;
36191 fail:
36192 return NULL;
36193 }
36194
36195
36196 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36197 int argc;
36198 PyObject *argv[3];
36199
36200 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36201 --argc;
36202 if (argc == 1) {
36203 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36204 }
36205 if (argc == 2) {
36206 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36207 }
36208
36209 fail:
36210 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36211 return NULL;
36212 }
36213
36214
36215 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36216 PyObject *resultobj = 0;
36217 wxWindow *arg1 = (wxWindow *) 0 ;
36218 long arg2 = (long) wxUPDATE_UI_NONE ;
36219 void *argp1 = 0 ;
36220 int res1 = 0 ;
36221 long val2 ;
36222 int ecode2 = 0 ;
36223 PyObject * obj0 = 0 ;
36224 PyObject * obj1 = 0 ;
36225 char * kwnames[] = {
36226 (char *) "self",(char *) "flags", NULL
36227 };
36228
36229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36231 if (!SWIG_IsOK(res1)) {
36232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36233 }
36234 arg1 = reinterpret_cast< wxWindow * >(argp1);
36235 if (obj1) {
36236 ecode2 = SWIG_AsVal_long(obj1, &val2);
36237 if (!SWIG_IsOK(ecode2)) {
36238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36239 }
36240 arg2 = static_cast< long >(val2);
36241 }
36242 {
36243 PyThreadState* __tstate = wxPyBeginAllowThreads();
36244 (arg1)->UpdateWindowUI(arg2);
36245 wxPyEndAllowThreads(__tstate);
36246 if (PyErr_Occurred()) SWIG_fail;
36247 }
36248 resultobj = SWIG_Py_Void();
36249 return resultobj;
36250 fail:
36251 return NULL;
36252 }
36253
36254
36255 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36256 PyObject *resultobj = 0;
36257 wxWindow *arg1 = (wxWindow *) 0 ;
36258 wxMenu *arg2 = (wxMenu *) 0 ;
36259 int arg3 = (int) -1 ;
36260 int arg4 = (int) -1 ;
36261 bool result;
36262 void *argp1 = 0 ;
36263 int res1 = 0 ;
36264 void *argp2 = 0 ;
36265 int res2 = 0 ;
36266 int val3 ;
36267 int ecode3 = 0 ;
36268 int val4 ;
36269 int ecode4 = 0 ;
36270 PyObject * obj0 = 0 ;
36271 PyObject * obj1 = 0 ;
36272 PyObject * obj2 = 0 ;
36273 PyObject * obj3 = 0 ;
36274 char * kwnames[] = {
36275 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36276 };
36277
36278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36280 if (!SWIG_IsOK(res1)) {
36281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36282 }
36283 arg1 = reinterpret_cast< wxWindow * >(argp1);
36284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36285 if (!SWIG_IsOK(res2)) {
36286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36287 }
36288 arg2 = reinterpret_cast< wxMenu * >(argp2);
36289 if (obj2) {
36290 ecode3 = SWIG_AsVal_int(obj2, &val3);
36291 if (!SWIG_IsOK(ecode3)) {
36292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36293 }
36294 arg3 = static_cast< int >(val3);
36295 }
36296 if (obj3) {
36297 ecode4 = SWIG_AsVal_int(obj3, &val4);
36298 if (!SWIG_IsOK(ecode4)) {
36299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36300 }
36301 arg4 = static_cast< int >(val4);
36302 }
36303 {
36304 PyThreadState* __tstate = wxPyBeginAllowThreads();
36305 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36306 wxPyEndAllowThreads(__tstate);
36307 if (PyErr_Occurred()) SWIG_fail;
36308 }
36309 {
36310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36311 }
36312 return resultobj;
36313 fail:
36314 return NULL;
36315 }
36316
36317
36318 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36319 PyObject *resultobj = 0;
36320 wxWindow *arg1 = (wxWindow *) 0 ;
36321 wxMenu *arg2 = (wxMenu *) 0 ;
36322 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36323 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36324 bool result;
36325 void *argp1 = 0 ;
36326 int res1 = 0 ;
36327 void *argp2 = 0 ;
36328 int res2 = 0 ;
36329 wxPoint temp3 ;
36330 PyObject * obj0 = 0 ;
36331 PyObject * obj1 = 0 ;
36332 PyObject * obj2 = 0 ;
36333 char * kwnames[] = {
36334 (char *) "self",(char *) "menu",(char *) "pos", NULL
36335 };
36336
36337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36339 if (!SWIG_IsOK(res1)) {
36340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36341 }
36342 arg1 = reinterpret_cast< wxWindow * >(argp1);
36343 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36344 if (!SWIG_IsOK(res2)) {
36345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36346 }
36347 arg2 = reinterpret_cast< wxMenu * >(argp2);
36348 if (obj2) {
36349 {
36350 arg3 = &temp3;
36351 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36352 }
36353 }
36354 {
36355 PyThreadState* __tstate = wxPyBeginAllowThreads();
36356 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36357 wxPyEndAllowThreads(__tstate);
36358 if (PyErr_Occurred()) SWIG_fail;
36359 }
36360 {
36361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36362 }
36363 return resultobj;
36364 fail:
36365 return NULL;
36366 }
36367
36368
36369 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36370 PyObject *resultobj = 0;
36371 wxWindow *arg1 = (wxWindow *) 0 ;
36372 bool result;
36373 void *argp1 = 0 ;
36374 int res1 = 0 ;
36375 PyObject *swig_obj[1] ;
36376
36377 if (!args) SWIG_fail;
36378 swig_obj[0] = args;
36379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36380 if (!SWIG_IsOK(res1)) {
36381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36382 }
36383 arg1 = reinterpret_cast< wxWindow * >(argp1);
36384 {
36385 PyThreadState* __tstate = wxPyBeginAllowThreads();
36386 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36387 wxPyEndAllowThreads(__tstate);
36388 if (PyErr_Occurred()) SWIG_fail;
36389 }
36390 {
36391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36392 }
36393 return resultobj;
36394 fail:
36395 return NULL;
36396 }
36397
36398
36399 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36400 PyObject *resultobj = 0;
36401 wxWindow *arg1 = (wxWindow *) 0 ;
36402 long result;
36403 void *argp1 = 0 ;
36404 int res1 = 0 ;
36405 PyObject *swig_obj[1] ;
36406
36407 if (!args) SWIG_fail;
36408 swig_obj[0] = args;
36409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36410 if (!SWIG_IsOK(res1)) {
36411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36412 }
36413 arg1 = reinterpret_cast< wxWindow * >(argp1);
36414 {
36415 PyThreadState* __tstate = wxPyBeginAllowThreads();
36416 result = (long)wxWindow_GetHandle(arg1);
36417 wxPyEndAllowThreads(__tstate);
36418 if (PyErr_Occurred()) SWIG_fail;
36419 }
36420 resultobj = SWIG_From_long(static_cast< long >(result));
36421 return resultobj;
36422 fail:
36423 return NULL;
36424 }
36425
36426
36427 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36428 PyObject *resultobj = 0;
36429 wxWindow *arg1 = (wxWindow *) 0 ;
36430 long arg2 ;
36431 void *argp1 = 0 ;
36432 int res1 = 0 ;
36433 long val2 ;
36434 int ecode2 = 0 ;
36435 PyObject * obj0 = 0 ;
36436 PyObject * obj1 = 0 ;
36437 char * kwnames[] = {
36438 (char *) "self",(char *) "handle", NULL
36439 };
36440
36441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36443 if (!SWIG_IsOK(res1)) {
36444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36445 }
36446 arg1 = reinterpret_cast< wxWindow * >(argp1);
36447 ecode2 = SWIG_AsVal_long(obj1, &val2);
36448 if (!SWIG_IsOK(ecode2)) {
36449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36450 }
36451 arg2 = static_cast< long >(val2);
36452 {
36453 PyThreadState* __tstate = wxPyBeginAllowThreads();
36454 wxWindow_AssociateHandle(arg1,arg2);
36455 wxPyEndAllowThreads(__tstate);
36456 if (PyErr_Occurred()) SWIG_fail;
36457 }
36458 resultobj = SWIG_Py_Void();
36459 return resultobj;
36460 fail:
36461 return NULL;
36462 }
36463
36464
36465 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36466 PyObject *resultobj = 0;
36467 wxWindow *arg1 = (wxWindow *) 0 ;
36468 void *argp1 = 0 ;
36469 int res1 = 0 ;
36470 PyObject *swig_obj[1] ;
36471
36472 if (!args) SWIG_fail;
36473 swig_obj[0] = args;
36474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36475 if (!SWIG_IsOK(res1)) {
36476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36477 }
36478 arg1 = reinterpret_cast< wxWindow * >(argp1);
36479 {
36480 PyThreadState* __tstate = wxPyBeginAllowThreads();
36481 (arg1)->DissociateHandle();
36482 wxPyEndAllowThreads(__tstate);
36483 if (PyErr_Occurred()) SWIG_fail;
36484 }
36485 resultobj = SWIG_Py_Void();
36486 return resultobj;
36487 fail:
36488 return NULL;
36489 }
36490
36491
36492 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36493 PyObject *resultobj = 0;
36494 wxWindow *arg1 = (wxWindow *) 0 ;
36495 int arg2 ;
36496 bool result;
36497 void *argp1 = 0 ;
36498 int res1 = 0 ;
36499 int val2 ;
36500 int ecode2 = 0 ;
36501 PyObject * obj0 = 0 ;
36502 PyObject * obj1 = 0 ;
36503 char * kwnames[] = {
36504 (char *) "self",(char *) "orient", NULL
36505 };
36506
36507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36509 if (!SWIG_IsOK(res1)) {
36510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36511 }
36512 arg1 = reinterpret_cast< wxWindow * >(argp1);
36513 ecode2 = SWIG_AsVal_int(obj1, &val2);
36514 if (!SWIG_IsOK(ecode2)) {
36515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36516 }
36517 arg2 = static_cast< int >(val2);
36518 {
36519 PyThreadState* __tstate = wxPyBeginAllowThreads();
36520 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36521 wxPyEndAllowThreads(__tstate);
36522 if (PyErr_Occurred()) SWIG_fail;
36523 }
36524 {
36525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36526 }
36527 return resultobj;
36528 fail:
36529 return NULL;
36530 }
36531
36532
36533 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36534 PyObject *resultobj = 0;
36535 wxWindow *arg1 = (wxWindow *) 0 ;
36536 int arg2 ;
36537 int arg3 ;
36538 int arg4 ;
36539 int arg5 ;
36540 bool arg6 = (bool) true ;
36541 void *argp1 = 0 ;
36542 int res1 = 0 ;
36543 int val2 ;
36544 int ecode2 = 0 ;
36545 int val3 ;
36546 int ecode3 = 0 ;
36547 int val4 ;
36548 int ecode4 = 0 ;
36549 int val5 ;
36550 int ecode5 = 0 ;
36551 bool val6 ;
36552 int ecode6 = 0 ;
36553 PyObject * obj0 = 0 ;
36554 PyObject * obj1 = 0 ;
36555 PyObject * obj2 = 0 ;
36556 PyObject * obj3 = 0 ;
36557 PyObject * obj4 = 0 ;
36558 PyObject * obj5 = 0 ;
36559 char * kwnames[] = {
36560 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36561 };
36562
36563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36565 if (!SWIG_IsOK(res1)) {
36566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36567 }
36568 arg1 = reinterpret_cast< wxWindow * >(argp1);
36569 ecode2 = SWIG_AsVal_int(obj1, &val2);
36570 if (!SWIG_IsOK(ecode2)) {
36571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36572 }
36573 arg2 = static_cast< int >(val2);
36574 ecode3 = SWIG_AsVal_int(obj2, &val3);
36575 if (!SWIG_IsOK(ecode3)) {
36576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36577 }
36578 arg3 = static_cast< int >(val3);
36579 ecode4 = SWIG_AsVal_int(obj3, &val4);
36580 if (!SWIG_IsOK(ecode4)) {
36581 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36582 }
36583 arg4 = static_cast< int >(val4);
36584 ecode5 = SWIG_AsVal_int(obj4, &val5);
36585 if (!SWIG_IsOK(ecode5)) {
36586 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36587 }
36588 arg5 = static_cast< int >(val5);
36589 if (obj5) {
36590 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36591 if (!SWIG_IsOK(ecode6)) {
36592 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36593 }
36594 arg6 = static_cast< bool >(val6);
36595 }
36596 {
36597 PyThreadState* __tstate = wxPyBeginAllowThreads();
36598 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36599 wxPyEndAllowThreads(__tstate);
36600 if (PyErr_Occurred()) SWIG_fail;
36601 }
36602 resultobj = SWIG_Py_Void();
36603 return resultobj;
36604 fail:
36605 return NULL;
36606 }
36607
36608
36609 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36610 PyObject *resultobj = 0;
36611 wxWindow *arg1 = (wxWindow *) 0 ;
36612 int arg2 ;
36613 int arg3 ;
36614 bool arg4 = (bool) true ;
36615 void *argp1 = 0 ;
36616 int res1 = 0 ;
36617 int val2 ;
36618 int ecode2 = 0 ;
36619 int val3 ;
36620 int ecode3 = 0 ;
36621 bool val4 ;
36622 int ecode4 = 0 ;
36623 PyObject * obj0 = 0 ;
36624 PyObject * obj1 = 0 ;
36625 PyObject * obj2 = 0 ;
36626 PyObject * obj3 = 0 ;
36627 char * kwnames[] = {
36628 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36629 };
36630
36631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36633 if (!SWIG_IsOK(res1)) {
36634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36635 }
36636 arg1 = reinterpret_cast< wxWindow * >(argp1);
36637 ecode2 = SWIG_AsVal_int(obj1, &val2);
36638 if (!SWIG_IsOK(ecode2)) {
36639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36640 }
36641 arg2 = static_cast< int >(val2);
36642 ecode3 = SWIG_AsVal_int(obj2, &val3);
36643 if (!SWIG_IsOK(ecode3)) {
36644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36645 }
36646 arg3 = static_cast< int >(val3);
36647 if (obj3) {
36648 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36649 if (!SWIG_IsOK(ecode4)) {
36650 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36651 }
36652 arg4 = static_cast< bool >(val4);
36653 }
36654 {
36655 PyThreadState* __tstate = wxPyBeginAllowThreads();
36656 (arg1)->SetScrollPos(arg2,arg3,arg4);
36657 wxPyEndAllowThreads(__tstate);
36658 if (PyErr_Occurred()) SWIG_fail;
36659 }
36660 resultobj = SWIG_Py_Void();
36661 return resultobj;
36662 fail:
36663 return NULL;
36664 }
36665
36666
36667 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36668 PyObject *resultobj = 0;
36669 wxWindow *arg1 = (wxWindow *) 0 ;
36670 int arg2 ;
36671 int result;
36672 void *argp1 = 0 ;
36673 int res1 = 0 ;
36674 int val2 ;
36675 int ecode2 = 0 ;
36676 PyObject * obj0 = 0 ;
36677 PyObject * obj1 = 0 ;
36678 char * kwnames[] = {
36679 (char *) "self",(char *) "orientation", NULL
36680 };
36681
36682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36684 if (!SWIG_IsOK(res1)) {
36685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36686 }
36687 arg1 = reinterpret_cast< wxWindow * >(argp1);
36688 ecode2 = SWIG_AsVal_int(obj1, &val2);
36689 if (!SWIG_IsOK(ecode2)) {
36690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36691 }
36692 arg2 = static_cast< int >(val2);
36693 {
36694 PyThreadState* __tstate = wxPyBeginAllowThreads();
36695 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36696 wxPyEndAllowThreads(__tstate);
36697 if (PyErr_Occurred()) SWIG_fail;
36698 }
36699 resultobj = SWIG_From_int(static_cast< int >(result));
36700 return resultobj;
36701 fail:
36702 return NULL;
36703 }
36704
36705
36706 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36707 PyObject *resultobj = 0;
36708 wxWindow *arg1 = (wxWindow *) 0 ;
36709 int arg2 ;
36710 int result;
36711 void *argp1 = 0 ;
36712 int res1 = 0 ;
36713 int val2 ;
36714 int ecode2 = 0 ;
36715 PyObject * obj0 = 0 ;
36716 PyObject * obj1 = 0 ;
36717 char * kwnames[] = {
36718 (char *) "self",(char *) "orientation", NULL
36719 };
36720
36721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36723 if (!SWIG_IsOK(res1)) {
36724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36725 }
36726 arg1 = reinterpret_cast< wxWindow * >(argp1);
36727 ecode2 = SWIG_AsVal_int(obj1, &val2);
36728 if (!SWIG_IsOK(ecode2)) {
36729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36730 }
36731 arg2 = static_cast< int >(val2);
36732 {
36733 PyThreadState* __tstate = wxPyBeginAllowThreads();
36734 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36735 wxPyEndAllowThreads(__tstate);
36736 if (PyErr_Occurred()) SWIG_fail;
36737 }
36738 resultobj = SWIG_From_int(static_cast< int >(result));
36739 return resultobj;
36740 fail:
36741 return NULL;
36742 }
36743
36744
36745 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36746 PyObject *resultobj = 0;
36747 wxWindow *arg1 = (wxWindow *) 0 ;
36748 int arg2 ;
36749 int result;
36750 void *argp1 = 0 ;
36751 int res1 = 0 ;
36752 int val2 ;
36753 int ecode2 = 0 ;
36754 PyObject * obj0 = 0 ;
36755 PyObject * obj1 = 0 ;
36756 char * kwnames[] = {
36757 (char *) "self",(char *) "orientation", NULL
36758 };
36759
36760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36762 if (!SWIG_IsOK(res1)) {
36763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36764 }
36765 arg1 = reinterpret_cast< wxWindow * >(argp1);
36766 ecode2 = SWIG_AsVal_int(obj1, &val2);
36767 if (!SWIG_IsOK(ecode2)) {
36768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36769 }
36770 arg2 = static_cast< int >(val2);
36771 {
36772 PyThreadState* __tstate = wxPyBeginAllowThreads();
36773 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 resultobj = SWIG_From_int(static_cast< int >(result));
36778 return resultobj;
36779 fail:
36780 return NULL;
36781 }
36782
36783
36784 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36785 PyObject *resultobj = 0;
36786 wxWindow *arg1 = (wxWindow *) 0 ;
36787 int arg2 ;
36788 int arg3 ;
36789 wxRect *arg4 = (wxRect *) NULL ;
36790 void *argp1 = 0 ;
36791 int res1 = 0 ;
36792 int val2 ;
36793 int ecode2 = 0 ;
36794 int val3 ;
36795 int ecode3 = 0 ;
36796 void *argp4 = 0 ;
36797 int res4 = 0 ;
36798 PyObject * obj0 = 0 ;
36799 PyObject * obj1 = 0 ;
36800 PyObject * obj2 = 0 ;
36801 PyObject * obj3 = 0 ;
36802 char * kwnames[] = {
36803 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36804 };
36805
36806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36808 if (!SWIG_IsOK(res1)) {
36809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36810 }
36811 arg1 = reinterpret_cast< wxWindow * >(argp1);
36812 ecode2 = SWIG_AsVal_int(obj1, &val2);
36813 if (!SWIG_IsOK(ecode2)) {
36814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36815 }
36816 arg2 = static_cast< int >(val2);
36817 ecode3 = SWIG_AsVal_int(obj2, &val3);
36818 if (!SWIG_IsOK(ecode3)) {
36819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36820 }
36821 arg3 = static_cast< int >(val3);
36822 if (obj3) {
36823 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36824 if (!SWIG_IsOK(res4)) {
36825 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36826 }
36827 arg4 = reinterpret_cast< wxRect * >(argp4);
36828 }
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 resultobj = SWIG_Py_Void();
36836 return resultobj;
36837 fail:
36838 return NULL;
36839 }
36840
36841
36842 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36843 PyObject *resultobj = 0;
36844 wxWindow *arg1 = (wxWindow *) 0 ;
36845 int arg2 ;
36846 bool result;
36847 void *argp1 = 0 ;
36848 int res1 = 0 ;
36849 int val2 ;
36850 int ecode2 = 0 ;
36851 PyObject * obj0 = 0 ;
36852 PyObject * obj1 = 0 ;
36853 char * kwnames[] = {
36854 (char *) "self",(char *) "lines", NULL
36855 };
36856
36857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36859 if (!SWIG_IsOK(res1)) {
36860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36861 }
36862 arg1 = reinterpret_cast< wxWindow * >(argp1);
36863 ecode2 = SWIG_AsVal_int(obj1, &val2);
36864 if (!SWIG_IsOK(ecode2)) {
36865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36866 }
36867 arg2 = static_cast< int >(val2);
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 result = (bool)(arg1)->ScrollLines(arg2);
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 {
36875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36876 }
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36884 PyObject *resultobj = 0;
36885 wxWindow *arg1 = (wxWindow *) 0 ;
36886 int arg2 ;
36887 bool result;
36888 void *argp1 = 0 ;
36889 int res1 = 0 ;
36890 int val2 ;
36891 int ecode2 = 0 ;
36892 PyObject * obj0 = 0 ;
36893 PyObject * obj1 = 0 ;
36894 char * kwnames[] = {
36895 (char *) "self",(char *) "pages", NULL
36896 };
36897
36898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36900 if (!SWIG_IsOK(res1)) {
36901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36902 }
36903 arg1 = reinterpret_cast< wxWindow * >(argp1);
36904 ecode2 = SWIG_AsVal_int(obj1, &val2);
36905 if (!SWIG_IsOK(ecode2)) {
36906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36907 }
36908 arg2 = static_cast< int >(val2);
36909 {
36910 PyThreadState* __tstate = wxPyBeginAllowThreads();
36911 result = (bool)(arg1)->ScrollPages(arg2);
36912 wxPyEndAllowThreads(__tstate);
36913 if (PyErr_Occurred()) SWIG_fail;
36914 }
36915 {
36916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36917 }
36918 return resultobj;
36919 fail:
36920 return NULL;
36921 }
36922
36923
36924 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36925 PyObject *resultobj = 0;
36926 wxWindow *arg1 = (wxWindow *) 0 ;
36927 bool result;
36928 void *argp1 = 0 ;
36929 int res1 = 0 ;
36930 PyObject *swig_obj[1] ;
36931
36932 if (!args) SWIG_fail;
36933 swig_obj[0] = args;
36934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36935 if (!SWIG_IsOK(res1)) {
36936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36937 }
36938 arg1 = reinterpret_cast< wxWindow * >(argp1);
36939 {
36940 PyThreadState* __tstate = wxPyBeginAllowThreads();
36941 result = (bool)(arg1)->LineUp();
36942 wxPyEndAllowThreads(__tstate);
36943 if (PyErr_Occurred()) SWIG_fail;
36944 }
36945 {
36946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36947 }
36948 return resultobj;
36949 fail:
36950 return NULL;
36951 }
36952
36953
36954 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36955 PyObject *resultobj = 0;
36956 wxWindow *arg1 = (wxWindow *) 0 ;
36957 bool result;
36958 void *argp1 = 0 ;
36959 int res1 = 0 ;
36960 PyObject *swig_obj[1] ;
36961
36962 if (!args) SWIG_fail;
36963 swig_obj[0] = args;
36964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36965 if (!SWIG_IsOK(res1)) {
36966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36967 }
36968 arg1 = reinterpret_cast< wxWindow * >(argp1);
36969 {
36970 PyThreadState* __tstate = wxPyBeginAllowThreads();
36971 result = (bool)(arg1)->LineDown();
36972 wxPyEndAllowThreads(__tstate);
36973 if (PyErr_Occurred()) SWIG_fail;
36974 }
36975 {
36976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36977 }
36978 return resultobj;
36979 fail:
36980 return NULL;
36981 }
36982
36983
36984 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36985 PyObject *resultobj = 0;
36986 wxWindow *arg1 = (wxWindow *) 0 ;
36987 bool result;
36988 void *argp1 = 0 ;
36989 int res1 = 0 ;
36990 PyObject *swig_obj[1] ;
36991
36992 if (!args) SWIG_fail;
36993 swig_obj[0] = args;
36994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36995 if (!SWIG_IsOK(res1)) {
36996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36997 }
36998 arg1 = reinterpret_cast< wxWindow * >(argp1);
36999 {
37000 PyThreadState* __tstate = wxPyBeginAllowThreads();
37001 result = (bool)(arg1)->PageUp();
37002 wxPyEndAllowThreads(__tstate);
37003 if (PyErr_Occurred()) SWIG_fail;
37004 }
37005 {
37006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37007 }
37008 return resultobj;
37009 fail:
37010 return NULL;
37011 }
37012
37013
37014 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37015 PyObject *resultobj = 0;
37016 wxWindow *arg1 = (wxWindow *) 0 ;
37017 bool result;
37018 void *argp1 = 0 ;
37019 int res1 = 0 ;
37020 PyObject *swig_obj[1] ;
37021
37022 if (!args) SWIG_fail;
37023 swig_obj[0] = args;
37024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37025 if (!SWIG_IsOK(res1)) {
37026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37027 }
37028 arg1 = reinterpret_cast< wxWindow * >(argp1);
37029 {
37030 PyThreadState* __tstate = wxPyBeginAllowThreads();
37031 result = (bool)(arg1)->PageDown();
37032 wxPyEndAllowThreads(__tstate);
37033 if (PyErr_Occurred()) SWIG_fail;
37034 }
37035 {
37036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37037 }
37038 return resultobj;
37039 fail:
37040 return NULL;
37041 }
37042
37043
37044 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37045 PyObject *resultobj = 0;
37046 wxWindow *arg1 = (wxWindow *) 0 ;
37047 wxString *arg2 = 0 ;
37048 void *argp1 = 0 ;
37049 int res1 = 0 ;
37050 bool temp2 = false ;
37051 PyObject * obj0 = 0 ;
37052 PyObject * obj1 = 0 ;
37053 char * kwnames[] = {
37054 (char *) "self",(char *) "text", NULL
37055 };
37056
37057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37059 if (!SWIG_IsOK(res1)) {
37060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37061 }
37062 arg1 = reinterpret_cast< wxWindow * >(argp1);
37063 {
37064 arg2 = wxString_in_helper(obj1);
37065 if (arg2 == NULL) SWIG_fail;
37066 temp2 = true;
37067 }
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 (arg1)->SetHelpText((wxString const &)*arg2);
37071 wxPyEndAllowThreads(__tstate);
37072 if (PyErr_Occurred()) SWIG_fail;
37073 }
37074 resultobj = SWIG_Py_Void();
37075 {
37076 if (temp2)
37077 delete arg2;
37078 }
37079 return resultobj;
37080 fail:
37081 {
37082 if (temp2)
37083 delete arg2;
37084 }
37085 return NULL;
37086 }
37087
37088
37089 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37090 PyObject *resultobj = 0;
37091 wxWindow *arg1 = (wxWindow *) 0 ;
37092 wxString *arg2 = 0 ;
37093 void *argp1 = 0 ;
37094 int res1 = 0 ;
37095 bool temp2 = false ;
37096 PyObject * obj0 = 0 ;
37097 PyObject * obj1 = 0 ;
37098 char * kwnames[] = {
37099 (char *) "self",(char *) "text", NULL
37100 };
37101
37102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37104 if (!SWIG_IsOK(res1)) {
37105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37106 }
37107 arg1 = reinterpret_cast< wxWindow * >(argp1);
37108 {
37109 arg2 = wxString_in_helper(obj1);
37110 if (arg2 == NULL) SWIG_fail;
37111 temp2 = true;
37112 }
37113 {
37114 PyThreadState* __tstate = wxPyBeginAllowThreads();
37115 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37116 wxPyEndAllowThreads(__tstate);
37117 if (PyErr_Occurred()) SWIG_fail;
37118 }
37119 resultobj = SWIG_Py_Void();
37120 {
37121 if (temp2)
37122 delete arg2;
37123 }
37124 return resultobj;
37125 fail:
37126 {
37127 if (temp2)
37128 delete arg2;
37129 }
37130 return NULL;
37131 }
37132
37133
37134 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37135 PyObject *resultobj = 0;
37136 wxWindow *arg1 = (wxWindow *) 0 ;
37137 wxPoint *arg2 = 0 ;
37138 wxHelpEvent::Origin arg3 ;
37139 wxString result;
37140 void *argp1 = 0 ;
37141 int res1 = 0 ;
37142 wxPoint temp2 ;
37143 void *argp3 ;
37144 int res3 = 0 ;
37145 PyObject * obj0 = 0 ;
37146 PyObject * obj1 = 0 ;
37147 PyObject * obj2 = 0 ;
37148 char * kwnames[] = {
37149 (char *) "self",(char *) "pt",(char *) "origin", NULL
37150 };
37151
37152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37154 if (!SWIG_IsOK(res1)) {
37155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37156 }
37157 arg1 = reinterpret_cast< wxWindow * >(argp1);
37158 {
37159 arg2 = &temp2;
37160 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37161 }
37162 {
37163 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37164 if (!SWIG_IsOK(res3)) {
37165 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37166 }
37167 if (!argp3) {
37168 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37169 } else {
37170 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37171 arg3 = *temp;
37172 if (SWIG_IsNewObj(res3)) delete temp;
37173 }
37174 }
37175 {
37176 PyThreadState* __tstate = wxPyBeginAllowThreads();
37177 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37178 wxPyEndAllowThreads(__tstate);
37179 if (PyErr_Occurred()) SWIG_fail;
37180 }
37181 {
37182 #if wxUSE_UNICODE
37183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37184 #else
37185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37186 #endif
37187 }
37188 return resultobj;
37189 fail:
37190 return NULL;
37191 }
37192
37193
37194 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37195 PyObject *resultobj = 0;
37196 wxWindow *arg1 = (wxWindow *) 0 ;
37197 wxString result;
37198 void *argp1 = 0 ;
37199 int res1 = 0 ;
37200 PyObject *swig_obj[1] ;
37201
37202 if (!args) SWIG_fail;
37203 swig_obj[0] = args;
37204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37205 if (!SWIG_IsOK(res1)) {
37206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37207 }
37208 arg1 = reinterpret_cast< wxWindow * >(argp1);
37209 {
37210 PyThreadState* __tstate = wxPyBeginAllowThreads();
37211 result = ((wxWindow const *)arg1)->GetHelpText();
37212 wxPyEndAllowThreads(__tstate);
37213 if (PyErr_Occurred()) SWIG_fail;
37214 }
37215 {
37216 #if wxUSE_UNICODE
37217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37218 #else
37219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37220 #endif
37221 }
37222 return resultobj;
37223 fail:
37224 return NULL;
37225 }
37226
37227
37228 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37229 PyObject *resultobj = 0;
37230 wxWindow *arg1 = (wxWindow *) 0 ;
37231 wxString *arg2 = 0 ;
37232 void *argp1 = 0 ;
37233 int res1 = 0 ;
37234 bool temp2 = false ;
37235 PyObject * obj0 = 0 ;
37236 PyObject * obj1 = 0 ;
37237 char * kwnames[] = {
37238 (char *) "self",(char *) "tip", NULL
37239 };
37240
37241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37243 if (!SWIG_IsOK(res1)) {
37244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37245 }
37246 arg1 = reinterpret_cast< wxWindow * >(argp1);
37247 {
37248 arg2 = wxString_in_helper(obj1);
37249 if (arg2 == NULL) SWIG_fail;
37250 temp2 = true;
37251 }
37252 {
37253 PyThreadState* __tstate = wxPyBeginAllowThreads();
37254 (arg1)->SetToolTip((wxString const &)*arg2);
37255 wxPyEndAllowThreads(__tstate);
37256 if (PyErr_Occurred()) SWIG_fail;
37257 }
37258 resultobj = SWIG_Py_Void();
37259 {
37260 if (temp2)
37261 delete arg2;
37262 }
37263 return resultobj;
37264 fail:
37265 {
37266 if (temp2)
37267 delete arg2;
37268 }
37269 return NULL;
37270 }
37271
37272
37273 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37274 PyObject *resultobj = 0;
37275 wxWindow *arg1 = (wxWindow *) 0 ;
37276 wxToolTip *arg2 = (wxToolTip *) 0 ;
37277 void *argp1 = 0 ;
37278 int res1 = 0 ;
37279 int res2 = 0 ;
37280 PyObject * obj0 = 0 ;
37281 PyObject * obj1 = 0 ;
37282 char * kwnames[] = {
37283 (char *) "self",(char *) "tip", NULL
37284 };
37285
37286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37288 if (!SWIG_IsOK(res1)) {
37289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37290 }
37291 arg1 = reinterpret_cast< wxWindow * >(argp1);
37292 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37293 if (!SWIG_IsOK(res2)) {
37294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37295 }
37296 {
37297 PyThreadState* __tstate = wxPyBeginAllowThreads();
37298 (arg1)->SetToolTip(arg2);
37299 wxPyEndAllowThreads(__tstate);
37300 if (PyErr_Occurred()) SWIG_fail;
37301 }
37302 resultobj = SWIG_Py_Void();
37303 return resultobj;
37304 fail:
37305 return NULL;
37306 }
37307
37308
37309 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37310 PyObject *resultobj = 0;
37311 wxWindow *arg1 = (wxWindow *) 0 ;
37312 wxToolTip *result = 0 ;
37313 void *argp1 = 0 ;
37314 int res1 = 0 ;
37315 PyObject *swig_obj[1] ;
37316
37317 if (!args) SWIG_fail;
37318 swig_obj[0] = args;
37319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37320 if (!SWIG_IsOK(res1)) {
37321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37322 }
37323 arg1 = reinterpret_cast< wxWindow * >(argp1);
37324 {
37325 PyThreadState* __tstate = wxPyBeginAllowThreads();
37326 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37327 wxPyEndAllowThreads(__tstate);
37328 if (PyErr_Occurred()) SWIG_fail;
37329 }
37330 {
37331 resultobj = wxPyMake_wxObject(result, (bool)0);
37332 }
37333 return resultobj;
37334 fail:
37335 return NULL;
37336 }
37337
37338
37339 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37340 PyObject *resultobj = 0;
37341 wxWindow *arg1 = (wxWindow *) 0 ;
37342 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37343 void *argp1 = 0 ;
37344 int res1 = 0 ;
37345 int res2 = 0 ;
37346 PyObject * obj0 = 0 ;
37347 PyObject * obj1 = 0 ;
37348 char * kwnames[] = {
37349 (char *) "self",(char *) "dropTarget", NULL
37350 };
37351
37352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37354 if (!SWIG_IsOK(res1)) {
37355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37356 }
37357 arg1 = reinterpret_cast< wxWindow * >(argp1);
37358 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37359 if (!SWIG_IsOK(res2)) {
37360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37361 }
37362 {
37363 PyThreadState* __tstate = wxPyBeginAllowThreads();
37364 (arg1)->SetDropTarget(arg2);
37365 wxPyEndAllowThreads(__tstate);
37366 if (PyErr_Occurred()) SWIG_fail;
37367 }
37368 resultobj = SWIG_Py_Void();
37369 return resultobj;
37370 fail:
37371 return NULL;
37372 }
37373
37374
37375 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37376 PyObject *resultobj = 0;
37377 wxWindow *arg1 = (wxWindow *) 0 ;
37378 wxPyDropTarget *result = 0 ;
37379 void *argp1 = 0 ;
37380 int res1 = 0 ;
37381 PyObject *swig_obj[1] ;
37382
37383 if (!args) SWIG_fail;
37384 swig_obj[0] = args;
37385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37386 if (!SWIG_IsOK(res1)) {
37387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37388 }
37389 arg1 = reinterpret_cast< wxWindow * >(argp1);
37390 {
37391 PyThreadState* __tstate = wxPyBeginAllowThreads();
37392 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37393 wxPyEndAllowThreads(__tstate);
37394 if (PyErr_Occurred()) SWIG_fail;
37395 }
37396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37397 return resultobj;
37398 fail:
37399 return NULL;
37400 }
37401
37402
37403 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37404 PyObject *resultobj = 0;
37405 wxWindow *arg1 = (wxWindow *) 0 ;
37406 bool arg2 ;
37407 void *argp1 = 0 ;
37408 int res1 = 0 ;
37409 bool val2 ;
37410 int ecode2 = 0 ;
37411 PyObject * obj0 = 0 ;
37412 PyObject * obj1 = 0 ;
37413 char * kwnames[] = {
37414 (char *) "self",(char *) "accept", NULL
37415 };
37416
37417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37419 if (!SWIG_IsOK(res1)) {
37420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37421 }
37422 arg1 = reinterpret_cast< wxWindow * >(argp1);
37423 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37424 if (!SWIG_IsOK(ecode2)) {
37425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37426 }
37427 arg2 = static_cast< bool >(val2);
37428 {
37429 PyThreadState* __tstate = wxPyBeginAllowThreads();
37430 wxWindow_DragAcceptFiles(arg1,arg2);
37431 wxPyEndAllowThreads(__tstate);
37432 if (PyErr_Occurred()) SWIG_fail;
37433 }
37434 resultobj = SWIG_Py_Void();
37435 return resultobj;
37436 fail:
37437 return NULL;
37438 }
37439
37440
37441 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37442 PyObject *resultobj = 0;
37443 wxWindow *arg1 = (wxWindow *) 0 ;
37444 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37445 void *argp1 = 0 ;
37446 int res1 = 0 ;
37447 int res2 = 0 ;
37448 PyObject * obj0 = 0 ;
37449 PyObject * obj1 = 0 ;
37450 char * kwnames[] = {
37451 (char *) "self",(char *) "constraints", NULL
37452 };
37453
37454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37456 if (!SWIG_IsOK(res1)) {
37457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37458 }
37459 arg1 = reinterpret_cast< wxWindow * >(argp1);
37460 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37461 if (!SWIG_IsOK(res2)) {
37462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37463 }
37464 {
37465 PyThreadState* __tstate = wxPyBeginAllowThreads();
37466 (arg1)->SetConstraints(arg2);
37467 wxPyEndAllowThreads(__tstate);
37468 if (PyErr_Occurred()) SWIG_fail;
37469 }
37470 resultobj = SWIG_Py_Void();
37471 return resultobj;
37472 fail:
37473 return NULL;
37474 }
37475
37476
37477 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37478 PyObject *resultobj = 0;
37479 wxWindow *arg1 = (wxWindow *) 0 ;
37480 wxLayoutConstraints *result = 0 ;
37481 void *argp1 = 0 ;
37482 int res1 = 0 ;
37483 PyObject *swig_obj[1] ;
37484
37485 if (!args) SWIG_fail;
37486 swig_obj[0] = args;
37487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37488 if (!SWIG_IsOK(res1)) {
37489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37490 }
37491 arg1 = reinterpret_cast< wxWindow * >(argp1);
37492 {
37493 PyThreadState* __tstate = wxPyBeginAllowThreads();
37494 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37495 wxPyEndAllowThreads(__tstate);
37496 if (PyErr_Occurred()) SWIG_fail;
37497 }
37498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37499 return resultobj;
37500 fail:
37501 return NULL;
37502 }
37503
37504
37505 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37506 PyObject *resultobj = 0;
37507 wxWindow *arg1 = (wxWindow *) 0 ;
37508 bool arg2 ;
37509 void *argp1 = 0 ;
37510 int res1 = 0 ;
37511 bool val2 ;
37512 int ecode2 = 0 ;
37513 PyObject * obj0 = 0 ;
37514 PyObject * obj1 = 0 ;
37515 char * kwnames[] = {
37516 (char *) "self",(char *) "autoLayout", NULL
37517 };
37518
37519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37521 if (!SWIG_IsOK(res1)) {
37522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37523 }
37524 arg1 = reinterpret_cast< wxWindow * >(argp1);
37525 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37526 if (!SWIG_IsOK(ecode2)) {
37527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37528 }
37529 arg2 = static_cast< bool >(val2);
37530 {
37531 PyThreadState* __tstate = wxPyBeginAllowThreads();
37532 (arg1)->SetAutoLayout(arg2);
37533 wxPyEndAllowThreads(__tstate);
37534 if (PyErr_Occurred()) SWIG_fail;
37535 }
37536 resultobj = SWIG_Py_Void();
37537 return resultobj;
37538 fail:
37539 return NULL;
37540 }
37541
37542
37543 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37544 PyObject *resultobj = 0;
37545 wxWindow *arg1 = (wxWindow *) 0 ;
37546 bool result;
37547 void *argp1 = 0 ;
37548 int res1 = 0 ;
37549 PyObject *swig_obj[1] ;
37550
37551 if (!args) SWIG_fail;
37552 swig_obj[0] = args;
37553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37554 if (!SWIG_IsOK(res1)) {
37555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37556 }
37557 arg1 = reinterpret_cast< wxWindow * >(argp1);
37558 {
37559 PyThreadState* __tstate = wxPyBeginAllowThreads();
37560 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37561 wxPyEndAllowThreads(__tstate);
37562 if (PyErr_Occurred()) SWIG_fail;
37563 }
37564 {
37565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37566 }
37567 return resultobj;
37568 fail:
37569 return NULL;
37570 }
37571
37572
37573 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37574 PyObject *resultobj = 0;
37575 wxWindow *arg1 = (wxWindow *) 0 ;
37576 bool result;
37577 void *argp1 = 0 ;
37578 int res1 = 0 ;
37579 PyObject *swig_obj[1] ;
37580
37581 if (!args) SWIG_fail;
37582 swig_obj[0] = args;
37583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37584 if (!SWIG_IsOK(res1)) {
37585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37586 }
37587 arg1 = reinterpret_cast< wxWindow * >(argp1);
37588 {
37589 PyThreadState* __tstate = wxPyBeginAllowThreads();
37590 result = (bool)(arg1)->Layout();
37591 wxPyEndAllowThreads(__tstate);
37592 if (PyErr_Occurred()) SWIG_fail;
37593 }
37594 {
37595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37596 }
37597 return resultobj;
37598 fail:
37599 return NULL;
37600 }
37601
37602
37603 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37604 PyObject *resultobj = 0;
37605 wxWindow *arg1 = (wxWindow *) 0 ;
37606 wxSizer *arg2 = (wxSizer *) 0 ;
37607 bool arg3 = (bool) true ;
37608 void *argp1 = 0 ;
37609 int res1 = 0 ;
37610 int res2 = 0 ;
37611 bool val3 ;
37612 int ecode3 = 0 ;
37613 PyObject * obj0 = 0 ;
37614 PyObject * obj1 = 0 ;
37615 PyObject * obj2 = 0 ;
37616 char * kwnames[] = {
37617 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37618 };
37619
37620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37622 if (!SWIG_IsOK(res1)) {
37623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37624 }
37625 arg1 = reinterpret_cast< wxWindow * >(argp1);
37626 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37627 if (!SWIG_IsOK(res2)) {
37628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37629 }
37630 if (obj2) {
37631 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37632 if (!SWIG_IsOK(ecode3)) {
37633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37634 }
37635 arg3 = static_cast< bool >(val3);
37636 }
37637 {
37638 PyThreadState* __tstate = wxPyBeginAllowThreads();
37639 (arg1)->SetSizer(arg2,arg3);
37640 wxPyEndAllowThreads(__tstate);
37641 if (PyErr_Occurred()) SWIG_fail;
37642 }
37643 resultobj = SWIG_Py_Void();
37644 return resultobj;
37645 fail:
37646 return NULL;
37647 }
37648
37649
37650 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37651 PyObject *resultobj = 0;
37652 wxWindow *arg1 = (wxWindow *) 0 ;
37653 wxSizer *arg2 = (wxSizer *) 0 ;
37654 bool arg3 = (bool) true ;
37655 void *argp1 = 0 ;
37656 int res1 = 0 ;
37657 int res2 = 0 ;
37658 bool val3 ;
37659 int ecode3 = 0 ;
37660 PyObject * obj0 = 0 ;
37661 PyObject * obj1 = 0 ;
37662 PyObject * obj2 = 0 ;
37663 char * kwnames[] = {
37664 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37665 };
37666
37667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37669 if (!SWIG_IsOK(res1)) {
37670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37671 }
37672 arg1 = reinterpret_cast< wxWindow * >(argp1);
37673 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37674 if (!SWIG_IsOK(res2)) {
37675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37676 }
37677 if (obj2) {
37678 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37679 if (!SWIG_IsOK(ecode3)) {
37680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37681 }
37682 arg3 = static_cast< bool >(val3);
37683 }
37684 {
37685 PyThreadState* __tstate = wxPyBeginAllowThreads();
37686 (arg1)->SetSizerAndFit(arg2,arg3);
37687 wxPyEndAllowThreads(__tstate);
37688 if (PyErr_Occurred()) SWIG_fail;
37689 }
37690 resultobj = SWIG_Py_Void();
37691 return resultobj;
37692 fail:
37693 return NULL;
37694 }
37695
37696
37697 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37698 PyObject *resultobj = 0;
37699 wxWindow *arg1 = (wxWindow *) 0 ;
37700 wxSizer *result = 0 ;
37701 void *argp1 = 0 ;
37702 int res1 = 0 ;
37703 PyObject *swig_obj[1] ;
37704
37705 if (!args) SWIG_fail;
37706 swig_obj[0] = args;
37707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37708 if (!SWIG_IsOK(res1)) {
37709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37710 }
37711 arg1 = reinterpret_cast< wxWindow * >(argp1);
37712 {
37713 PyThreadState* __tstate = wxPyBeginAllowThreads();
37714 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37715 wxPyEndAllowThreads(__tstate);
37716 if (PyErr_Occurred()) SWIG_fail;
37717 }
37718 {
37719 resultobj = wxPyMake_wxObject(result, (bool)0);
37720 }
37721 return resultobj;
37722 fail:
37723 return NULL;
37724 }
37725
37726
37727 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37728 PyObject *resultobj = 0;
37729 wxWindow *arg1 = (wxWindow *) 0 ;
37730 wxSizer *arg2 = (wxSizer *) 0 ;
37731 void *argp1 = 0 ;
37732 int res1 = 0 ;
37733 void *argp2 = 0 ;
37734 int res2 = 0 ;
37735 PyObject * obj0 = 0 ;
37736 PyObject * obj1 = 0 ;
37737 char * kwnames[] = {
37738 (char *) "self",(char *) "sizer", NULL
37739 };
37740
37741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37743 if (!SWIG_IsOK(res1)) {
37744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37745 }
37746 arg1 = reinterpret_cast< wxWindow * >(argp1);
37747 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37748 if (!SWIG_IsOK(res2)) {
37749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37750 }
37751 arg2 = reinterpret_cast< wxSizer * >(argp2);
37752 {
37753 PyThreadState* __tstate = wxPyBeginAllowThreads();
37754 (arg1)->SetContainingSizer(arg2);
37755 wxPyEndAllowThreads(__tstate);
37756 if (PyErr_Occurred()) SWIG_fail;
37757 }
37758 resultobj = SWIG_Py_Void();
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37766 PyObject *resultobj = 0;
37767 wxWindow *arg1 = (wxWindow *) 0 ;
37768 wxSizer *result = 0 ;
37769 void *argp1 = 0 ;
37770 int res1 = 0 ;
37771 PyObject *swig_obj[1] ;
37772
37773 if (!args) SWIG_fail;
37774 swig_obj[0] = args;
37775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37776 if (!SWIG_IsOK(res1)) {
37777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37778 }
37779 arg1 = reinterpret_cast< wxWindow * >(argp1);
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37783 wxPyEndAllowThreads(__tstate);
37784 if (PyErr_Occurred()) SWIG_fail;
37785 }
37786 {
37787 resultobj = wxPyMake_wxObject(result, (bool)0);
37788 }
37789 return resultobj;
37790 fail:
37791 return NULL;
37792 }
37793
37794
37795 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37796 PyObject *resultobj = 0;
37797 wxWindow *arg1 = (wxWindow *) 0 ;
37798 void *argp1 = 0 ;
37799 int res1 = 0 ;
37800 PyObject *swig_obj[1] ;
37801
37802 if (!args) SWIG_fail;
37803 swig_obj[0] = args;
37804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37805 if (!SWIG_IsOK(res1)) {
37806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37807 }
37808 arg1 = reinterpret_cast< wxWindow * >(argp1);
37809 {
37810 PyThreadState* __tstate = wxPyBeginAllowThreads();
37811 (arg1)->InheritAttributes();
37812 wxPyEndAllowThreads(__tstate);
37813 if (PyErr_Occurred()) SWIG_fail;
37814 }
37815 resultobj = SWIG_Py_Void();
37816 return resultobj;
37817 fail:
37818 return NULL;
37819 }
37820
37821
37822 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37823 PyObject *resultobj = 0;
37824 wxWindow *arg1 = (wxWindow *) 0 ;
37825 bool result;
37826 void *argp1 = 0 ;
37827 int res1 = 0 ;
37828 PyObject *swig_obj[1] ;
37829
37830 if (!args) SWIG_fail;
37831 swig_obj[0] = args;
37832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37833 if (!SWIG_IsOK(res1)) {
37834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37835 }
37836 arg1 = reinterpret_cast< wxWindow * >(argp1);
37837 {
37838 PyThreadState* __tstate = wxPyBeginAllowThreads();
37839 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37840 wxPyEndAllowThreads(__tstate);
37841 if (PyErr_Occurred()) SWIG_fail;
37842 }
37843 {
37844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37845 }
37846 return resultobj;
37847 fail:
37848 return NULL;
37849 }
37850
37851
37852 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37853 PyObject *resultobj = 0;
37854 wxWindow *arg1 = (wxWindow *) 0 ;
37855 bool result;
37856 void *argp1 = 0 ;
37857 int res1 = 0 ;
37858 PyObject *swig_obj[1] ;
37859
37860 if (!args) SWIG_fail;
37861 swig_obj[0] = args;
37862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37863 if (!SWIG_IsOK(res1)) {
37864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37865 }
37866 arg1 = reinterpret_cast< wxWindow * >(argp1);
37867 {
37868 PyThreadState* __tstate = wxPyBeginAllowThreads();
37869 result = (bool)(arg1)->CanSetTransparent();
37870 wxPyEndAllowThreads(__tstate);
37871 if (PyErr_Occurred()) SWIG_fail;
37872 }
37873 {
37874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37875 }
37876 return resultobj;
37877 fail:
37878 return NULL;
37879 }
37880
37881
37882 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37883 PyObject *resultobj = 0;
37884 wxWindow *arg1 = (wxWindow *) 0 ;
37885 byte arg2 ;
37886 bool result;
37887 void *argp1 = 0 ;
37888 int res1 = 0 ;
37889 unsigned char val2 ;
37890 int ecode2 = 0 ;
37891 PyObject * obj0 = 0 ;
37892 PyObject * obj1 = 0 ;
37893 char * kwnames[] = {
37894 (char *) "self",(char *) "alpha", NULL
37895 };
37896
37897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
37898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37899 if (!SWIG_IsOK(res1)) {
37900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37901 }
37902 arg1 = reinterpret_cast< wxWindow * >(argp1);
37903 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
37904 if (!SWIG_IsOK(ecode2)) {
37905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
37906 }
37907 arg2 = static_cast< byte >(val2);
37908 {
37909 PyThreadState* __tstate = wxPyBeginAllowThreads();
37910 result = (bool)(arg1)->SetTransparent(arg2);
37911 wxPyEndAllowThreads(__tstate);
37912 if (PyErr_Occurred()) SWIG_fail;
37913 }
37914 {
37915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37916 }
37917 return resultobj;
37918 fail:
37919 return NULL;
37920 }
37921
37922
37923 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37924 PyObject *obj;
37925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37926 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37927 return SWIG_Py_Void();
37928 }
37929
37930 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37931 return SWIG_Python_InitShadowInstance(args);
37932 }
37933
37934 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37935 PyObject *resultobj = 0;
37936 long arg1 ;
37937 wxWindow *arg2 = (wxWindow *) NULL ;
37938 wxWindow *result = 0 ;
37939 long val1 ;
37940 int ecode1 = 0 ;
37941 void *argp2 = 0 ;
37942 int res2 = 0 ;
37943 PyObject * obj0 = 0 ;
37944 PyObject * obj1 = 0 ;
37945 char * kwnames[] = {
37946 (char *) "id",(char *) "parent", NULL
37947 };
37948
37949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37950 ecode1 = SWIG_AsVal_long(obj0, &val1);
37951 if (!SWIG_IsOK(ecode1)) {
37952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37953 }
37954 arg1 = static_cast< long >(val1);
37955 if (obj1) {
37956 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37957 if (!SWIG_IsOK(res2)) {
37958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37959 }
37960 arg2 = reinterpret_cast< wxWindow * >(argp2);
37961 }
37962 {
37963 if (!wxPyCheckForApp()) SWIG_fail;
37964 PyThreadState* __tstate = wxPyBeginAllowThreads();
37965 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37966 wxPyEndAllowThreads(__tstate);
37967 if (PyErr_Occurred()) SWIG_fail;
37968 }
37969 {
37970 resultobj = wxPyMake_wxObject(result, 0);
37971 }
37972 return resultobj;
37973 fail:
37974 return NULL;
37975 }
37976
37977
37978 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37979 PyObject *resultobj = 0;
37980 wxString *arg1 = 0 ;
37981 wxWindow *arg2 = (wxWindow *) NULL ;
37982 wxWindow *result = 0 ;
37983 bool temp1 = false ;
37984 void *argp2 = 0 ;
37985 int res2 = 0 ;
37986 PyObject * obj0 = 0 ;
37987 PyObject * obj1 = 0 ;
37988 char * kwnames[] = {
37989 (char *) "name",(char *) "parent", NULL
37990 };
37991
37992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37993 {
37994 arg1 = wxString_in_helper(obj0);
37995 if (arg1 == NULL) SWIG_fail;
37996 temp1 = true;
37997 }
37998 if (obj1) {
37999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38000 if (!SWIG_IsOK(res2)) {
38001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38002 }
38003 arg2 = reinterpret_cast< wxWindow * >(argp2);
38004 }
38005 {
38006 if (!wxPyCheckForApp()) SWIG_fail;
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38009 wxPyEndAllowThreads(__tstate);
38010 if (PyErr_Occurred()) SWIG_fail;
38011 }
38012 {
38013 resultobj = wxPyMake_wxObject(result, 0);
38014 }
38015 {
38016 if (temp1)
38017 delete arg1;
38018 }
38019 return resultobj;
38020 fail:
38021 {
38022 if (temp1)
38023 delete arg1;
38024 }
38025 return NULL;
38026 }
38027
38028
38029 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38030 PyObject *resultobj = 0;
38031 wxString *arg1 = 0 ;
38032 wxWindow *arg2 = (wxWindow *) NULL ;
38033 wxWindow *result = 0 ;
38034 bool temp1 = false ;
38035 void *argp2 = 0 ;
38036 int res2 = 0 ;
38037 PyObject * obj0 = 0 ;
38038 PyObject * obj1 = 0 ;
38039 char * kwnames[] = {
38040 (char *) "label",(char *) "parent", NULL
38041 };
38042
38043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38044 {
38045 arg1 = wxString_in_helper(obj0);
38046 if (arg1 == NULL) SWIG_fail;
38047 temp1 = true;
38048 }
38049 if (obj1) {
38050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38051 if (!SWIG_IsOK(res2)) {
38052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38053 }
38054 arg2 = reinterpret_cast< wxWindow * >(argp2);
38055 }
38056 {
38057 if (!wxPyCheckForApp()) SWIG_fail;
38058 PyThreadState* __tstate = wxPyBeginAllowThreads();
38059 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 {
38064 resultobj = wxPyMake_wxObject(result, 0);
38065 }
38066 {
38067 if (temp1)
38068 delete arg1;
38069 }
38070 return resultobj;
38071 fail:
38072 {
38073 if (temp1)
38074 delete arg1;
38075 }
38076 return NULL;
38077 }
38078
38079
38080 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38081 PyObject *resultobj = 0;
38082 wxWindow *arg1 = (wxWindow *) 0 ;
38083 unsigned long arg2 ;
38084 wxWindow *result = 0 ;
38085 void *argp1 = 0 ;
38086 int res1 = 0 ;
38087 unsigned long val2 ;
38088 int ecode2 = 0 ;
38089 PyObject * obj0 = 0 ;
38090 PyObject * obj1 = 0 ;
38091 char * kwnames[] = {
38092 (char *) "parent",(char *) "_hWnd", NULL
38093 };
38094
38095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38097 if (!SWIG_IsOK(res1)) {
38098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38099 }
38100 arg1 = reinterpret_cast< wxWindow * >(argp1);
38101 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38102 if (!SWIG_IsOK(ecode2)) {
38103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38104 }
38105 arg2 = static_cast< unsigned long >(val2);
38106 {
38107 PyThreadState* __tstate = wxPyBeginAllowThreads();
38108 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38109 wxPyEndAllowThreads(__tstate);
38110 if (PyErr_Occurred()) SWIG_fail;
38111 }
38112 {
38113 resultobj = wxPyMake_wxObject(result, 0);
38114 }
38115 return resultobj;
38116 fail:
38117 return NULL;
38118 }
38119
38120
38121 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38122 PyObject *resultobj = 0;
38123 PyObject *result = 0 ;
38124
38125 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38126 {
38127 PyThreadState* __tstate = wxPyBeginAllowThreads();
38128 result = (PyObject *)GetTopLevelWindows();
38129 wxPyEndAllowThreads(__tstate);
38130 if (PyErr_Occurred()) SWIG_fail;
38131 }
38132 resultobj = result;
38133 return resultobj;
38134 fail:
38135 return NULL;
38136 }
38137
38138
38139 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38140 PyObject *resultobj = 0;
38141 wxValidator *result = 0 ;
38142
38143 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38144 {
38145 PyThreadState* __tstate = wxPyBeginAllowThreads();
38146 result = (wxValidator *)new wxValidator();
38147 wxPyEndAllowThreads(__tstate);
38148 if (PyErr_Occurred()) SWIG_fail;
38149 }
38150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38151 return resultobj;
38152 fail:
38153 return NULL;
38154 }
38155
38156
38157 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38158 PyObject *resultobj = 0;
38159 wxValidator *arg1 = (wxValidator *) 0 ;
38160 wxValidator *result = 0 ;
38161 void *argp1 = 0 ;
38162 int res1 = 0 ;
38163 PyObject *swig_obj[1] ;
38164
38165 if (!args) SWIG_fail;
38166 swig_obj[0] = args;
38167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38168 if (!SWIG_IsOK(res1)) {
38169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38170 }
38171 arg1 = reinterpret_cast< wxValidator * >(argp1);
38172 {
38173 PyThreadState* __tstate = wxPyBeginAllowThreads();
38174 result = (wxValidator *)(arg1)->Clone();
38175 wxPyEndAllowThreads(__tstate);
38176 if (PyErr_Occurred()) SWIG_fail;
38177 }
38178 {
38179 resultobj = wxPyMake_wxObject(result, 0);
38180 }
38181 return resultobj;
38182 fail:
38183 return NULL;
38184 }
38185
38186
38187 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38188 PyObject *resultobj = 0;
38189 wxValidator *arg1 = (wxValidator *) 0 ;
38190 wxWindow *arg2 = (wxWindow *) 0 ;
38191 bool result;
38192 void *argp1 = 0 ;
38193 int res1 = 0 ;
38194 void *argp2 = 0 ;
38195 int res2 = 0 ;
38196 PyObject * obj0 = 0 ;
38197 PyObject * obj1 = 0 ;
38198 char * kwnames[] = {
38199 (char *) "self",(char *) "parent", NULL
38200 };
38201
38202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38204 if (!SWIG_IsOK(res1)) {
38205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38206 }
38207 arg1 = reinterpret_cast< wxValidator * >(argp1);
38208 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38209 if (!SWIG_IsOK(res2)) {
38210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38211 }
38212 arg2 = reinterpret_cast< wxWindow * >(argp2);
38213 {
38214 PyThreadState* __tstate = wxPyBeginAllowThreads();
38215 result = (bool)(arg1)->Validate(arg2);
38216 wxPyEndAllowThreads(__tstate);
38217 if (PyErr_Occurred()) SWIG_fail;
38218 }
38219 {
38220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38221 }
38222 return resultobj;
38223 fail:
38224 return NULL;
38225 }
38226
38227
38228 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38229 PyObject *resultobj = 0;
38230 wxValidator *arg1 = (wxValidator *) 0 ;
38231 bool result;
38232 void *argp1 = 0 ;
38233 int res1 = 0 ;
38234 PyObject *swig_obj[1] ;
38235
38236 if (!args) SWIG_fail;
38237 swig_obj[0] = args;
38238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38239 if (!SWIG_IsOK(res1)) {
38240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38241 }
38242 arg1 = reinterpret_cast< wxValidator * >(argp1);
38243 {
38244 PyThreadState* __tstate = wxPyBeginAllowThreads();
38245 result = (bool)(arg1)->TransferToWindow();
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 {
38250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38251 }
38252 return resultobj;
38253 fail:
38254 return NULL;
38255 }
38256
38257
38258 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38259 PyObject *resultobj = 0;
38260 wxValidator *arg1 = (wxValidator *) 0 ;
38261 bool result;
38262 void *argp1 = 0 ;
38263 int res1 = 0 ;
38264 PyObject *swig_obj[1] ;
38265
38266 if (!args) SWIG_fail;
38267 swig_obj[0] = args;
38268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38269 if (!SWIG_IsOK(res1)) {
38270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38271 }
38272 arg1 = reinterpret_cast< wxValidator * >(argp1);
38273 {
38274 PyThreadState* __tstate = wxPyBeginAllowThreads();
38275 result = (bool)(arg1)->TransferFromWindow();
38276 wxPyEndAllowThreads(__tstate);
38277 if (PyErr_Occurred()) SWIG_fail;
38278 }
38279 {
38280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38281 }
38282 return resultobj;
38283 fail:
38284 return NULL;
38285 }
38286
38287
38288 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38289 PyObject *resultobj = 0;
38290 wxValidator *arg1 = (wxValidator *) 0 ;
38291 wxWindow *result = 0 ;
38292 void *argp1 = 0 ;
38293 int res1 = 0 ;
38294 PyObject *swig_obj[1] ;
38295
38296 if (!args) SWIG_fail;
38297 swig_obj[0] = args;
38298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38299 if (!SWIG_IsOK(res1)) {
38300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38301 }
38302 arg1 = reinterpret_cast< wxValidator * >(argp1);
38303 {
38304 PyThreadState* __tstate = wxPyBeginAllowThreads();
38305 result = (wxWindow *)(arg1)->GetWindow();
38306 wxPyEndAllowThreads(__tstate);
38307 if (PyErr_Occurred()) SWIG_fail;
38308 }
38309 {
38310 resultobj = wxPyMake_wxObject(result, 0);
38311 }
38312 return resultobj;
38313 fail:
38314 return NULL;
38315 }
38316
38317
38318 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38319 PyObject *resultobj = 0;
38320 wxValidator *arg1 = (wxValidator *) 0 ;
38321 wxWindow *arg2 = (wxWindow *) 0 ;
38322 void *argp1 = 0 ;
38323 int res1 = 0 ;
38324 void *argp2 = 0 ;
38325 int res2 = 0 ;
38326 PyObject * obj0 = 0 ;
38327 PyObject * obj1 = 0 ;
38328 char * kwnames[] = {
38329 (char *) "self",(char *) "window", NULL
38330 };
38331
38332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38334 if (!SWIG_IsOK(res1)) {
38335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38336 }
38337 arg1 = reinterpret_cast< wxValidator * >(argp1);
38338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38339 if (!SWIG_IsOK(res2)) {
38340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38341 }
38342 arg2 = reinterpret_cast< wxWindow * >(argp2);
38343 {
38344 PyThreadState* __tstate = wxPyBeginAllowThreads();
38345 (arg1)->SetWindow(arg2);
38346 wxPyEndAllowThreads(__tstate);
38347 if (PyErr_Occurred()) SWIG_fail;
38348 }
38349 resultobj = SWIG_Py_Void();
38350 return resultobj;
38351 fail:
38352 return NULL;
38353 }
38354
38355
38356 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38357 PyObject *resultobj = 0;
38358 bool result;
38359
38360 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38361 {
38362 PyThreadState* __tstate = wxPyBeginAllowThreads();
38363 result = (bool)wxValidator::IsSilent();
38364 wxPyEndAllowThreads(__tstate);
38365 if (PyErr_Occurred()) SWIG_fail;
38366 }
38367 {
38368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38369 }
38370 return resultobj;
38371 fail:
38372 return NULL;
38373 }
38374
38375
38376 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38377 PyObject *resultobj = 0;
38378 int arg1 = (int) true ;
38379 int val1 ;
38380 int ecode1 = 0 ;
38381 PyObject * obj0 = 0 ;
38382 char * kwnames[] = {
38383 (char *) "doIt", NULL
38384 };
38385
38386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38387 if (obj0) {
38388 ecode1 = SWIG_AsVal_int(obj0, &val1);
38389 if (!SWIG_IsOK(ecode1)) {
38390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38391 }
38392 arg1 = static_cast< int >(val1);
38393 }
38394 {
38395 PyThreadState* __tstate = wxPyBeginAllowThreads();
38396 wxValidator::SetBellOnError(arg1);
38397 wxPyEndAllowThreads(__tstate);
38398 if (PyErr_Occurred()) SWIG_fail;
38399 }
38400 resultobj = SWIG_Py_Void();
38401 return resultobj;
38402 fail:
38403 return NULL;
38404 }
38405
38406
38407 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38408 PyObject *obj;
38409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38410 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38411 return SWIG_Py_Void();
38412 }
38413
38414 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38415 return SWIG_Python_InitShadowInstance(args);
38416 }
38417
38418 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38419 PyObject *resultobj = 0;
38420 wxPyValidator *result = 0 ;
38421
38422 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38423 {
38424 PyThreadState* __tstate = wxPyBeginAllowThreads();
38425 result = (wxPyValidator *)new wxPyValidator();
38426 wxPyEndAllowThreads(__tstate);
38427 if (PyErr_Occurred()) SWIG_fail;
38428 }
38429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38430 return resultobj;
38431 fail:
38432 return NULL;
38433 }
38434
38435
38436 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38437 PyObject *resultobj = 0;
38438 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38439 PyObject *arg2 = (PyObject *) 0 ;
38440 PyObject *arg3 = (PyObject *) 0 ;
38441 int arg4 = (int) true ;
38442 void *argp1 = 0 ;
38443 int res1 = 0 ;
38444 int val4 ;
38445 int ecode4 = 0 ;
38446 PyObject * obj0 = 0 ;
38447 PyObject * obj1 = 0 ;
38448 PyObject * obj2 = 0 ;
38449 PyObject * obj3 = 0 ;
38450 char * kwnames[] = {
38451 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38452 };
38453
38454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38456 if (!SWIG_IsOK(res1)) {
38457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38458 }
38459 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38460 arg2 = obj1;
38461 arg3 = obj2;
38462 if (obj3) {
38463 ecode4 = SWIG_AsVal_int(obj3, &val4);
38464 if (!SWIG_IsOK(ecode4)) {
38465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38466 }
38467 arg4 = static_cast< int >(val4);
38468 }
38469 {
38470 PyThreadState* __tstate = wxPyBeginAllowThreads();
38471 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38472 wxPyEndAllowThreads(__tstate);
38473 if (PyErr_Occurred()) SWIG_fail;
38474 }
38475 resultobj = SWIG_Py_Void();
38476 return resultobj;
38477 fail:
38478 return NULL;
38479 }
38480
38481
38482 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38483 PyObject *obj;
38484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38485 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38486 return SWIG_Py_Void();
38487 }
38488
38489 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38490 return SWIG_Python_InitShadowInstance(args);
38491 }
38492
38493 SWIGINTERN int DefaultValidator_set(PyObject *) {
38494 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38495 return 1;
38496 }
38497
38498
38499 SWIGINTERN PyObject *DefaultValidator_get(void) {
38500 PyObject *pyobj = 0;
38501
38502 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38503 return pyobj;
38504 }
38505
38506
38507 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38508 PyObject *resultobj = 0;
38509 wxString const &arg1_defvalue = wxPyEmptyString ;
38510 wxString *arg1 = (wxString *) &arg1_defvalue ;
38511 long arg2 = (long) 0 ;
38512 wxMenu *result = 0 ;
38513 bool temp1 = false ;
38514 long val2 ;
38515 int ecode2 = 0 ;
38516 PyObject * obj0 = 0 ;
38517 PyObject * obj1 = 0 ;
38518 char * kwnames[] = {
38519 (char *) "title",(char *) "style", NULL
38520 };
38521
38522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38523 if (obj0) {
38524 {
38525 arg1 = wxString_in_helper(obj0);
38526 if (arg1 == NULL) SWIG_fail;
38527 temp1 = true;
38528 }
38529 }
38530 if (obj1) {
38531 ecode2 = SWIG_AsVal_long(obj1, &val2);
38532 if (!SWIG_IsOK(ecode2)) {
38533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38534 }
38535 arg2 = static_cast< long >(val2);
38536 }
38537 {
38538 if (!wxPyCheckForApp()) SWIG_fail;
38539 PyThreadState* __tstate = wxPyBeginAllowThreads();
38540 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38541 wxPyEndAllowThreads(__tstate);
38542 if (PyErr_Occurred()) SWIG_fail;
38543 }
38544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38545 {
38546 if (temp1)
38547 delete arg1;
38548 }
38549 return resultobj;
38550 fail:
38551 {
38552 if (temp1)
38553 delete arg1;
38554 }
38555 return NULL;
38556 }
38557
38558
38559 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38560 PyObject *resultobj = 0;
38561 wxMenu *arg1 = (wxMenu *) 0 ;
38562 int arg2 ;
38563 wxString *arg3 = 0 ;
38564 wxString const &arg4_defvalue = wxPyEmptyString ;
38565 wxString *arg4 = (wxString *) &arg4_defvalue ;
38566 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38567 wxMenuItem *result = 0 ;
38568 void *argp1 = 0 ;
38569 int res1 = 0 ;
38570 int val2 ;
38571 int ecode2 = 0 ;
38572 bool temp3 = false ;
38573 bool temp4 = false ;
38574 int val5 ;
38575 int ecode5 = 0 ;
38576 PyObject * obj0 = 0 ;
38577 PyObject * obj1 = 0 ;
38578 PyObject * obj2 = 0 ;
38579 PyObject * obj3 = 0 ;
38580 PyObject * obj4 = 0 ;
38581 char * kwnames[] = {
38582 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38583 };
38584
38585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38587 if (!SWIG_IsOK(res1)) {
38588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38589 }
38590 arg1 = reinterpret_cast< wxMenu * >(argp1);
38591 ecode2 = SWIG_AsVal_int(obj1, &val2);
38592 if (!SWIG_IsOK(ecode2)) {
38593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38594 }
38595 arg2 = static_cast< int >(val2);
38596 {
38597 arg3 = wxString_in_helper(obj2);
38598 if (arg3 == NULL) SWIG_fail;
38599 temp3 = true;
38600 }
38601 if (obj3) {
38602 {
38603 arg4 = wxString_in_helper(obj3);
38604 if (arg4 == NULL) SWIG_fail;
38605 temp4 = true;
38606 }
38607 }
38608 if (obj4) {
38609 ecode5 = SWIG_AsVal_int(obj4, &val5);
38610 if (!SWIG_IsOK(ecode5)) {
38611 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38612 }
38613 arg5 = static_cast< wxItemKind >(val5);
38614 }
38615 {
38616 PyThreadState* __tstate = wxPyBeginAllowThreads();
38617 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38618 wxPyEndAllowThreads(__tstate);
38619 if (PyErr_Occurred()) SWIG_fail;
38620 }
38621 {
38622 resultobj = wxPyMake_wxObject(result, (bool)0);
38623 }
38624 {
38625 if (temp3)
38626 delete arg3;
38627 }
38628 {
38629 if (temp4)
38630 delete arg4;
38631 }
38632 return resultobj;
38633 fail:
38634 {
38635 if (temp3)
38636 delete arg3;
38637 }
38638 {
38639 if (temp4)
38640 delete arg4;
38641 }
38642 return NULL;
38643 }
38644
38645
38646 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38647 PyObject *resultobj = 0;
38648 wxMenu *arg1 = (wxMenu *) 0 ;
38649 wxMenuItem *result = 0 ;
38650 void *argp1 = 0 ;
38651 int res1 = 0 ;
38652 PyObject *swig_obj[1] ;
38653
38654 if (!args) SWIG_fail;
38655 swig_obj[0] = args;
38656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38657 if (!SWIG_IsOK(res1)) {
38658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38659 }
38660 arg1 = reinterpret_cast< wxMenu * >(argp1);
38661 {
38662 PyThreadState* __tstate = wxPyBeginAllowThreads();
38663 result = (wxMenuItem *)(arg1)->AppendSeparator();
38664 wxPyEndAllowThreads(__tstate);
38665 if (PyErr_Occurred()) SWIG_fail;
38666 }
38667 {
38668 resultobj = wxPyMake_wxObject(result, (bool)0);
38669 }
38670 return resultobj;
38671 fail:
38672 return NULL;
38673 }
38674
38675
38676 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38677 PyObject *resultobj = 0;
38678 wxMenu *arg1 = (wxMenu *) 0 ;
38679 int arg2 ;
38680 wxString *arg3 = 0 ;
38681 wxString const &arg4_defvalue = wxPyEmptyString ;
38682 wxString *arg4 = (wxString *) &arg4_defvalue ;
38683 wxMenuItem *result = 0 ;
38684 void *argp1 = 0 ;
38685 int res1 = 0 ;
38686 int val2 ;
38687 int ecode2 = 0 ;
38688 bool temp3 = false ;
38689 bool temp4 = false ;
38690 PyObject * obj0 = 0 ;
38691 PyObject * obj1 = 0 ;
38692 PyObject * obj2 = 0 ;
38693 PyObject * obj3 = 0 ;
38694 char * kwnames[] = {
38695 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38696 };
38697
38698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38700 if (!SWIG_IsOK(res1)) {
38701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38702 }
38703 arg1 = reinterpret_cast< wxMenu * >(argp1);
38704 ecode2 = SWIG_AsVal_int(obj1, &val2);
38705 if (!SWIG_IsOK(ecode2)) {
38706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38707 }
38708 arg2 = static_cast< int >(val2);
38709 {
38710 arg3 = wxString_in_helper(obj2);
38711 if (arg3 == NULL) SWIG_fail;
38712 temp3 = true;
38713 }
38714 if (obj3) {
38715 {
38716 arg4 = wxString_in_helper(obj3);
38717 if (arg4 == NULL) SWIG_fail;
38718 temp4 = true;
38719 }
38720 }
38721 {
38722 PyThreadState* __tstate = wxPyBeginAllowThreads();
38723 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38724 wxPyEndAllowThreads(__tstate);
38725 if (PyErr_Occurred()) SWIG_fail;
38726 }
38727 {
38728 resultobj = wxPyMake_wxObject(result, (bool)0);
38729 }
38730 {
38731 if (temp3)
38732 delete arg3;
38733 }
38734 {
38735 if (temp4)
38736 delete arg4;
38737 }
38738 return resultobj;
38739 fail:
38740 {
38741 if (temp3)
38742 delete arg3;
38743 }
38744 {
38745 if (temp4)
38746 delete arg4;
38747 }
38748 return NULL;
38749 }
38750
38751
38752 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38753 PyObject *resultobj = 0;
38754 wxMenu *arg1 = (wxMenu *) 0 ;
38755 int arg2 ;
38756 wxString *arg3 = 0 ;
38757 wxString const &arg4_defvalue = wxPyEmptyString ;
38758 wxString *arg4 = (wxString *) &arg4_defvalue ;
38759 wxMenuItem *result = 0 ;
38760 void *argp1 = 0 ;
38761 int res1 = 0 ;
38762 int val2 ;
38763 int ecode2 = 0 ;
38764 bool temp3 = false ;
38765 bool temp4 = false ;
38766 PyObject * obj0 = 0 ;
38767 PyObject * obj1 = 0 ;
38768 PyObject * obj2 = 0 ;
38769 PyObject * obj3 = 0 ;
38770 char * kwnames[] = {
38771 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38772 };
38773
38774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38776 if (!SWIG_IsOK(res1)) {
38777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38778 }
38779 arg1 = reinterpret_cast< wxMenu * >(argp1);
38780 ecode2 = SWIG_AsVal_int(obj1, &val2);
38781 if (!SWIG_IsOK(ecode2)) {
38782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38783 }
38784 arg2 = static_cast< int >(val2);
38785 {
38786 arg3 = wxString_in_helper(obj2);
38787 if (arg3 == NULL) SWIG_fail;
38788 temp3 = true;
38789 }
38790 if (obj3) {
38791 {
38792 arg4 = wxString_in_helper(obj3);
38793 if (arg4 == NULL) SWIG_fail;
38794 temp4 = true;
38795 }
38796 }
38797 {
38798 PyThreadState* __tstate = wxPyBeginAllowThreads();
38799 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38800 wxPyEndAllowThreads(__tstate);
38801 if (PyErr_Occurred()) SWIG_fail;
38802 }
38803 {
38804 resultobj = wxPyMake_wxObject(result, (bool)0);
38805 }
38806 {
38807 if (temp3)
38808 delete arg3;
38809 }
38810 {
38811 if (temp4)
38812 delete arg4;
38813 }
38814 return resultobj;
38815 fail:
38816 {
38817 if (temp3)
38818 delete arg3;
38819 }
38820 {
38821 if (temp4)
38822 delete arg4;
38823 }
38824 return NULL;
38825 }
38826
38827
38828 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38829 PyObject *resultobj = 0;
38830 wxMenu *arg1 = (wxMenu *) 0 ;
38831 int arg2 ;
38832 wxString *arg3 = 0 ;
38833 wxMenu *arg4 = (wxMenu *) 0 ;
38834 wxString const &arg5_defvalue = wxPyEmptyString ;
38835 wxString *arg5 = (wxString *) &arg5_defvalue ;
38836 wxMenuItem *result = 0 ;
38837 void *argp1 = 0 ;
38838 int res1 = 0 ;
38839 int val2 ;
38840 int ecode2 = 0 ;
38841 bool temp3 = false ;
38842 void *argp4 = 0 ;
38843 int res4 = 0 ;
38844 bool temp5 = false ;
38845 PyObject * obj0 = 0 ;
38846 PyObject * obj1 = 0 ;
38847 PyObject * obj2 = 0 ;
38848 PyObject * obj3 = 0 ;
38849 PyObject * obj4 = 0 ;
38850 char * kwnames[] = {
38851 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38852 };
38853
38854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38856 if (!SWIG_IsOK(res1)) {
38857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38858 }
38859 arg1 = reinterpret_cast< wxMenu * >(argp1);
38860 ecode2 = SWIG_AsVal_int(obj1, &val2);
38861 if (!SWIG_IsOK(ecode2)) {
38862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38863 }
38864 arg2 = static_cast< int >(val2);
38865 {
38866 arg3 = wxString_in_helper(obj2);
38867 if (arg3 == NULL) SWIG_fail;
38868 temp3 = true;
38869 }
38870 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38871 if (!SWIG_IsOK(res4)) {
38872 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38873 }
38874 arg4 = reinterpret_cast< wxMenu * >(argp4);
38875 if (obj4) {
38876 {
38877 arg5 = wxString_in_helper(obj4);
38878 if (arg5 == NULL) SWIG_fail;
38879 temp5 = true;
38880 }
38881 }
38882 {
38883 PyThreadState* __tstate = wxPyBeginAllowThreads();
38884 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38885 wxPyEndAllowThreads(__tstate);
38886 if (PyErr_Occurred()) SWIG_fail;
38887 }
38888 {
38889 resultobj = wxPyMake_wxObject(result, (bool)0);
38890 }
38891 {
38892 if (temp3)
38893 delete arg3;
38894 }
38895 {
38896 if (temp5)
38897 delete arg5;
38898 }
38899 return resultobj;
38900 fail:
38901 {
38902 if (temp3)
38903 delete arg3;
38904 }
38905 {
38906 if (temp5)
38907 delete arg5;
38908 }
38909 return NULL;
38910 }
38911
38912
38913 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38914 PyObject *resultobj = 0;
38915 wxMenu *arg1 = (wxMenu *) 0 ;
38916 wxMenu *arg2 = (wxMenu *) 0 ;
38917 wxString *arg3 = 0 ;
38918 wxString const &arg4_defvalue = wxPyEmptyString ;
38919 wxString *arg4 = (wxString *) &arg4_defvalue ;
38920 wxMenuItem *result = 0 ;
38921 void *argp1 = 0 ;
38922 int res1 = 0 ;
38923 void *argp2 = 0 ;
38924 int res2 = 0 ;
38925 bool temp3 = false ;
38926 bool temp4 = false ;
38927 PyObject * obj0 = 0 ;
38928 PyObject * obj1 = 0 ;
38929 PyObject * obj2 = 0 ;
38930 PyObject * obj3 = 0 ;
38931 char * kwnames[] = {
38932 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38933 };
38934
38935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38937 if (!SWIG_IsOK(res1)) {
38938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38939 }
38940 arg1 = reinterpret_cast< wxMenu * >(argp1);
38941 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38942 if (!SWIG_IsOK(res2)) {
38943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38944 }
38945 arg2 = reinterpret_cast< wxMenu * >(argp2);
38946 {
38947 arg3 = wxString_in_helper(obj2);
38948 if (arg3 == NULL) SWIG_fail;
38949 temp3 = true;
38950 }
38951 if (obj3) {
38952 {
38953 arg4 = wxString_in_helper(obj3);
38954 if (arg4 == NULL) SWIG_fail;
38955 temp4 = true;
38956 }
38957 }
38958 {
38959 PyThreadState* __tstate = wxPyBeginAllowThreads();
38960 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38961 wxPyEndAllowThreads(__tstate);
38962 if (PyErr_Occurred()) SWIG_fail;
38963 }
38964 {
38965 resultobj = wxPyMake_wxObject(result, (bool)0);
38966 }
38967 {
38968 if (temp3)
38969 delete arg3;
38970 }
38971 {
38972 if (temp4)
38973 delete arg4;
38974 }
38975 return resultobj;
38976 fail:
38977 {
38978 if (temp3)
38979 delete arg3;
38980 }
38981 {
38982 if (temp4)
38983 delete arg4;
38984 }
38985 return NULL;
38986 }
38987
38988
38989 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38990 PyObject *resultobj = 0;
38991 wxMenu *arg1 = (wxMenu *) 0 ;
38992 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38993 wxMenuItem *result = 0 ;
38994 void *argp1 = 0 ;
38995 int res1 = 0 ;
38996 int res2 = 0 ;
38997 PyObject * obj0 = 0 ;
38998 PyObject * obj1 = 0 ;
38999 char * kwnames[] = {
39000 (char *) "self",(char *) "item", NULL
39001 };
39002
39003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39005 if (!SWIG_IsOK(res1)) {
39006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39007 }
39008 arg1 = reinterpret_cast< wxMenu * >(argp1);
39009 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39010 if (!SWIG_IsOK(res2)) {
39011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39012 }
39013 {
39014 PyThreadState* __tstate = wxPyBeginAllowThreads();
39015 result = (wxMenuItem *)(arg1)->Append(arg2);
39016 wxPyEndAllowThreads(__tstate);
39017 if (PyErr_Occurred()) SWIG_fail;
39018 }
39019 {
39020 resultobj = wxPyMake_wxObject(result, (bool)0);
39021 }
39022 return resultobj;
39023 fail:
39024 return NULL;
39025 }
39026
39027
39028 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39029 PyObject *resultobj = 0;
39030 wxMenu *arg1 = (wxMenu *) 0 ;
39031 size_t arg2 ;
39032 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39033 wxMenuItem *result = 0 ;
39034 void *argp1 = 0 ;
39035 int res1 = 0 ;
39036 size_t val2 ;
39037 int ecode2 = 0 ;
39038 int res3 = 0 ;
39039 PyObject * obj0 = 0 ;
39040 PyObject * obj1 = 0 ;
39041 PyObject * obj2 = 0 ;
39042 char * kwnames[] = {
39043 (char *) "self",(char *) "pos",(char *) "item", NULL
39044 };
39045
39046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39048 if (!SWIG_IsOK(res1)) {
39049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39050 }
39051 arg1 = reinterpret_cast< wxMenu * >(argp1);
39052 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39053 if (!SWIG_IsOK(ecode2)) {
39054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39055 }
39056 arg2 = static_cast< size_t >(val2);
39057 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39058 if (!SWIG_IsOK(res3)) {
39059 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39060 }
39061 {
39062 PyThreadState* __tstate = wxPyBeginAllowThreads();
39063 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39064 wxPyEndAllowThreads(__tstate);
39065 if (PyErr_Occurred()) SWIG_fail;
39066 }
39067 {
39068 resultobj = wxPyMake_wxObject(result, (bool)0);
39069 }
39070 return resultobj;
39071 fail:
39072 return NULL;
39073 }
39074
39075
39076 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39077 PyObject *resultobj = 0;
39078 wxMenu *arg1 = (wxMenu *) 0 ;
39079 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39080 wxMenuItem *result = 0 ;
39081 void *argp1 = 0 ;
39082 int res1 = 0 ;
39083 int res2 = 0 ;
39084 PyObject * obj0 = 0 ;
39085 PyObject * obj1 = 0 ;
39086 char * kwnames[] = {
39087 (char *) "self",(char *) "item", NULL
39088 };
39089
39090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39092 if (!SWIG_IsOK(res1)) {
39093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39094 }
39095 arg1 = reinterpret_cast< wxMenu * >(argp1);
39096 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39097 if (!SWIG_IsOK(res2)) {
39098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39099 }
39100 {
39101 PyThreadState* __tstate = wxPyBeginAllowThreads();
39102 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39103 wxPyEndAllowThreads(__tstate);
39104 if (PyErr_Occurred()) SWIG_fail;
39105 }
39106 {
39107 resultobj = wxPyMake_wxObject(result, (bool)0);
39108 }
39109 return resultobj;
39110 fail:
39111 return NULL;
39112 }
39113
39114
39115 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39116 PyObject *resultobj = 0;
39117 wxMenu *arg1 = (wxMenu *) 0 ;
39118 void *argp1 = 0 ;
39119 int res1 = 0 ;
39120 PyObject *swig_obj[1] ;
39121
39122 if (!args) SWIG_fail;
39123 swig_obj[0] = args;
39124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39125 if (!SWIG_IsOK(res1)) {
39126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39127 }
39128 arg1 = reinterpret_cast< wxMenu * >(argp1);
39129 {
39130 PyThreadState* __tstate = wxPyBeginAllowThreads();
39131 (arg1)->Break();
39132 wxPyEndAllowThreads(__tstate);
39133 if (PyErr_Occurred()) SWIG_fail;
39134 }
39135 resultobj = SWIG_Py_Void();
39136 return resultobj;
39137 fail:
39138 return NULL;
39139 }
39140
39141
39142 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39143 PyObject *resultobj = 0;
39144 wxMenu *arg1 = (wxMenu *) 0 ;
39145 size_t arg2 ;
39146 int arg3 ;
39147 wxString *arg4 = 0 ;
39148 wxString const &arg5_defvalue = wxPyEmptyString ;
39149 wxString *arg5 = (wxString *) &arg5_defvalue ;
39150 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39151 wxMenuItem *result = 0 ;
39152 void *argp1 = 0 ;
39153 int res1 = 0 ;
39154 size_t val2 ;
39155 int ecode2 = 0 ;
39156 int val3 ;
39157 int ecode3 = 0 ;
39158 bool temp4 = false ;
39159 bool temp5 = false ;
39160 int val6 ;
39161 int ecode6 = 0 ;
39162 PyObject * obj0 = 0 ;
39163 PyObject * obj1 = 0 ;
39164 PyObject * obj2 = 0 ;
39165 PyObject * obj3 = 0 ;
39166 PyObject * obj4 = 0 ;
39167 PyObject * obj5 = 0 ;
39168 char * kwnames[] = {
39169 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39170 };
39171
39172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39174 if (!SWIG_IsOK(res1)) {
39175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39176 }
39177 arg1 = reinterpret_cast< wxMenu * >(argp1);
39178 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39179 if (!SWIG_IsOK(ecode2)) {
39180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39181 }
39182 arg2 = static_cast< size_t >(val2);
39183 ecode3 = SWIG_AsVal_int(obj2, &val3);
39184 if (!SWIG_IsOK(ecode3)) {
39185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39186 }
39187 arg3 = static_cast< int >(val3);
39188 {
39189 arg4 = wxString_in_helper(obj3);
39190 if (arg4 == NULL) SWIG_fail;
39191 temp4 = true;
39192 }
39193 if (obj4) {
39194 {
39195 arg5 = wxString_in_helper(obj4);
39196 if (arg5 == NULL) SWIG_fail;
39197 temp5 = true;
39198 }
39199 }
39200 if (obj5) {
39201 ecode6 = SWIG_AsVal_int(obj5, &val6);
39202 if (!SWIG_IsOK(ecode6)) {
39203 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39204 }
39205 arg6 = static_cast< wxItemKind >(val6);
39206 }
39207 {
39208 PyThreadState* __tstate = wxPyBeginAllowThreads();
39209 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39210 wxPyEndAllowThreads(__tstate);
39211 if (PyErr_Occurred()) SWIG_fail;
39212 }
39213 {
39214 resultobj = wxPyMake_wxObject(result, (bool)0);
39215 }
39216 {
39217 if (temp4)
39218 delete arg4;
39219 }
39220 {
39221 if (temp5)
39222 delete arg5;
39223 }
39224 return resultobj;
39225 fail:
39226 {
39227 if (temp4)
39228 delete arg4;
39229 }
39230 {
39231 if (temp5)
39232 delete arg5;
39233 }
39234 return NULL;
39235 }
39236
39237
39238 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39239 PyObject *resultobj = 0;
39240 wxMenu *arg1 = (wxMenu *) 0 ;
39241 size_t arg2 ;
39242 wxMenuItem *result = 0 ;
39243 void *argp1 = 0 ;
39244 int res1 = 0 ;
39245 size_t val2 ;
39246 int ecode2 = 0 ;
39247 PyObject * obj0 = 0 ;
39248 PyObject * obj1 = 0 ;
39249 char * kwnames[] = {
39250 (char *) "self",(char *) "pos", NULL
39251 };
39252
39253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39255 if (!SWIG_IsOK(res1)) {
39256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39257 }
39258 arg1 = reinterpret_cast< wxMenu * >(argp1);
39259 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39260 if (!SWIG_IsOK(ecode2)) {
39261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39262 }
39263 arg2 = static_cast< size_t >(val2);
39264 {
39265 PyThreadState* __tstate = wxPyBeginAllowThreads();
39266 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39267 wxPyEndAllowThreads(__tstate);
39268 if (PyErr_Occurred()) SWIG_fail;
39269 }
39270 {
39271 resultobj = wxPyMake_wxObject(result, (bool)0);
39272 }
39273 return resultobj;
39274 fail:
39275 return NULL;
39276 }
39277
39278
39279 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39280 PyObject *resultobj = 0;
39281 wxMenu *arg1 = (wxMenu *) 0 ;
39282 size_t arg2 ;
39283 int arg3 ;
39284 wxString *arg4 = 0 ;
39285 wxString const &arg5_defvalue = wxPyEmptyString ;
39286 wxString *arg5 = (wxString *) &arg5_defvalue ;
39287 wxMenuItem *result = 0 ;
39288 void *argp1 = 0 ;
39289 int res1 = 0 ;
39290 size_t val2 ;
39291 int ecode2 = 0 ;
39292 int val3 ;
39293 int ecode3 = 0 ;
39294 bool temp4 = false ;
39295 bool temp5 = false ;
39296 PyObject * obj0 = 0 ;
39297 PyObject * obj1 = 0 ;
39298 PyObject * obj2 = 0 ;
39299 PyObject * obj3 = 0 ;
39300 PyObject * obj4 = 0 ;
39301 char * kwnames[] = {
39302 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39303 };
39304
39305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39307 if (!SWIG_IsOK(res1)) {
39308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39309 }
39310 arg1 = reinterpret_cast< wxMenu * >(argp1);
39311 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39312 if (!SWIG_IsOK(ecode2)) {
39313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39314 }
39315 arg2 = static_cast< size_t >(val2);
39316 ecode3 = SWIG_AsVal_int(obj2, &val3);
39317 if (!SWIG_IsOK(ecode3)) {
39318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39319 }
39320 arg3 = static_cast< int >(val3);
39321 {
39322 arg4 = wxString_in_helper(obj3);
39323 if (arg4 == NULL) SWIG_fail;
39324 temp4 = true;
39325 }
39326 if (obj4) {
39327 {
39328 arg5 = wxString_in_helper(obj4);
39329 if (arg5 == NULL) SWIG_fail;
39330 temp5 = true;
39331 }
39332 }
39333 {
39334 PyThreadState* __tstate = wxPyBeginAllowThreads();
39335 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39336 wxPyEndAllowThreads(__tstate);
39337 if (PyErr_Occurred()) SWIG_fail;
39338 }
39339 {
39340 resultobj = wxPyMake_wxObject(result, (bool)0);
39341 }
39342 {
39343 if (temp4)
39344 delete arg4;
39345 }
39346 {
39347 if (temp5)
39348 delete arg5;
39349 }
39350 return resultobj;
39351 fail:
39352 {
39353 if (temp4)
39354 delete arg4;
39355 }
39356 {
39357 if (temp5)
39358 delete arg5;
39359 }
39360 return NULL;
39361 }
39362
39363
39364 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39365 PyObject *resultobj = 0;
39366 wxMenu *arg1 = (wxMenu *) 0 ;
39367 size_t arg2 ;
39368 int arg3 ;
39369 wxString *arg4 = 0 ;
39370 wxString const &arg5_defvalue = wxPyEmptyString ;
39371 wxString *arg5 = (wxString *) &arg5_defvalue ;
39372 wxMenuItem *result = 0 ;
39373 void *argp1 = 0 ;
39374 int res1 = 0 ;
39375 size_t val2 ;
39376 int ecode2 = 0 ;
39377 int val3 ;
39378 int ecode3 = 0 ;
39379 bool temp4 = false ;
39380 bool temp5 = false ;
39381 PyObject * obj0 = 0 ;
39382 PyObject * obj1 = 0 ;
39383 PyObject * obj2 = 0 ;
39384 PyObject * obj3 = 0 ;
39385 PyObject * obj4 = 0 ;
39386 char * kwnames[] = {
39387 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39388 };
39389
39390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39392 if (!SWIG_IsOK(res1)) {
39393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39394 }
39395 arg1 = reinterpret_cast< wxMenu * >(argp1);
39396 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39397 if (!SWIG_IsOK(ecode2)) {
39398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39399 }
39400 arg2 = static_cast< size_t >(val2);
39401 ecode3 = SWIG_AsVal_int(obj2, &val3);
39402 if (!SWIG_IsOK(ecode3)) {
39403 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39404 }
39405 arg3 = static_cast< int >(val3);
39406 {
39407 arg4 = wxString_in_helper(obj3);
39408 if (arg4 == NULL) SWIG_fail;
39409 temp4 = true;
39410 }
39411 if (obj4) {
39412 {
39413 arg5 = wxString_in_helper(obj4);
39414 if (arg5 == NULL) SWIG_fail;
39415 temp5 = true;
39416 }
39417 }
39418 {
39419 PyThreadState* __tstate = wxPyBeginAllowThreads();
39420 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39421 wxPyEndAllowThreads(__tstate);
39422 if (PyErr_Occurred()) SWIG_fail;
39423 }
39424 {
39425 resultobj = wxPyMake_wxObject(result, (bool)0);
39426 }
39427 {
39428 if (temp4)
39429 delete arg4;
39430 }
39431 {
39432 if (temp5)
39433 delete arg5;
39434 }
39435 return resultobj;
39436 fail:
39437 {
39438 if (temp4)
39439 delete arg4;
39440 }
39441 {
39442 if (temp5)
39443 delete arg5;
39444 }
39445 return NULL;
39446 }
39447
39448
39449 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39450 PyObject *resultobj = 0;
39451 wxMenu *arg1 = (wxMenu *) 0 ;
39452 size_t arg2 ;
39453 int arg3 ;
39454 wxString *arg4 = 0 ;
39455 wxMenu *arg5 = (wxMenu *) 0 ;
39456 wxString const &arg6_defvalue = wxPyEmptyString ;
39457 wxString *arg6 = (wxString *) &arg6_defvalue ;
39458 wxMenuItem *result = 0 ;
39459 void *argp1 = 0 ;
39460 int res1 = 0 ;
39461 size_t val2 ;
39462 int ecode2 = 0 ;
39463 int val3 ;
39464 int ecode3 = 0 ;
39465 bool temp4 = false ;
39466 void *argp5 = 0 ;
39467 int res5 = 0 ;
39468 bool temp6 = false ;
39469 PyObject * obj0 = 0 ;
39470 PyObject * obj1 = 0 ;
39471 PyObject * obj2 = 0 ;
39472 PyObject * obj3 = 0 ;
39473 PyObject * obj4 = 0 ;
39474 PyObject * obj5 = 0 ;
39475 char * kwnames[] = {
39476 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39477 };
39478
39479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39481 if (!SWIG_IsOK(res1)) {
39482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39483 }
39484 arg1 = reinterpret_cast< wxMenu * >(argp1);
39485 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39486 if (!SWIG_IsOK(ecode2)) {
39487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39488 }
39489 arg2 = static_cast< size_t >(val2);
39490 ecode3 = SWIG_AsVal_int(obj2, &val3);
39491 if (!SWIG_IsOK(ecode3)) {
39492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39493 }
39494 arg3 = static_cast< int >(val3);
39495 {
39496 arg4 = wxString_in_helper(obj3);
39497 if (arg4 == NULL) SWIG_fail;
39498 temp4 = true;
39499 }
39500 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39501 if (!SWIG_IsOK(res5)) {
39502 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39503 }
39504 arg5 = reinterpret_cast< wxMenu * >(argp5);
39505 if (obj5) {
39506 {
39507 arg6 = wxString_in_helper(obj5);
39508 if (arg6 == NULL) SWIG_fail;
39509 temp6 = true;
39510 }
39511 }
39512 {
39513 PyThreadState* __tstate = wxPyBeginAllowThreads();
39514 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39515 wxPyEndAllowThreads(__tstate);
39516 if (PyErr_Occurred()) SWIG_fail;
39517 }
39518 {
39519 resultobj = wxPyMake_wxObject(result, (bool)0);
39520 }
39521 {
39522 if (temp4)
39523 delete arg4;
39524 }
39525 {
39526 if (temp6)
39527 delete arg6;
39528 }
39529 return resultobj;
39530 fail:
39531 {
39532 if (temp4)
39533 delete arg4;
39534 }
39535 {
39536 if (temp6)
39537 delete arg6;
39538 }
39539 return NULL;
39540 }
39541
39542
39543 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39544 PyObject *resultobj = 0;
39545 wxMenu *arg1 = (wxMenu *) 0 ;
39546 int arg2 ;
39547 wxString *arg3 = 0 ;
39548 wxString const &arg4_defvalue = wxPyEmptyString ;
39549 wxString *arg4 = (wxString *) &arg4_defvalue ;
39550 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39551 wxMenuItem *result = 0 ;
39552 void *argp1 = 0 ;
39553 int res1 = 0 ;
39554 int val2 ;
39555 int ecode2 = 0 ;
39556 bool temp3 = false ;
39557 bool temp4 = false ;
39558 int val5 ;
39559 int ecode5 = 0 ;
39560 PyObject * obj0 = 0 ;
39561 PyObject * obj1 = 0 ;
39562 PyObject * obj2 = 0 ;
39563 PyObject * obj3 = 0 ;
39564 PyObject * obj4 = 0 ;
39565 char * kwnames[] = {
39566 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39567 };
39568
39569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39571 if (!SWIG_IsOK(res1)) {
39572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39573 }
39574 arg1 = reinterpret_cast< wxMenu * >(argp1);
39575 ecode2 = SWIG_AsVal_int(obj1, &val2);
39576 if (!SWIG_IsOK(ecode2)) {
39577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39578 }
39579 arg2 = static_cast< int >(val2);
39580 {
39581 arg3 = wxString_in_helper(obj2);
39582 if (arg3 == NULL) SWIG_fail;
39583 temp3 = true;
39584 }
39585 if (obj3) {
39586 {
39587 arg4 = wxString_in_helper(obj3);
39588 if (arg4 == NULL) SWIG_fail;
39589 temp4 = true;
39590 }
39591 }
39592 if (obj4) {
39593 ecode5 = SWIG_AsVal_int(obj4, &val5);
39594 if (!SWIG_IsOK(ecode5)) {
39595 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39596 }
39597 arg5 = static_cast< wxItemKind >(val5);
39598 }
39599 {
39600 PyThreadState* __tstate = wxPyBeginAllowThreads();
39601 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39602 wxPyEndAllowThreads(__tstate);
39603 if (PyErr_Occurred()) SWIG_fail;
39604 }
39605 {
39606 resultobj = wxPyMake_wxObject(result, (bool)0);
39607 }
39608 {
39609 if (temp3)
39610 delete arg3;
39611 }
39612 {
39613 if (temp4)
39614 delete arg4;
39615 }
39616 return resultobj;
39617 fail:
39618 {
39619 if (temp3)
39620 delete arg3;
39621 }
39622 {
39623 if (temp4)
39624 delete arg4;
39625 }
39626 return NULL;
39627 }
39628
39629
39630 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39631 PyObject *resultobj = 0;
39632 wxMenu *arg1 = (wxMenu *) 0 ;
39633 wxMenuItem *result = 0 ;
39634 void *argp1 = 0 ;
39635 int res1 = 0 ;
39636 PyObject *swig_obj[1] ;
39637
39638 if (!args) SWIG_fail;
39639 swig_obj[0] = args;
39640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39641 if (!SWIG_IsOK(res1)) {
39642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39643 }
39644 arg1 = reinterpret_cast< wxMenu * >(argp1);
39645 {
39646 PyThreadState* __tstate = wxPyBeginAllowThreads();
39647 result = (wxMenuItem *)(arg1)->PrependSeparator();
39648 wxPyEndAllowThreads(__tstate);
39649 if (PyErr_Occurred()) SWIG_fail;
39650 }
39651 {
39652 resultobj = wxPyMake_wxObject(result, (bool)0);
39653 }
39654 return resultobj;
39655 fail:
39656 return NULL;
39657 }
39658
39659
39660 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39661 PyObject *resultobj = 0;
39662 wxMenu *arg1 = (wxMenu *) 0 ;
39663 int arg2 ;
39664 wxString *arg3 = 0 ;
39665 wxString const &arg4_defvalue = wxPyEmptyString ;
39666 wxString *arg4 = (wxString *) &arg4_defvalue ;
39667 wxMenuItem *result = 0 ;
39668 void *argp1 = 0 ;
39669 int res1 = 0 ;
39670 int val2 ;
39671 int ecode2 = 0 ;
39672 bool temp3 = false ;
39673 bool temp4 = false ;
39674 PyObject * obj0 = 0 ;
39675 PyObject * obj1 = 0 ;
39676 PyObject * obj2 = 0 ;
39677 PyObject * obj3 = 0 ;
39678 char * kwnames[] = {
39679 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39680 };
39681
39682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39684 if (!SWIG_IsOK(res1)) {
39685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39686 }
39687 arg1 = reinterpret_cast< wxMenu * >(argp1);
39688 ecode2 = SWIG_AsVal_int(obj1, &val2);
39689 if (!SWIG_IsOK(ecode2)) {
39690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39691 }
39692 arg2 = static_cast< int >(val2);
39693 {
39694 arg3 = wxString_in_helper(obj2);
39695 if (arg3 == NULL) SWIG_fail;
39696 temp3 = true;
39697 }
39698 if (obj3) {
39699 {
39700 arg4 = wxString_in_helper(obj3);
39701 if (arg4 == NULL) SWIG_fail;
39702 temp4 = true;
39703 }
39704 }
39705 {
39706 PyThreadState* __tstate = wxPyBeginAllowThreads();
39707 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39708 wxPyEndAllowThreads(__tstate);
39709 if (PyErr_Occurred()) SWIG_fail;
39710 }
39711 {
39712 resultobj = wxPyMake_wxObject(result, (bool)0);
39713 }
39714 {
39715 if (temp3)
39716 delete arg3;
39717 }
39718 {
39719 if (temp4)
39720 delete arg4;
39721 }
39722 return resultobj;
39723 fail:
39724 {
39725 if (temp3)
39726 delete arg3;
39727 }
39728 {
39729 if (temp4)
39730 delete arg4;
39731 }
39732 return NULL;
39733 }
39734
39735
39736 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39737 PyObject *resultobj = 0;
39738 wxMenu *arg1 = (wxMenu *) 0 ;
39739 int arg2 ;
39740 wxString *arg3 = 0 ;
39741 wxString const &arg4_defvalue = wxPyEmptyString ;
39742 wxString *arg4 = (wxString *) &arg4_defvalue ;
39743 wxMenuItem *result = 0 ;
39744 void *argp1 = 0 ;
39745 int res1 = 0 ;
39746 int val2 ;
39747 int ecode2 = 0 ;
39748 bool temp3 = false ;
39749 bool temp4 = false ;
39750 PyObject * obj0 = 0 ;
39751 PyObject * obj1 = 0 ;
39752 PyObject * obj2 = 0 ;
39753 PyObject * obj3 = 0 ;
39754 char * kwnames[] = {
39755 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39756 };
39757
39758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39760 if (!SWIG_IsOK(res1)) {
39761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39762 }
39763 arg1 = reinterpret_cast< wxMenu * >(argp1);
39764 ecode2 = SWIG_AsVal_int(obj1, &val2);
39765 if (!SWIG_IsOK(ecode2)) {
39766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39767 }
39768 arg2 = static_cast< int >(val2);
39769 {
39770 arg3 = wxString_in_helper(obj2);
39771 if (arg3 == NULL) SWIG_fail;
39772 temp3 = true;
39773 }
39774 if (obj3) {
39775 {
39776 arg4 = wxString_in_helper(obj3);
39777 if (arg4 == NULL) SWIG_fail;
39778 temp4 = true;
39779 }
39780 }
39781 {
39782 PyThreadState* __tstate = wxPyBeginAllowThreads();
39783 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39784 wxPyEndAllowThreads(__tstate);
39785 if (PyErr_Occurred()) SWIG_fail;
39786 }
39787 {
39788 resultobj = wxPyMake_wxObject(result, (bool)0);
39789 }
39790 {
39791 if (temp3)
39792 delete arg3;
39793 }
39794 {
39795 if (temp4)
39796 delete arg4;
39797 }
39798 return resultobj;
39799 fail:
39800 {
39801 if (temp3)
39802 delete arg3;
39803 }
39804 {
39805 if (temp4)
39806 delete arg4;
39807 }
39808 return NULL;
39809 }
39810
39811
39812 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39813 PyObject *resultobj = 0;
39814 wxMenu *arg1 = (wxMenu *) 0 ;
39815 int arg2 ;
39816 wxString *arg3 = 0 ;
39817 wxMenu *arg4 = (wxMenu *) 0 ;
39818 wxString const &arg5_defvalue = wxPyEmptyString ;
39819 wxString *arg5 = (wxString *) &arg5_defvalue ;
39820 wxMenuItem *result = 0 ;
39821 void *argp1 = 0 ;
39822 int res1 = 0 ;
39823 int val2 ;
39824 int ecode2 = 0 ;
39825 bool temp3 = false ;
39826 void *argp4 = 0 ;
39827 int res4 = 0 ;
39828 bool temp5 = false ;
39829 PyObject * obj0 = 0 ;
39830 PyObject * obj1 = 0 ;
39831 PyObject * obj2 = 0 ;
39832 PyObject * obj3 = 0 ;
39833 PyObject * obj4 = 0 ;
39834 char * kwnames[] = {
39835 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39836 };
39837
39838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39840 if (!SWIG_IsOK(res1)) {
39841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39842 }
39843 arg1 = reinterpret_cast< wxMenu * >(argp1);
39844 ecode2 = SWIG_AsVal_int(obj1, &val2);
39845 if (!SWIG_IsOK(ecode2)) {
39846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39847 }
39848 arg2 = static_cast< int >(val2);
39849 {
39850 arg3 = wxString_in_helper(obj2);
39851 if (arg3 == NULL) SWIG_fail;
39852 temp3 = true;
39853 }
39854 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39855 if (!SWIG_IsOK(res4)) {
39856 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39857 }
39858 arg4 = reinterpret_cast< wxMenu * >(argp4);
39859 if (obj4) {
39860 {
39861 arg5 = wxString_in_helper(obj4);
39862 if (arg5 == NULL) SWIG_fail;
39863 temp5 = true;
39864 }
39865 }
39866 {
39867 PyThreadState* __tstate = wxPyBeginAllowThreads();
39868 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39869 wxPyEndAllowThreads(__tstate);
39870 if (PyErr_Occurred()) SWIG_fail;
39871 }
39872 {
39873 resultobj = wxPyMake_wxObject(result, (bool)0);
39874 }
39875 {
39876 if (temp3)
39877 delete arg3;
39878 }
39879 {
39880 if (temp5)
39881 delete arg5;
39882 }
39883 return resultobj;
39884 fail:
39885 {
39886 if (temp3)
39887 delete arg3;
39888 }
39889 {
39890 if (temp5)
39891 delete arg5;
39892 }
39893 return NULL;
39894 }
39895
39896
39897 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39898 PyObject *resultobj = 0;
39899 wxMenu *arg1 = (wxMenu *) 0 ;
39900 int arg2 ;
39901 wxMenuItem *result = 0 ;
39902 void *argp1 = 0 ;
39903 int res1 = 0 ;
39904 int val2 ;
39905 int ecode2 = 0 ;
39906 PyObject * obj0 = 0 ;
39907 PyObject * obj1 = 0 ;
39908 char * kwnames[] = {
39909 (char *) "self",(char *) "id", NULL
39910 };
39911
39912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39914 if (!SWIG_IsOK(res1)) {
39915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39916 }
39917 arg1 = reinterpret_cast< wxMenu * >(argp1);
39918 ecode2 = SWIG_AsVal_int(obj1, &val2);
39919 if (!SWIG_IsOK(ecode2)) {
39920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39921 }
39922 arg2 = static_cast< int >(val2);
39923 {
39924 PyThreadState* __tstate = wxPyBeginAllowThreads();
39925 result = (wxMenuItem *)(arg1)->Remove(arg2);
39926 wxPyEndAllowThreads(__tstate);
39927 if (PyErr_Occurred()) SWIG_fail;
39928 }
39929 {
39930 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39931 }
39932 return resultobj;
39933 fail:
39934 return NULL;
39935 }
39936
39937
39938 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39939 PyObject *resultobj = 0;
39940 wxMenu *arg1 = (wxMenu *) 0 ;
39941 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39942 wxMenuItem *result = 0 ;
39943 void *argp1 = 0 ;
39944 int res1 = 0 ;
39945 void *argp2 = 0 ;
39946 int res2 = 0 ;
39947 PyObject * obj0 = 0 ;
39948 PyObject * obj1 = 0 ;
39949 char * kwnames[] = {
39950 (char *) "self",(char *) "item", NULL
39951 };
39952
39953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39955 if (!SWIG_IsOK(res1)) {
39956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39957 }
39958 arg1 = reinterpret_cast< wxMenu * >(argp1);
39959 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39960 if (!SWIG_IsOK(res2)) {
39961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39962 }
39963 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39964 {
39965 PyThreadState* __tstate = wxPyBeginAllowThreads();
39966 result = (wxMenuItem *)(arg1)->Remove(arg2);
39967 wxPyEndAllowThreads(__tstate);
39968 if (PyErr_Occurred()) SWIG_fail;
39969 }
39970 {
39971 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39972 }
39973 return resultobj;
39974 fail:
39975 return NULL;
39976 }
39977
39978
39979 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39980 PyObject *resultobj = 0;
39981 wxMenu *arg1 = (wxMenu *) 0 ;
39982 int arg2 ;
39983 bool result;
39984 void *argp1 = 0 ;
39985 int res1 = 0 ;
39986 int val2 ;
39987 int ecode2 = 0 ;
39988 PyObject * obj0 = 0 ;
39989 PyObject * obj1 = 0 ;
39990 char * kwnames[] = {
39991 (char *) "self",(char *) "id", NULL
39992 };
39993
39994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39996 if (!SWIG_IsOK(res1)) {
39997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39998 }
39999 arg1 = reinterpret_cast< wxMenu * >(argp1);
40000 ecode2 = SWIG_AsVal_int(obj1, &val2);
40001 if (!SWIG_IsOK(ecode2)) {
40002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40003 }
40004 arg2 = static_cast< int >(val2);
40005 {
40006 PyThreadState* __tstate = wxPyBeginAllowThreads();
40007 result = (bool)(arg1)->Delete(arg2);
40008 wxPyEndAllowThreads(__tstate);
40009 if (PyErr_Occurred()) SWIG_fail;
40010 }
40011 {
40012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40013 }
40014 return resultobj;
40015 fail:
40016 return NULL;
40017 }
40018
40019
40020 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40021 PyObject *resultobj = 0;
40022 wxMenu *arg1 = (wxMenu *) 0 ;
40023 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40024 bool result;
40025 void *argp1 = 0 ;
40026 int res1 = 0 ;
40027 void *argp2 = 0 ;
40028 int res2 = 0 ;
40029 PyObject * obj0 = 0 ;
40030 PyObject * obj1 = 0 ;
40031 char * kwnames[] = {
40032 (char *) "self",(char *) "item", NULL
40033 };
40034
40035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40037 if (!SWIG_IsOK(res1)) {
40038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40039 }
40040 arg1 = reinterpret_cast< wxMenu * >(argp1);
40041 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40042 if (!SWIG_IsOK(res2)) {
40043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40044 }
40045 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40046 {
40047 PyThreadState* __tstate = wxPyBeginAllowThreads();
40048 result = (bool)(arg1)->Delete(arg2);
40049 wxPyEndAllowThreads(__tstate);
40050 if (PyErr_Occurred()) SWIG_fail;
40051 }
40052 {
40053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40054 }
40055 return resultobj;
40056 fail:
40057 return NULL;
40058 }
40059
40060
40061 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40062 PyObject *resultobj = 0;
40063 wxMenu *arg1 = (wxMenu *) 0 ;
40064 void *argp1 = 0 ;
40065 int res1 = 0 ;
40066 PyObject *swig_obj[1] ;
40067
40068 if (!args) SWIG_fail;
40069 swig_obj[0] = args;
40070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40071 if (!SWIG_IsOK(res1)) {
40072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40073 }
40074 arg1 = reinterpret_cast< wxMenu * >(argp1);
40075 {
40076 PyThreadState* __tstate = wxPyBeginAllowThreads();
40077 wxMenu_Destroy(arg1);
40078 wxPyEndAllowThreads(__tstate);
40079 if (PyErr_Occurred()) SWIG_fail;
40080 }
40081 resultobj = SWIG_Py_Void();
40082 return resultobj;
40083 fail:
40084 return NULL;
40085 }
40086
40087
40088 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40089 PyObject *resultobj = 0;
40090 wxMenu *arg1 = (wxMenu *) 0 ;
40091 int arg2 ;
40092 bool result;
40093 void *argp1 = 0 ;
40094 int res1 = 0 ;
40095 int val2 ;
40096 int ecode2 = 0 ;
40097 PyObject * obj0 = 0 ;
40098 PyObject * obj1 = 0 ;
40099 char * kwnames[] = {
40100 (char *) "self",(char *) "id", NULL
40101 };
40102
40103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40105 if (!SWIG_IsOK(res1)) {
40106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40107 }
40108 arg1 = reinterpret_cast< wxMenu * >(argp1);
40109 ecode2 = SWIG_AsVal_int(obj1, &val2);
40110 if (!SWIG_IsOK(ecode2)) {
40111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40112 }
40113 arg2 = static_cast< int >(val2);
40114 {
40115 PyThreadState* __tstate = wxPyBeginAllowThreads();
40116 result = (bool)(arg1)->Destroy(arg2);
40117 wxPyEndAllowThreads(__tstate);
40118 if (PyErr_Occurred()) SWIG_fail;
40119 }
40120 {
40121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40122 }
40123 return resultobj;
40124 fail:
40125 return NULL;
40126 }
40127
40128
40129 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40130 PyObject *resultobj = 0;
40131 wxMenu *arg1 = (wxMenu *) 0 ;
40132 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40133 bool result;
40134 void *argp1 = 0 ;
40135 int res1 = 0 ;
40136 void *argp2 = 0 ;
40137 int res2 = 0 ;
40138 PyObject * obj0 = 0 ;
40139 PyObject * obj1 = 0 ;
40140 char * kwnames[] = {
40141 (char *) "self",(char *) "item", NULL
40142 };
40143
40144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40146 if (!SWIG_IsOK(res1)) {
40147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40148 }
40149 arg1 = reinterpret_cast< wxMenu * >(argp1);
40150 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40151 if (!SWIG_IsOK(res2)) {
40152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40153 }
40154 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40155 {
40156 PyThreadState* __tstate = wxPyBeginAllowThreads();
40157 result = (bool)(arg1)->Destroy(arg2);
40158 wxPyEndAllowThreads(__tstate);
40159 if (PyErr_Occurred()) SWIG_fail;
40160 }
40161 {
40162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40163 }
40164 return resultobj;
40165 fail:
40166 return NULL;
40167 }
40168
40169
40170 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40171 PyObject *resultobj = 0;
40172 wxMenu *arg1 = (wxMenu *) 0 ;
40173 size_t result;
40174 void *argp1 = 0 ;
40175 int res1 = 0 ;
40176 PyObject *swig_obj[1] ;
40177
40178 if (!args) SWIG_fail;
40179 swig_obj[0] = args;
40180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40181 if (!SWIG_IsOK(res1)) {
40182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40183 }
40184 arg1 = reinterpret_cast< wxMenu * >(argp1);
40185 {
40186 PyThreadState* __tstate = wxPyBeginAllowThreads();
40187 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40188 wxPyEndAllowThreads(__tstate);
40189 if (PyErr_Occurred()) SWIG_fail;
40190 }
40191 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40192 return resultobj;
40193 fail:
40194 return NULL;
40195 }
40196
40197
40198 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40199 PyObject *resultobj = 0;
40200 wxMenu *arg1 = (wxMenu *) 0 ;
40201 PyObject *result = 0 ;
40202 void *argp1 = 0 ;
40203 int res1 = 0 ;
40204 PyObject *swig_obj[1] ;
40205
40206 if (!args) SWIG_fail;
40207 swig_obj[0] = args;
40208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40209 if (!SWIG_IsOK(res1)) {
40210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40211 }
40212 arg1 = reinterpret_cast< wxMenu * >(argp1);
40213 {
40214 PyThreadState* __tstate = wxPyBeginAllowThreads();
40215 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40216 wxPyEndAllowThreads(__tstate);
40217 if (PyErr_Occurred()) SWIG_fail;
40218 }
40219 resultobj = result;
40220 return resultobj;
40221 fail:
40222 return NULL;
40223 }
40224
40225
40226 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40227 PyObject *resultobj = 0;
40228 wxMenu *arg1 = (wxMenu *) 0 ;
40229 wxString *arg2 = 0 ;
40230 int result;
40231 void *argp1 = 0 ;
40232 int res1 = 0 ;
40233 bool temp2 = false ;
40234 PyObject * obj0 = 0 ;
40235 PyObject * obj1 = 0 ;
40236 char * kwnames[] = {
40237 (char *) "self",(char *) "item", NULL
40238 };
40239
40240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40242 if (!SWIG_IsOK(res1)) {
40243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40244 }
40245 arg1 = reinterpret_cast< wxMenu * >(argp1);
40246 {
40247 arg2 = wxString_in_helper(obj1);
40248 if (arg2 == NULL) SWIG_fail;
40249 temp2 = true;
40250 }
40251 {
40252 PyThreadState* __tstate = wxPyBeginAllowThreads();
40253 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40254 wxPyEndAllowThreads(__tstate);
40255 if (PyErr_Occurred()) SWIG_fail;
40256 }
40257 resultobj = SWIG_From_int(static_cast< int >(result));
40258 {
40259 if (temp2)
40260 delete arg2;
40261 }
40262 return resultobj;
40263 fail:
40264 {
40265 if (temp2)
40266 delete arg2;
40267 }
40268 return NULL;
40269 }
40270
40271
40272 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40273 PyObject *resultobj = 0;
40274 wxMenu *arg1 = (wxMenu *) 0 ;
40275 int arg2 ;
40276 wxMenuItem *result = 0 ;
40277 void *argp1 = 0 ;
40278 int res1 = 0 ;
40279 int val2 ;
40280 int ecode2 = 0 ;
40281 PyObject * obj0 = 0 ;
40282 PyObject * obj1 = 0 ;
40283 char * kwnames[] = {
40284 (char *) "self",(char *) "id", NULL
40285 };
40286
40287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40289 if (!SWIG_IsOK(res1)) {
40290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40291 }
40292 arg1 = reinterpret_cast< wxMenu * >(argp1);
40293 ecode2 = SWIG_AsVal_int(obj1, &val2);
40294 if (!SWIG_IsOK(ecode2)) {
40295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40296 }
40297 arg2 = static_cast< int >(val2);
40298 {
40299 PyThreadState* __tstate = wxPyBeginAllowThreads();
40300 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40301 wxPyEndAllowThreads(__tstate);
40302 if (PyErr_Occurred()) SWIG_fail;
40303 }
40304 {
40305 resultobj = wxPyMake_wxObject(result, (bool)0);
40306 }
40307 return resultobj;
40308 fail:
40309 return NULL;
40310 }
40311
40312
40313 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40314 PyObject *resultobj = 0;
40315 wxMenu *arg1 = (wxMenu *) 0 ;
40316 size_t arg2 ;
40317 wxMenuItem *result = 0 ;
40318 void *argp1 = 0 ;
40319 int res1 = 0 ;
40320 size_t val2 ;
40321 int ecode2 = 0 ;
40322 PyObject * obj0 = 0 ;
40323 PyObject * obj1 = 0 ;
40324 char * kwnames[] = {
40325 (char *) "self",(char *) "position", NULL
40326 };
40327
40328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40330 if (!SWIG_IsOK(res1)) {
40331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40332 }
40333 arg1 = reinterpret_cast< wxMenu * >(argp1);
40334 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40335 if (!SWIG_IsOK(ecode2)) {
40336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40337 }
40338 arg2 = static_cast< size_t >(val2);
40339 {
40340 PyThreadState* __tstate = wxPyBeginAllowThreads();
40341 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40342 wxPyEndAllowThreads(__tstate);
40343 if (PyErr_Occurred()) SWIG_fail;
40344 }
40345 {
40346 resultobj = wxPyMake_wxObject(result, (bool)0);
40347 }
40348 return resultobj;
40349 fail:
40350 return NULL;
40351 }
40352
40353
40354 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40355 PyObject *resultobj = 0;
40356 wxMenu *arg1 = (wxMenu *) 0 ;
40357 int arg2 ;
40358 bool arg3 ;
40359 void *argp1 = 0 ;
40360 int res1 = 0 ;
40361 int val2 ;
40362 int ecode2 = 0 ;
40363 bool val3 ;
40364 int ecode3 = 0 ;
40365 PyObject * obj0 = 0 ;
40366 PyObject * obj1 = 0 ;
40367 PyObject * obj2 = 0 ;
40368 char * kwnames[] = {
40369 (char *) "self",(char *) "id",(char *) "enable", NULL
40370 };
40371
40372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40374 if (!SWIG_IsOK(res1)) {
40375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40376 }
40377 arg1 = reinterpret_cast< wxMenu * >(argp1);
40378 ecode2 = SWIG_AsVal_int(obj1, &val2);
40379 if (!SWIG_IsOK(ecode2)) {
40380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40381 }
40382 arg2 = static_cast< int >(val2);
40383 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40384 if (!SWIG_IsOK(ecode3)) {
40385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40386 }
40387 arg3 = static_cast< bool >(val3);
40388 {
40389 PyThreadState* __tstate = wxPyBeginAllowThreads();
40390 (arg1)->Enable(arg2,arg3);
40391 wxPyEndAllowThreads(__tstate);
40392 if (PyErr_Occurred()) SWIG_fail;
40393 }
40394 resultobj = SWIG_Py_Void();
40395 return resultobj;
40396 fail:
40397 return NULL;
40398 }
40399
40400
40401 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40402 PyObject *resultobj = 0;
40403 wxMenu *arg1 = (wxMenu *) 0 ;
40404 int arg2 ;
40405 bool result;
40406 void *argp1 = 0 ;
40407 int res1 = 0 ;
40408 int val2 ;
40409 int ecode2 = 0 ;
40410 PyObject * obj0 = 0 ;
40411 PyObject * obj1 = 0 ;
40412 char * kwnames[] = {
40413 (char *) "self",(char *) "id", NULL
40414 };
40415
40416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",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_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40420 }
40421 arg1 = reinterpret_cast< wxMenu * >(argp1);
40422 ecode2 = SWIG_AsVal_int(obj1, &val2);
40423 if (!SWIG_IsOK(ecode2)) {
40424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40425 }
40426 arg2 = static_cast< int >(val2);
40427 {
40428 PyThreadState* __tstate = wxPyBeginAllowThreads();
40429 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40430 wxPyEndAllowThreads(__tstate);
40431 if (PyErr_Occurred()) SWIG_fail;
40432 }
40433 {
40434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40435 }
40436 return resultobj;
40437 fail:
40438 return NULL;
40439 }
40440
40441
40442 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40443 PyObject *resultobj = 0;
40444 wxMenu *arg1 = (wxMenu *) 0 ;
40445 int arg2 ;
40446 bool arg3 ;
40447 void *argp1 = 0 ;
40448 int res1 = 0 ;
40449 int val2 ;
40450 int ecode2 = 0 ;
40451 bool val3 ;
40452 int ecode3 = 0 ;
40453 PyObject * obj0 = 0 ;
40454 PyObject * obj1 = 0 ;
40455 PyObject * obj2 = 0 ;
40456 char * kwnames[] = {
40457 (char *) "self",(char *) "id",(char *) "check", NULL
40458 };
40459
40460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40462 if (!SWIG_IsOK(res1)) {
40463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40464 }
40465 arg1 = reinterpret_cast< wxMenu * >(argp1);
40466 ecode2 = SWIG_AsVal_int(obj1, &val2);
40467 if (!SWIG_IsOK(ecode2)) {
40468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40469 }
40470 arg2 = static_cast< int >(val2);
40471 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40472 if (!SWIG_IsOK(ecode3)) {
40473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40474 }
40475 arg3 = static_cast< bool >(val3);
40476 {
40477 PyThreadState* __tstate = wxPyBeginAllowThreads();
40478 (arg1)->Check(arg2,arg3);
40479 wxPyEndAllowThreads(__tstate);
40480 if (PyErr_Occurred()) SWIG_fail;
40481 }
40482 resultobj = SWIG_Py_Void();
40483 return resultobj;
40484 fail:
40485 return NULL;
40486 }
40487
40488
40489 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40490 PyObject *resultobj = 0;
40491 wxMenu *arg1 = (wxMenu *) 0 ;
40492 int arg2 ;
40493 bool result;
40494 void *argp1 = 0 ;
40495 int res1 = 0 ;
40496 int val2 ;
40497 int ecode2 = 0 ;
40498 PyObject * obj0 = 0 ;
40499 PyObject * obj1 = 0 ;
40500 char * kwnames[] = {
40501 (char *) "self",(char *) "id", NULL
40502 };
40503
40504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40506 if (!SWIG_IsOK(res1)) {
40507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40508 }
40509 arg1 = reinterpret_cast< wxMenu * >(argp1);
40510 ecode2 = SWIG_AsVal_int(obj1, &val2);
40511 if (!SWIG_IsOK(ecode2)) {
40512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40513 }
40514 arg2 = static_cast< int >(val2);
40515 {
40516 PyThreadState* __tstate = wxPyBeginAllowThreads();
40517 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 {
40522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40523 }
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40531 PyObject *resultobj = 0;
40532 wxMenu *arg1 = (wxMenu *) 0 ;
40533 int arg2 ;
40534 wxString *arg3 = 0 ;
40535 void *argp1 = 0 ;
40536 int res1 = 0 ;
40537 int val2 ;
40538 int ecode2 = 0 ;
40539 bool temp3 = false ;
40540 PyObject * obj0 = 0 ;
40541 PyObject * obj1 = 0 ;
40542 PyObject * obj2 = 0 ;
40543 char * kwnames[] = {
40544 (char *) "self",(char *) "id",(char *) "label", NULL
40545 };
40546
40547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40549 if (!SWIG_IsOK(res1)) {
40550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40551 }
40552 arg1 = reinterpret_cast< wxMenu * >(argp1);
40553 ecode2 = SWIG_AsVal_int(obj1, &val2);
40554 if (!SWIG_IsOK(ecode2)) {
40555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40556 }
40557 arg2 = static_cast< int >(val2);
40558 {
40559 arg3 = wxString_in_helper(obj2);
40560 if (arg3 == NULL) SWIG_fail;
40561 temp3 = true;
40562 }
40563 {
40564 PyThreadState* __tstate = wxPyBeginAllowThreads();
40565 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40566 wxPyEndAllowThreads(__tstate);
40567 if (PyErr_Occurred()) SWIG_fail;
40568 }
40569 resultobj = SWIG_Py_Void();
40570 {
40571 if (temp3)
40572 delete arg3;
40573 }
40574 return resultobj;
40575 fail:
40576 {
40577 if (temp3)
40578 delete arg3;
40579 }
40580 return NULL;
40581 }
40582
40583
40584 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40585 PyObject *resultobj = 0;
40586 wxMenu *arg1 = (wxMenu *) 0 ;
40587 int arg2 ;
40588 wxString result;
40589 void *argp1 = 0 ;
40590 int res1 = 0 ;
40591 int val2 ;
40592 int ecode2 = 0 ;
40593 PyObject * obj0 = 0 ;
40594 PyObject * obj1 = 0 ;
40595 char * kwnames[] = {
40596 (char *) "self",(char *) "id", NULL
40597 };
40598
40599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40601 if (!SWIG_IsOK(res1)) {
40602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40603 }
40604 arg1 = reinterpret_cast< wxMenu * >(argp1);
40605 ecode2 = SWIG_AsVal_int(obj1, &val2);
40606 if (!SWIG_IsOK(ecode2)) {
40607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40608 }
40609 arg2 = static_cast< int >(val2);
40610 {
40611 PyThreadState* __tstate = wxPyBeginAllowThreads();
40612 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40613 wxPyEndAllowThreads(__tstate);
40614 if (PyErr_Occurred()) SWIG_fail;
40615 }
40616 {
40617 #if wxUSE_UNICODE
40618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40619 #else
40620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40621 #endif
40622 }
40623 return resultobj;
40624 fail:
40625 return NULL;
40626 }
40627
40628
40629 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40630 PyObject *resultobj = 0;
40631 wxMenu *arg1 = (wxMenu *) 0 ;
40632 int arg2 ;
40633 wxString *arg3 = 0 ;
40634 void *argp1 = 0 ;
40635 int res1 = 0 ;
40636 int val2 ;
40637 int ecode2 = 0 ;
40638 bool temp3 = false ;
40639 PyObject * obj0 = 0 ;
40640 PyObject * obj1 = 0 ;
40641 PyObject * obj2 = 0 ;
40642 char * kwnames[] = {
40643 (char *) "self",(char *) "id",(char *) "helpString", NULL
40644 };
40645
40646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40648 if (!SWIG_IsOK(res1)) {
40649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40650 }
40651 arg1 = reinterpret_cast< wxMenu * >(argp1);
40652 ecode2 = SWIG_AsVal_int(obj1, &val2);
40653 if (!SWIG_IsOK(ecode2)) {
40654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40655 }
40656 arg2 = static_cast< int >(val2);
40657 {
40658 arg3 = wxString_in_helper(obj2);
40659 if (arg3 == NULL) SWIG_fail;
40660 temp3 = true;
40661 }
40662 {
40663 PyThreadState* __tstate = wxPyBeginAllowThreads();
40664 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40665 wxPyEndAllowThreads(__tstate);
40666 if (PyErr_Occurred()) SWIG_fail;
40667 }
40668 resultobj = SWIG_Py_Void();
40669 {
40670 if (temp3)
40671 delete arg3;
40672 }
40673 return resultobj;
40674 fail:
40675 {
40676 if (temp3)
40677 delete arg3;
40678 }
40679 return NULL;
40680 }
40681
40682
40683 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40684 PyObject *resultobj = 0;
40685 wxMenu *arg1 = (wxMenu *) 0 ;
40686 int arg2 ;
40687 wxString result;
40688 void *argp1 = 0 ;
40689 int res1 = 0 ;
40690 int val2 ;
40691 int ecode2 = 0 ;
40692 PyObject * obj0 = 0 ;
40693 PyObject * obj1 = 0 ;
40694 char * kwnames[] = {
40695 (char *) "self",(char *) "id", NULL
40696 };
40697
40698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40700 if (!SWIG_IsOK(res1)) {
40701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40702 }
40703 arg1 = reinterpret_cast< wxMenu * >(argp1);
40704 ecode2 = SWIG_AsVal_int(obj1, &val2);
40705 if (!SWIG_IsOK(ecode2)) {
40706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40707 }
40708 arg2 = static_cast< int >(val2);
40709 {
40710 PyThreadState* __tstate = wxPyBeginAllowThreads();
40711 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40712 wxPyEndAllowThreads(__tstate);
40713 if (PyErr_Occurred()) SWIG_fail;
40714 }
40715 {
40716 #if wxUSE_UNICODE
40717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40718 #else
40719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40720 #endif
40721 }
40722 return resultobj;
40723 fail:
40724 return NULL;
40725 }
40726
40727
40728 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40729 PyObject *resultobj = 0;
40730 wxMenu *arg1 = (wxMenu *) 0 ;
40731 wxString *arg2 = 0 ;
40732 void *argp1 = 0 ;
40733 int res1 = 0 ;
40734 bool temp2 = false ;
40735 PyObject * obj0 = 0 ;
40736 PyObject * obj1 = 0 ;
40737 char * kwnames[] = {
40738 (char *) "self",(char *) "title", NULL
40739 };
40740
40741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40743 if (!SWIG_IsOK(res1)) {
40744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40745 }
40746 arg1 = reinterpret_cast< wxMenu * >(argp1);
40747 {
40748 arg2 = wxString_in_helper(obj1);
40749 if (arg2 == NULL) SWIG_fail;
40750 temp2 = true;
40751 }
40752 {
40753 PyThreadState* __tstate = wxPyBeginAllowThreads();
40754 (arg1)->SetTitle((wxString const &)*arg2);
40755 wxPyEndAllowThreads(__tstate);
40756 if (PyErr_Occurred()) SWIG_fail;
40757 }
40758 resultobj = SWIG_Py_Void();
40759 {
40760 if (temp2)
40761 delete arg2;
40762 }
40763 return resultobj;
40764 fail:
40765 {
40766 if (temp2)
40767 delete arg2;
40768 }
40769 return NULL;
40770 }
40771
40772
40773 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40774 PyObject *resultobj = 0;
40775 wxMenu *arg1 = (wxMenu *) 0 ;
40776 wxString result;
40777 void *argp1 = 0 ;
40778 int res1 = 0 ;
40779 PyObject *swig_obj[1] ;
40780
40781 if (!args) SWIG_fail;
40782 swig_obj[0] = args;
40783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40784 if (!SWIG_IsOK(res1)) {
40785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40786 }
40787 arg1 = reinterpret_cast< wxMenu * >(argp1);
40788 {
40789 PyThreadState* __tstate = wxPyBeginAllowThreads();
40790 result = ((wxMenu const *)arg1)->GetTitle();
40791 wxPyEndAllowThreads(__tstate);
40792 if (PyErr_Occurred()) SWIG_fail;
40793 }
40794 {
40795 #if wxUSE_UNICODE
40796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40797 #else
40798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40799 #endif
40800 }
40801 return resultobj;
40802 fail:
40803 return NULL;
40804 }
40805
40806
40807 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40808 PyObject *resultobj = 0;
40809 wxMenu *arg1 = (wxMenu *) 0 ;
40810 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40811 void *argp1 = 0 ;
40812 int res1 = 0 ;
40813 void *argp2 = 0 ;
40814 int res2 = 0 ;
40815 PyObject * obj0 = 0 ;
40816 PyObject * obj1 = 0 ;
40817 char * kwnames[] = {
40818 (char *) "self",(char *) "handler", NULL
40819 };
40820
40821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40823 if (!SWIG_IsOK(res1)) {
40824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40825 }
40826 arg1 = reinterpret_cast< wxMenu * >(argp1);
40827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40828 if (!SWIG_IsOK(res2)) {
40829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40830 }
40831 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40832 {
40833 PyThreadState* __tstate = wxPyBeginAllowThreads();
40834 (arg1)->SetEventHandler(arg2);
40835 wxPyEndAllowThreads(__tstate);
40836 if (PyErr_Occurred()) SWIG_fail;
40837 }
40838 resultobj = SWIG_Py_Void();
40839 return resultobj;
40840 fail:
40841 return NULL;
40842 }
40843
40844
40845 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40846 PyObject *resultobj = 0;
40847 wxMenu *arg1 = (wxMenu *) 0 ;
40848 wxEvtHandler *result = 0 ;
40849 void *argp1 = 0 ;
40850 int res1 = 0 ;
40851 PyObject *swig_obj[1] ;
40852
40853 if (!args) SWIG_fail;
40854 swig_obj[0] = args;
40855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40856 if (!SWIG_IsOK(res1)) {
40857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40858 }
40859 arg1 = reinterpret_cast< wxMenu * >(argp1);
40860 {
40861 PyThreadState* __tstate = wxPyBeginAllowThreads();
40862 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40863 wxPyEndAllowThreads(__tstate);
40864 if (PyErr_Occurred()) SWIG_fail;
40865 }
40866 {
40867 resultobj = wxPyMake_wxObject(result, 0);
40868 }
40869 return resultobj;
40870 fail:
40871 return NULL;
40872 }
40873
40874
40875 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40876 PyObject *resultobj = 0;
40877 wxMenu *arg1 = (wxMenu *) 0 ;
40878 wxWindow *arg2 = (wxWindow *) 0 ;
40879 void *argp1 = 0 ;
40880 int res1 = 0 ;
40881 void *argp2 = 0 ;
40882 int res2 = 0 ;
40883 PyObject * obj0 = 0 ;
40884 PyObject * obj1 = 0 ;
40885 char * kwnames[] = {
40886 (char *) "self",(char *) "win", NULL
40887 };
40888
40889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40891 if (!SWIG_IsOK(res1)) {
40892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40893 }
40894 arg1 = reinterpret_cast< wxMenu * >(argp1);
40895 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40896 if (!SWIG_IsOK(res2)) {
40897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40898 }
40899 arg2 = reinterpret_cast< wxWindow * >(argp2);
40900 {
40901 PyThreadState* __tstate = wxPyBeginAllowThreads();
40902 (arg1)->SetInvokingWindow(arg2);
40903 wxPyEndAllowThreads(__tstate);
40904 if (PyErr_Occurred()) SWIG_fail;
40905 }
40906 resultobj = SWIG_Py_Void();
40907 return resultobj;
40908 fail:
40909 return NULL;
40910 }
40911
40912
40913 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40914 PyObject *resultobj = 0;
40915 wxMenu *arg1 = (wxMenu *) 0 ;
40916 wxWindow *result = 0 ;
40917 void *argp1 = 0 ;
40918 int res1 = 0 ;
40919 PyObject *swig_obj[1] ;
40920
40921 if (!args) SWIG_fail;
40922 swig_obj[0] = args;
40923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40924 if (!SWIG_IsOK(res1)) {
40925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40926 }
40927 arg1 = reinterpret_cast< wxMenu * >(argp1);
40928 {
40929 PyThreadState* __tstate = wxPyBeginAllowThreads();
40930 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40931 wxPyEndAllowThreads(__tstate);
40932 if (PyErr_Occurred()) SWIG_fail;
40933 }
40934 {
40935 resultobj = wxPyMake_wxObject(result, 0);
40936 }
40937 return resultobj;
40938 fail:
40939 return NULL;
40940 }
40941
40942
40943 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40944 PyObject *resultobj = 0;
40945 wxMenu *arg1 = (wxMenu *) 0 ;
40946 long result;
40947 void *argp1 = 0 ;
40948 int res1 = 0 ;
40949 PyObject *swig_obj[1] ;
40950
40951 if (!args) SWIG_fail;
40952 swig_obj[0] = args;
40953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40954 if (!SWIG_IsOK(res1)) {
40955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40956 }
40957 arg1 = reinterpret_cast< wxMenu * >(argp1);
40958 {
40959 PyThreadState* __tstate = wxPyBeginAllowThreads();
40960 result = (long)((wxMenu const *)arg1)->GetStyle();
40961 wxPyEndAllowThreads(__tstate);
40962 if (PyErr_Occurred()) SWIG_fail;
40963 }
40964 resultobj = SWIG_From_long(static_cast< long >(result));
40965 return resultobj;
40966 fail:
40967 return NULL;
40968 }
40969
40970
40971 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40972 PyObject *resultobj = 0;
40973 wxMenu *arg1 = (wxMenu *) 0 ;
40974 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40975 void *argp1 = 0 ;
40976 int res1 = 0 ;
40977 void *argp2 = 0 ;
40978 int res2 = 0 ;
40979 PyObject * obj0 = 0 ;
40980 PyObject * obj1 = 0 ;
40981 char * kwnames[] = {
40982 (char *) "self",(char *) "source", NULL
40983 };
40984
40985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40987 if (!SWIG_IsOK(res1)) {
40988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40989 }
40990 arg1 = reinterpret_cast< wxMenu * >(argp1);
40991 if (obj1) {
40992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40993 if (!SWIG_IsOK(res2)) {
40994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40995 }
40996 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40997 }
40998 {
40999 PyThreadState* __tstate = wxPyBeginAllowThreads();
41000 (arg1)->UpdateUI(arg2);
41001 wxPyEndAllowThreads(__tstate);
41002 if (PyErr_Occurred()) SWIG_fail;
41003 }
41004 resultobj = SWIG_Py_Void();
41005 return resultobj;
41006 fail:
41007 return NULL;
41008 }
41009
41010
41011 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41012 PyObject *resultobj = 0;
41013 wxMenu *arg1 = (wxMenu *) 0 ;
41014 wxMenuBar *result = 0 ;
41015 void *argp1 = 0 ;
41016 int res1 = 0 ;
41017 PyObject *swig_obj[1] ;
41018
41019 if (!args) SWIG_fail;
41020 swig_obj[0] = args;
41021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41022 if (!SWIG_IsOK(res1)) {
41023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41024 }
41025 arg1 = reinterpret_cast< wxMenu * >(argp1);
41026 {
41027 PyThreadState* __tstate = wxPyBeginAllowThreads();
41028 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41029 wxPyEndAllowThreads(__tstate);
41030 if (PyErr_Occurred()) SWIG_fail;
41031 }
41032 {
41033 resultobj = wxPyMake_wxObject(result, (bool)0);
41034 }
41035 return resultobj;
41036 fail:
41037 return NULL;
41038 }
41039
41040
41041 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41042 PyObject *resultobj = 0;
41043 wxMenu *arg1 = (wxMenu *) 0 ;
41044 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41045 void *argp1 = 0 ;
41046 int res1 = 0 ;
41047 void *argp2 = 0 ;
41048 int res2 = 0 ;
41049 PyObject * obj0 = 0 ;
41050 PyObject * obj1 = 0 ;
41051 char * kwnames[] = {
41052 (char *) "self",(char *) "menubar", NULL
41053 };
41054
41055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41057 if (!SWIG_IsOK(res1)) {
41058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41059 }
41060 arg1 = reinterpret_cast< wxMenu * >(argp1);
41061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41062 if (!SWIG_IsOK(res2)) {
41063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41064 }
41065 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41066 {
41067 PyThreadState* __tstate = wxPyBeginAllowThreads();
41068 (arg1)->Attach(arg2);
41069 wxPyEndAllowThreads(__tstate);
41070 if (PyErr_Occurred()) SWIG_fail;
41071 }
41072 resultobj = SWIG_Py_Void();
41073 return resultobj;
41074 fail:
41075 return NULL;
41076 }
41077
41078
41079 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41080 PyObject *resultobj = 0;
41081 wxMenu *arg1 = (wxMenu *) 0 ;
41082 void *argp1 = 0 ;
41083 int res1 = 0 ;
41084 PyObject *swig_obj[1] ;
41085
41086 if (!args) SWIG_fail;
41087 swig_obj[0] = args;
41088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41089 if (!SWIG_IsOK(res1)) {
41090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41091 }
41092 arg1 = reinterpret_cast< wxMenu * >(argp1);
41093 {
41094 PyThreadState* __tstate = wxPyBeginAllowThreads();
41095 (arg1)->Detach();
41096 wxPyEndAllowThreads(__tstate);
41097 if (PyErr_Occurred()) SWIG_fail;
41098 }
41099 resultobj = SWIG_Py_Void();
41100 return resultobj;
41101 fail:
41102 return NULL;
41103 }
41104
41105
41106 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41107 PyObject *resultobj = 0;
41108 wxMenu *arg1 = (wxMenu *) 0 ;
41109 bool result;
41110 void *argp1 = 0 ;
41111 int res1 = 0 ;
41112 PyObject *swig_obj[1] ;
41113
41114 if (!args) SWIG_fail;
41115 swig_obj[0] = args;
41116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41117 if (!SWIG_IsOK(res1)) {
41118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41119 }
41120 arg1 = reinterpret_cast< wxMenu * >(argp1);
41121 {
41122 PyThreadState* __tstate = wxPyBeginAllowThreads();
41123 result = (bool)((wxMenu const *)arg1)->IsAttached();
41124 wxPyEndAllowThreads(__tstate);
41125 if (PyErr_Occurred()) SWIG_fail;
41126 }
41127 {
41128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41129 }
41130 return resultobj;
41131 fail:
41132 return NULL;
41133 }
41134
41135
41136 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41137 PyObject *resultobj = 0;
41138 wxMenu *arg1 = (wxMenu *) 0 ;
41139 wxMenu *arg2 = (wxMenu *) 0 ;
41140 void *argp1 = 0 ;
41141 int res1 = 0 ;
41142 void *argp2 = 0 ;
41143 int res2 = 0 ;
41144 PyObject * obj0 = 0 ;
41145 PyObject * obj1 = 0 ;
41146 char * kwnames[] = {
41147 (char *) "self",(char *) "parent", NULL
41148 };
41149
41150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41152 if (!SWIG_IsOK(res1)) {
41153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41154 }
41155 arg1 = reinterpret_cast< wxMenu * >(argp1);
41156 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41157 if (!SWIG_IsOK(res2)) {
41158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41159 }
41160 arg2 = reinterpret_cast< wxMenu * >(argp2);
41161 {
41162 PyThreadState* __tstate = wxPyBeginAllowThreads();
41163 (arg1)->SetParent(arg2);
41164 wxPyEndAllowThreads(__tstate);
41165 if (PyErr_Occurred()) SWIG_fail;
41166 }
41167 resultobj = SWIG_Py_Void();
41168 return resultobj;
41169 fail:
41170 return NULL;
41171 }
41172
41173
41174 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41175 PyObject *resultobj = 0;
41176 wxMenu *arg1 = (wxMenu *) 0 ;
41177 wxMenu *result = 0 ;
41178 void *argp1 = 0 ;
41179 int res1 = 0 ;
41180 PyObject *swig_obj[1] ;
41181
41182 if (!args) SWIG_fail;
41183 swig_obj[0] = args;
41184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41185 if (!SWIG_IsOK(res1)) {
41186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41187 }
41188 arg1 = reinterpret_cast< wxMenu * >(argp1);
41189 {
41190 PyThreadState* __tstate = wxPyBeginAllowThreads();
41191 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41192 wxPyEndAllowThreads(__tstate);
41193 if (PyErr_Occurred()) SWIG_fail;
41194 }
41195 {
41196 resultobj = wxPyMake_wxObject(result, 0);
41197 }
41198 return resultobj;
41199 fail:
41200 return NULL;
41201 }
41202
41203
41204 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41205 PyObject *obj;
41206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41207 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41208 return SWIG_Py_Void();
41209 }
41210
41211 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41212 return SWIG_Python_InitShadowInstance(args);
41213 }
41214
41215 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41216 PyObject *resultobj = 0;
41217 long arg1 = (long) 0 ;
41218 wxMenuBar *result = 0 ;
41219 long val1 ;
41220 int ecode1 = 0 ;
41221 PyObject * obj0 = 0 ;
41222 char * kwnames[] = {
41223 (char *) "style", NULL
41224 };
41225
41226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41227 if (obj0) {
41228 ecode1 = SWIG_AsVal_long(obj0, &val1);
41229 if (!SWIG_IsOK(ecode1)) {
41230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41231 }
41232 arg1 = static_cast< long >(val1);
41233 }
41234 {
41235 if (!wxPyCheckForApp()) SWIG_fail;
41236 PyThreadState* __tstate = wxPyBeginAllowThreads();
41237 result = (wxMenuBar *)new wxMenuBar(arg1);
41238 wxPyEndAllowThreads(__tstate);
41239 if (PyErr_Occurred()) SWIG_fail;
41240 }
41241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41242 return resultobj;
41243 fail:
41244 return NULL;
41245 }
41246
41247
41248 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41249 PyObject *resultobj = 0;
41250 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41251 wxMenu *arg2 = (wxMenu *) 0 ;
41252 wxString *arg3 = 0 ;
41253 bool result;
41254 void *argp1 = 0 ;
41255 int res1 = 0 ;
41256 void *argp2 = 0 ;
41257 int res2 = 0 ;
41258 bool temp3 = false ;
41259 PyObject * obj0 = 0 ;
41260 PyObject * obj1 = 0 ;
41261 PyObject * obj2 = 0 ;
41262 char * kwnames[] = {
41263 (char *) "self",(char *) "menu",(char *) "title", NULL
41264 };
41265
41266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41268 if (!SWIG_IsOK(res1)) {
41269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41270 }
41271 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41273 if (!SWIG_IsOK(res2)) {
41274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41275 }
41276 arg2 = reinterpret_cast< wxMenu * >(argp2);
41277 {
41278 arg3 = wxString_in_helper(obj2);
41279 if (arg3 == NULL) SWIG_fail;
41280 temp3 = true;
41281 }
41282 {
41283 PyThreadState* __tstate = wxPyBeginAllowThreads();
41284 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41285 wxPyEndAllowThreads(__tstate);
41286 if (PyErr_Occurred()) SWIG_fail;
41287 }
41288 {
41289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41290 }
41291 {
41292 if (temp3)
41293 delete arg3;
41294 }
41295 return resultobj;
41296 fail:
41297 {
41298 if (temp3)
41299 delete arg3;
41300 }
41301 return NULL;
41302 }
41303
41304
41305 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41306 PyObject *resultobj = 0;
41307 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41308 size_t arg2 ;
41309 wxMenu *arg3 = (wxMenu *) 0 ;
41310 wxString *arg4 = 0 ;
41311 bool result;
41312 void *argp1 = 0 ;
41313 int res1 = 0 ;
41314 size_t val2 ;
41315 int ecode2 = 0 ;
41316 void *argp3 = 0 ;
41317 int res3 = 0 ;
41318 bool temp4 = false ;
41319 PyObject * obj0 = 0 ;
41320 PyObject * obj1 = 0 ;
41321 PyObject * obj2 = 0 ;
41322 PyObject * obj3 = 0 ;
41323 char * kwnames[] = {
41324 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41325 };
41326
41327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41329 if (!SWIG_IsOK(res1)) {
41330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41331 }
41332 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41333 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41334 if (!SWIG_IsOK(ecode2)) {
41335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41336 }
41337 arg2 = static_cast< size_t >(val2);
41338 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41339 if (!SWIG_IsOK(res3)) {
41340 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41341 }
41342 arg3 = reinterpret_cast< wxMenu * >(argp3);
41343 {
41344 arg4 = wxString_in_helper(obj3);
41345 if (arg4 == NULL) SWIG_fail;
41346 temp4 = true;
41347 }
41348 {
41349 PyThreadState* __tstate = wxPyBeginAllowThreads();
41350 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41351 wxPyEndAllowThreads(__tstate);
41352 if (PyErr_Occurred()) SWIG_fail;
41353 }
41354 {
41355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41356 }
41357 {
41358 if (temp4)
41359 delete arg4;
41360 }
41361 return resultobj;
41362 fail:
41363 {
41364 if (temp4)
41365 delete arg4;
41366 }
41367 return NULL;
41368 }
41369
41370
41371 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41372 PyObject *resultobj = 0;
41373 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41374 size_t result;
41375 void *argp1 = 0 ;
41376 int res1 = 0 ;
41377 PyObject *swig_obj[1] ;
41378
41379 if (!args) SWIG_fail;
41380 swig_obj[0] = args;
41381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41382 if (!SWIG_IsOK(res1)) {
41383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41384 }
41385 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41386 {
41387 PyThreadState* __tstate = wxPyBeginAllowThreads();
41388 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41389 wxPyEndAllowThreads(__tstate);
41390 if (PyErr_Occurred()) SWIG_fail;
41391 }
41392 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41393 return resultobj;
41394 fail:
41395 return NULL;
41396 }
41397
41398
41399 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41400 PyObject *resultobj = 0;
41401 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41402 size_t arg2 ;
41403 wxMenu *result = 0 ;
41404 void *argp1 = 0 ;
41405 int res1 = 0 ;
41406 size_t val2 ;
41407 int ecode2 = 0 ;
41408 PyObject * obj0 = 0 ;
41409 PyObject * obj1 = 0 ;
41410 char * kwnames[] = {
41411 (char *) "self",(char *) "pos", NULL
41412 };
41413
41414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41416 if (!SWIG_IsOK(res1)) {
41417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41418 }
41419 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41420 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41421 if (!SWIG_IsOK(ecode2)) {
41422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41423 }
41424 arg2 = static_cast< size_t >(val2);
41425 {
41426 PyThreadState* __tstate = wxPyBeginAllowThreads();
41427 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41428 wxPyEndAllowThreads(__tstate);
41429 if (PyErr_Occurred()) SWIG_fail;
41430 }
41431 {
41432 resultobj = wxPyMake_wxObject(result, 0);
41433 }
41434 return resultobj;
41435 fail:
41436 return NULL;
41437 }
41438
41439
41440 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41441 PyObject *resultobj = 0;
41442 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41443 size_t arg2 ;
41444 wxMenu *arg3 = (wxMenu *) 0 ;
41445 wxString *arg4 = 0 ;
41446 wxMenu *result = 0 ;
41447 void *argp1 = 0 ;
41448 int res1 = 0 ;
41449 size_t val2 ;
41450 int ecode2 = 0 ;
41451 void *argp3 = 0 ;
41452 int res3 = 0 ;
41453 bool temp4 = false ;
41454 PyObject * obj0 = 0 ;
41455 PyObject * obj1 = 0 ;
41456 PyObject * obj2 = 0 ;
41457 PyObject * obj3 = 0 ;
41458 char * kwnames[] = {
41459 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41460 };
41461
41462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41464 if (!SWIG_IsOK(res1)) {
41465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41466 }
41467 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41468 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41469 if (!SWIG_IsOK(ecode2)) {
41470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41471 }
41472 arg2 = static_cast< size_t >(val2);
41473 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41474 if (!SWIG_IsOK(res3)) {
41475 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41476 }
41477 arg3 = reinterpret_cast< wxMenu * >(argp3);
41478 {
41479 arg4 = wxString_in_helper(obj3);
41480 if (arg4 == NULL) SWIG_fail;
41481 temp4 = true;
41482 }
41483 {
41484 PyThreadState* __tstate = wxPyBeginAllowThreads();
41485 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41486 wxPyEndAllowThreads(__tstate);
41487 if (PyErr_Occurred()) SWIG_fail;
41488 }
41489 {
41490 resultobj = wxPyMake_wxObject(result, 0);
41491 }
41492 {
41493 if (temp4)
41494 delete arg4;
41495 }
41496 return resultobj;
41497 fail:
41498 {
41499 if (temp4)
41500 delete arg4;
41501 }
41502 return NULL;
41503 }
41504
41505
41506 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41507 PyObject *resultobj = 0;
41508 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41509 size_t arg2 ;
41510 wxMenu *result = 0 ;
41511 void *argp1 = 0 ;
41512 int res1 = 0 ;
41513 size_t val2 ;
41514 int ecode2 = 0 ;
41515 PyObject * obj0 = 0 ;
41516 PyObject * obj1 = 0 ;
41517 char * kwnames[] = {
41518 (char *) "self",(char *) "pos", NULL
41519 };
41520
41521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41523 if (!SWIG_IsOK(res1)) {
41524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41525 }
41526 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41527 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41528 if (!SWIG_IsOK(ecode2)) {
41529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41530 }
41531 arg2 = static_cast< size_t >(val2);
41532 {
41533 PyThreadState* __tstate = wxPyBeginAllowThreads();
41534 result = (wxMenu *)(arg1)->Remove(arg2);
41535 wxPyEndAllowThreads(__tstate);
41536 if (PyErr_Occurred()) SWIG_fail;
41537 }
41538 {
41539 resultobj = wxPyMake_wxObject(result, 0);
41540 }
41541 return resultobj;
41542 fail:
41543 return NULL;
41544 }
41545
41546
41547 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41548 PyObject *resultobj = 0;
41549 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41550 size_t arg2 ;
41551 bool arg3 ;
41552 void *argp1 = 0 ;
41553 int res1 = 0 ;
41554 size_t val2 ;
41555 int ecode2 = 0 ;
41556 bool val3 ;
41557 int ecode3 = 0 ;
41558 PyObject * obj0 = 0 ;
41559 PyObject * obj1 = 0 ;
41560 PyObject * obj2 = 0 ;
41561 char * kwnames[] = {
41562 (char *) "self",(char *) "pos",(char *) "enable", NULL
41563 };
41564
41565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41567 if (!SWIG_IsOK(res1)) {
41568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41569 }
41570 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41571 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41572 if (!SWIG_IsOK(ecode2)) {
41573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41574 }
41575 arg2 = static_cast< size_t >(val2);
41576 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41577 if (!SWIG_IsOK(ecode3)) {
41578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41579 }
41580 arg3 = static_cast< bool >(val3);
41581 {
41582 PyThreadState* __tstate = wxPyBeginAllowThreads();
41583 (arg1)->EnableTop(arg2,arg3);
41584 wxPyEndAllowThreads(__tstate);
41585 if (PyErr_Occurred()) SWIG_fail;
41586 }
41587 resultobj = SWIG_Py_Void();
41588 return resultobj;
41589 fail:
41590 return NULL;
41591 }
41592
41593
41594 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41595 PyObject *resultobj = 0;
41596 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41597 size_t arg2 ;
41598 bool result;
41599 void *argp1 = 0 ;
41600 int res1 = 0 ;
41601 size_t val2 ;
41602 int ecode2 = 0 ;
41603 PyObject * obj0 = 0 ;
41604 PyObject * obj1 = 0 ;
41605 char * kwnames[] = {
41606 (char *) "self",(char *) "pos", NULL
41607 };
41608
41609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41611 if (!SWIG_IsOK(res1)) {
41612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41613 }
41614 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41615 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41616 if (!SWIG_IsOK(ecode2)) {
41617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41618 }
41619 arg2 = static_cast< size_t >(val2);
41620 {
41621 PyThreadState* __tstate = wxPyBeginAllowThreads();
41622 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41623 wxPyEndAllowThreads(__tstate);
41624 if (PyErr_Occurred()) SWIG_fail;
41625 }
41626 {
41627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41628 }
41629 return resultobj;
41630 fail:
41631 return NULL;
41632 }
41633
41634
41635 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41636 PyObject *resultobj = 0;
41637 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41638 size_t arg2 ;
41639 wxString *arg3 = 0 ;
41640 void *argp1 = 0 ;
41641 int res1 = 0 ;
41642 size_t val2 ;
41643 int ecode2 = 0 ;
41644 bool temp3 = false ;
41645 PyObject * obj0 = 0 ;
41646 PyObject * obj1 = 0 ;
41647 PyObject * obj2 = 0 ;
41648 char * kwnames[] = {
41649 (char *) "self",(char *) "pos",(char *) "label", NULL
41650 };
41651
41652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41654 if (!SWIG_IsOK(res1)) {
41655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41656 }
41657 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41658 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41659 if (!SWIG_IsOK(ecode2)) {
41660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41661 }
41662 arg2 = static_cast< size_t >(val2);
41663 {
41664 arg3 = wxString_in_helper(obj2);
41665 if (arg3 == NULL) SWIG_fail;
41666 temp3 = true;
41667 }
41668 {
41669 PyThreadState* __tstate = wxPyBeginAllowThreads();
41670 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41671 wxPyEndAllowThreads(__tstate);
41672 if (PyErr_Occurred()) SWIG_fail;
41673 }
41674 resultobj = SWIG_Py_Void();
41675 {
41676 if (temp3)
41677 delete arg3;
41678 }
41679 return resultobj;
41680 fail:
41681 {
41682 if (temp3)
41683 delete arg3;
41684 }
41685 return NULL;
41686 }
41687
41688
41689 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41690 PyObject *resultobj = 0;
41691 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41692 size_t arg2 ;
41693 wxString result;
41694 void *argp1 = 0 ;
41695 int res1 = 0 ;
41696 size_t val2 ;
41697 int ecode2 = 0 ;
41698 PyObject * obj0 = 0 ;
41699 PyObject * obj1 = 0 ;
41700 char * kwnames[] = {
41701 (char *) "self",(char *) "pos", NULL
41702 };
41703
41704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41706 if (!SWIG_IsOK(res1)) {
41707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41708 }
41709 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41710 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41711 if (!SWIG_IsOK(ecode2)) {
41712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41713 }
41714 arg2 = static_cast< size_t >(val2);
41715 {
41716 PyThreadState* __tstate = wxPyBeginAllowThreads();
41717 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41718 wxPyEndAllowThreads(__tstate);
41719 if (PyErr_Occurred()) SWIG_fail;
41720 }
41721 {
41722 #if wxUSE_UNICODE
41723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41724 #else
41725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41726 #endif
41727 }
41728 return resultobj;
41729 fail:
41730 return NULL;
41731 }
41732
41733
41734 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41735 PyObject *resultobj = 0;
41736 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41737 wxString *arg2 = 0 ;
41738 wxString *arg3 = 0 ;
41739 int result;
41740 void *argp1 = 0 ;
41741 int res1 = 0 ;
41742 bool temp2 = false ;
41743 bool temp3 = false ;
41744 PyObject * obj0 = 0 ;
41745 PyObject * obj1 = 0 ;
41746 PyObject * obj2 = 0 ;
41747 char * kwnames[] = {
41748 (char *) "self",(char *) "menu",(char *) "item", NULL
41749 };
41750
41751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41753 if (!SWIG_IsOK(res1)) {
41754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41755 }
41756 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41757 {
41758 arg2 = wxString_in_helper(obj1);
41759 if (arg2 == NULL) SWIG_fail;
41760 temp2 = true;
41761 }
41762 {
41763 arg3 = wxString_in_helper(obj2);
41764 if (arg3 == NULL) SWIG_fail;
41765 temp3 = true;
41766 }
41767 {
41768 PyThreadState* __tstate = wxPyBeginAllowThreads();
41769 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41770 wxPyEndAllowThreads(__tstate);
41771 if (PyErr_Occurred()) SWIG_fail;
41772 }
41773 resultobj = SWIG_From_int(static_cast< int >(result));
41774 {
41775 if (temp2)
41776 delete arg2;
41777 }
41778 {
41779 if (temp3)
41780 delete arg3;
41781 }
41782 return resultobj;
41783 fail:
41784 {
41785 if (temp2)
41786 delete arg2;
41787 }
41788 {
41789 if (temp3)
41790 delete arg3;
41791 }
41792 return NULL;
41793 }
41794
41795
41796 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41797 PyObject *resultobj = 0;
41798 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41799 int arg2 ;
41800 wxMenuItem *result = 0 ;
41801 void *argp1 = 0 ;
41802 int res1 = 0 ;
41803 int val2 ;
41804 int ecode2 = 0 ;
41805 PyObject * obj0 = 0 ;
41806 PyObject * obj1 = 0 ;
41807 char * kwnames[] = {
41808 (char *) "self",(char *) "id", NULL
41809 };
41810
41811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41813 if (!SWIG_IsOK(res1)) {
41814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41815 }
41816 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41817 ecode2 = SWIG_AsVal_int(obj1, &val2);
41818 if (!SWIG_IsOK(ecode2)) {
41819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41820 }
41821 arg2 = static_cast< int >(val2);
41822 {
41823 PyThreadState* __tstate = wxPyBeginAllowThreads();
41824 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41825 wxPyEndAllowThreads(__tstate);
41826 if (PyErr_Occurred()) SWIG_fail;
41827 }
41828 {
41829 resultobj = wxPyMake_wxObject(result, (bool)0);
41830 }
41831 return resultobj;
41832 fail:
41833 return NULL;
41834 }
41835
41836
41837 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41838 PyObject *resultobj = 0;
41839 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41840 wxString *arg2 = 0 ;
41841 int result;
41842 void *argp1 = 0 ;
41843 int res1 = 0 ;
41844 bool temp2 = false ;
41845 PyObject * obj0 = 0 ;
41846 PyObject * obj1 = 0 ;
41847 char * kwnames[] = {
41848 (char *) "self",(char *) "title", NULL
41849 };
41850
41851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41853 if (!SWIG_IsOK(res1)) {
41854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41855 }
41856 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41857 {
41858 arg2 = wxString_in_helper(obj1);
41859 if (arg2 == NULL) SWIG_fail;
41860 temp2 = true;
41861 }
41862 {
41863 PyThreadState* __tstate = wxPyBeginAllowThreads();
41864 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41865 wxPyEndAllowThreads(__tstate);
41866 if (PyErr_Occurred()) SWIG_fail;
41867 }
41868 resultobj = SWIG_From_int(static_cast< int >(result));
41869 {
41870 if (temp2)
41871 delete arg2;
41872 }
41873 return resultobj;
41874 fail:
41875 {
41876 if (temp2)
41877 delete arg2;
41878 }
41879 return NULL;
41880 }
41881
41882
41883 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41884 PyObject *resultobj = 0;
41885 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41886 int arg2 ;
41887 bool arg3 ;
41888 void *argp1 = 0 ;
41889 int res1 = 0 ;
41890 int val2 ;
41891 int ecode2 = 0 ;
41892 bool val3 ;
41893 int ecode3 = 0 ;
41894 PyObject * obj0 = 0 ;
41895 PyObject * obj1 = 0 ;
41896 PyObject * obj2 = 0 ;
41897 char * kwnames[] = {
41898 (char *) "self",(char *) "id",(char *) "enable", NULL
41899 };
41900
41901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41903 if (!SWIG_IsOK(res1)) {
41904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41905 }
41906 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41907 ecode2 = SWIG_AsVal_int(obj1, &val2);
41908 if (!SWIG_IsOK(ecode2)) {
41909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41910 }
41911 arg2 = static_cast< int >(val2);
41912 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41913 if (!SWIG_IsOK(ecode3)) {
41914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41915 }
41916 arg3 = static_cast< bool >(val3);
41917 {
41918 PyThreadState* __tstate = wxPyBeginAllowThreads();
41919 (arg1)->Enable(arg2,arg3);
41920 wxPyEndAllowThreads(__tstate);
41921 if (PyErr_Occurred()) SWIG_fail;
41922 }
41923 resultobj = SWIG_Py_Void();
41924 return resultobj;
41925 fail:
41926 return NULL;
41927 }
41928
41929
41930 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41931 PyObject *resultobj = 0;
41932 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41933 int arg2 ;
41934 bool arg3 ;
41935 void *argp1 = 0 ;
41936 int res1 = 0 ;
41937 int val2 ;
41938 int ecode2 = 0 ;
41939 bool val3 ;
41940 int ecode3 = 0 ;
41941 PyObject * obj0 = 0 ;
41942 PyObject * obj1 = 0 ;
41943 PyObject * obj2 = 0 ;
41944 char * kwnames[] = {
41945 (char *) "self",(char *) "id",(char *) "check", NULL
41946 };
41947
41948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41950 if (!SWIG_IsOK(res1)) {
41951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41952 }
41953 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41954 ecode2 = SWIG_AsVal_int(obj1, &val2);
41955 if (!SWIG_IsOK(ecode2)) {
41956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41957 }
41958 arg2 = static_cast< int >(val2);
41959 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41960 if (!SWIG_IsOK(ecode3)) {
41961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41962 }
41963 arg3 = static_cast< bool >(val3);
41964 {
41965 PyThreadState* __tstate = wxPyBeginAllowThreads();
41966 (arg1)->Check(arg2,arg3);
41967 wxPyEndAllowThreads(__tstate);
41968 if (PyErr_Occurred()) SWIG_fail;
41969 }
41970 resultobj = SWIG_Py_Void();
41971 return resultobj;
41972 fail:
41973 return NULL;
41974 }
41975
41976
41977 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41978 PyObject *resultobj = 0;
41979 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41980 int arg2 ;
41981 bool result;
41982 void *argp1 = 0 ;
41983 int res1 = 0 ;
41984 int val2 ;
41985 int ecode2 = 0 ;
41986 PyObject * obj0 = 0 ;
41987 PyObject * obj1 = 0 ;
41988 char * kwnames[] = {
41989 (char *) "self",(char *) "id", NULL
41990 };
41991
41992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41994 if (!SWIG_IsOK(res1)) {
41995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41996 }
41997 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41998 ecode2 = SWIG_AsVal_int(obj1, &val2);
41999 if (!SWIG_IsOK(ecode2)) {
42000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42001 }
42002 arg2 = static_cast< int >(val2);
42003 {
42004 PyThreadState* __tstate = wxPyBeginAllowThreads();
42005 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42006 wxPyEndAllowThreads(__tstate);
42007 if (PyErr_Occurred()) SWIG_fail;
42008 }
42009 {
42010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42011 }
42012 return resultobj;
42013 fail:
42014 return NULL;
42015 }
42016
42017
42018 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42019 PyObject *resultobj = 0;
42020 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42021 int arg2 ;
42022 bool result;
42023 void *argp1 = 0 ;
42024 int res1 = 0 ;
42025 int val2 ;
42026 int ecode2 = 0 ;
42027 PyObject * obj0 = 0 ;
42028 PyObject * obj1 = 0 ;
42029 char * kwnames[] = {
42030 (char *) "self",(char *) "id", NULL
42031 };
42032
42033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42035 if (!SWIG_IsOK(res1)) {
42036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42037 }
42038 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42039 ecode2 = SWIG_AsVal_int(obj1, &val2);
42040 if (!SWIG_IsOK(ecode2)) {
42041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42042 }
42043 arg2 = static_cast< int >(val2);
42044 {
42045 PyThreadState* __tstate = wxPyBeginAllowThreads();
42046 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42047 wxPyEndAllowThreads(__tstate);
42048 if (PyErr_Occurred()) SWIG_fail;
42049 }
42050 {
42051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42052 }
42053 return resultobj;
42054 fail:
42055 return NULL;
42056 }
42057
42058
42059 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42060 PyObject *resultobj = 0;
42061 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42062 int arg2 ;
42063 wxString *arg3 = 0 ;
42064 void *argp1 = 0 ;
42065 int res1 = 0 ;
42066 int val2 ;
42067 int ecode2 = 0 ;
42068 bool temp3 = false ;
42069 PyObject * obj0 = 0 ;
42070 PyObject * obj1 = 0 ;
42071 PyObject * obj2 = 0 ;
42072 char * kwnames[] = {
42073 (char *) "self",(char *) "id",(char *) "label", NULL
42074 };
42075
42076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42078 if (!SWIG_IsOK(res1)) {
42079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42080 }
42081 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42082 ecode2 = SWIG_AsVal_int(obj1, &val2);
42083 if (!SWIG_IsOK(ecode2)) {
42084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42085 }
42086 arg2 = static_cast< int >(val2);
42087 {
42088 arg3 = wxString_in_helper(obj2);
42089 if (arg3 == NULL) SWIG_fail;
42090 temp3 = true;
42091 }
42092 {
42093 PyThreadState* __tstate = wxPyBeginAllowThreads();
42094 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42095 wxPyEndAllowThreads(__tstate);
42096 if (PyErr_Occurred()) SWIG_fail;
42097 }
42098 resultobj = SWIG_Py_Void();
42099 {
42100 if (temp3)
42101 delete arg3;
42102 }
42103 return resultobj;
42104 fail:
42105 {
42106 if (temp3)
42107 delete arg3;
42108 }
42109 return NULL;
42110 }
42111
42112
42113 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42114 PyObject *resultobj = 0;
42115 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42116 int arg2 ;
42117 wxString result;
42118 void *argp1 = 0 ;
42119 int res1 = 0 ;
42120 int val2 ;
42121 int ecode2 = 0 ;
42122 PyObject * obj0 = 0 ;
42123 PyObject * obj1 = 0 ;
42124 char * kwnames[] = {
42125 (char *) "self",(char *) "id", NULL
42126 };
42127
42128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42130 if (!SWIG_IsOK(res1)) {
42131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42132 }
42133 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42134 ecode2 = SWIG_AsVal_int(obj1, &val2);
42135 if (!SWIG_IsOK(ecode2)) {
42136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42137 }
42138 arg2 = static_cast< int >(val2);
42139 {
42140 PyThreadState* __tstate = wxPyBeginAllowThreads();
42141 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42142 wxPyEndAllowThreads(__tstate);
42143 if (PyErr_Occurred()) SWIG_fail;
42144 }
42145 {
42146 #if wxUSE_UNICODE
42147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42148 #else
42149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42150 #endif
42151 }
42152 return resultobj;
42153 fail:
42154 return NULL;
42155 }
42156
42157
42158 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42159 PyObject *resultobj = 0;
42160 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42161 int arg2 ;
42162 wxString *arg3 = 0 ;
42163 void *argp1 = 0 ;
42164 int res1 = 0 ;
42165 int val2 ;
42166 int ecode2 = 0 ;
42167 bool temp3 = false ;
42168 PyObject * obj0 = 0 ;
42169 PyObject * obj1 = 0 ;
42170 PyObject * obj2 = 0 ;
42171 char * kwnames[] = {
42172 (char *) "self",(char *) "id",(char *) "helpString", NULL
42173 };
42174
42175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42177 if (!SWIG_IsOK(res1)) {
42178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42179 }
42180 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42181 ecode2 = SWIG_AsVal_int(obj1, &val2);
42182 if (!SWIG_IsOK(ecode2)) {
42183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42184 }
42185 arg2 = static_cast< int >(val2);
42186 {
42187 arg3 = wxString_in_helper(obj2);
42188 if (arg3 == NULL) SWIG_fail;
42189 temp3 = true;
42190 }
42191 {
42192 PyThreadState* __tstate = wxPyBeginAllowThreads();
42193 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42194 wxPyEndAllowThreads(__tstate);
42195 if (PyErr_Occurred()) SWIG_fail;
42196 }
42197 resultobj = SWIG_Py_Void();
42198 {
42199 if (temp3)
42200 delete arg3;
42201 }
42202 return resultobj;
42203 fail:
42204 {
42205 if (temp3)
42206 delete arg3;
42207 }
42208 return NULL;
42209 }
42210
42211
42212 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42213 PyObject *resultobj = 0;
42214 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42215 int arg2 ;
42216 wxString result;
42217 void *argp1 = 0 ;
42218 int res1 = 0 ;
42219 int val2 ;
42220 int ecode2 = 0 ;
42221 PyObject * obj0 = 0 ;
42222 PyObject * obj1 = 0 ;
42223 char * kwnames[] = {
42224 (char *) "self",(char *) "id", NULL
42225 };
42226
42227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42229 if (!SWIG_IsOK(res1)) {
42230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42231 }
42232 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42233 ecode2 = SWIG_AsVal_int(obj1, &val2);
42234 if (!SWIG_IsOK(ecode2)) {
42235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42236 }
42237 arg2 = static_cast< int >(val2);
42238 {
42239 PyThreadState* __tstate = wxPyBeginAllowThreads();
42240 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42241 wxPyEndAllowThreads(__tstate);
42242 if (PyErr_Occurred()) SWIG_fail;
42243 }
42244 {
42245 #if wxUSE_UNICODE
42246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42247 #else
42248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42249 #endif
42250 }
42251 return resultobj;
42252 fail:
42253 return NULL;
42254 }
42255
42256
42257 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42258 PyObject *resultobj = 0;
42259 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42260 wxFrame *result = 0 ;
42261 void *argp1 = 0 ;
42262 int res1 = 0 ;
42263 PyObject *swig_obj[1] ;
42264
42265 if (!args) SWIG_fail;
42266 swig_obj[0] = args;
42267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42268 if (!SWIG_IsOK(res1)) {
42269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42270 }
42271 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42272 {
42273 PyThreadState* __tstate = wxPyBeginAllowThreads();
42274 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42275 wxPyEndAllowThreads(__tstate);
42276 if (PyErr_Occurred()) SWIG_fail;
42277 }
42278 {
42279 resultobj = wxPyMake_wxObject(result, (bool)0);
42280 }
42281 return resultobj;
42282 fail:
42283 return NULL;
42284 }
42285
42286
42287 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42288 PyObject *resultobj = 0;
42289 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42290 bool result;
42291 void *argp1 = 0 ;
42292 int res1 = 0 ;
42293 PyObject *swig_obj[1] ;
42294
42295 if (!args) SWIG_fail;
42296 swig_obj[0] = args;
42297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42298 if (!SWIG_IsOK(res1)) {
42299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42300 }
42301 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42302 {
42303 PyThreadState* __tstate = wxPyBeginAllowThreads();
42304 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42305 wxPyEndAllowThreads(__tstate);
42306 if (PyErr_Occurred()) SWIG_fail;
42307 }
42308 {
42309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42310 }
42311 return resultobj;
42312 fail:
42313 return NULL;
42314 }
42315
42316
42317 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42318 PyObject *resultobj = 0;
42319 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42320 wxFrame *arg2 = (wxFrame *) 0 ;
42321 void *argp1 = 0 ;
42322 int res1 = 0 ;
42323 void *argp2 = 0 ;
42324 int res2 = 0 ;
42325 PyObject * obj0 = 0 ;
42326 PyObject * obj1 = 0 ;
42327 char * kwnames[] = {
42328 (char *) "self",(char *) "frame", NULL
42329 };
42330
42331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42333 if (!SWIG_IsOK(res1)) {
42334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42335 }
42336 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42338 if (!SWIG_IsOK(res2)) {
42339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42340 }
42341 arg2 = reinterpret_cast< wxFrame * >(argp2);
42342 {
42343 PyThreadState* __tstate = wxPyBeginAllowThreads();
42344 (arg1)->Attach(arg2);
42345 wxPyEndAllowThreads(__tstate);
42346 if (PyErr_Occurred()) SWIG_fail;
42347 }
42348 resultobj = SWIG_Py_Void();
42349 return resultobj;
42350 fail:
42351 return NULL;
42352 }
42353
42354
42355 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42356 PyObject *resultobj = 0;
42357 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42358 void *argp1 = 0 ;
42359 int res1 = 0 ;
42360 PyObject *swig_obj[1] ;
42361
42362 if (!args) SWIG_fail;
42363 swig_obj[0] = args;
42364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42365 if (!SWIG_IsOK(res1)) {
42366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42367 }
42368 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42369 {
42370 PyThreadState* __tstate = wxPyBeginAllowThreads();
42371 (arg1)->Detach();
42372 wxPyEndAllowThreads(__tstate);
42373 if (PyErr_Occurred()) SWIG_fail;
42374 }
42375 resultobj = SWIG_Py_Void();
42376 return resultobj;
42377 fail:
42378 return NULL;
42379 }
42380
42381
42382 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42383 PyObject *resultobj = 0;
42384 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42385 void *argp1 = 0 ;
42386 int res1 = 0 ;
42387 PyObject *swig_obj[1] ;
42388
42389 if (!args) SWIG_fail;
42390 swig_obj[0] = args;
42391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42392 if (!SWIG_IsOK(res1)) {
42393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42394 }
42395 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42396 {
42397 PyThreadState* __tstate = wxPyBeginAllowThreads();
42398 (arg1)->UpdateMenus();
42399 wxPyEndAllowThreads(__tstate);
42400 if (PyErr_Occurred()) SWIG_fail;
42401 }
42402 resultobj = SWIG_Py_Void();
42403 return resultobj;
42404 fail:
42405 return NULL;
42406 }
42407
42408
42409 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42410 PyObject *resultobj = 0;
42411 bool arg1 ;
42412 bool val1 ;
42413 int ecode1 = 0 ;
42414 PyObject * obj0 = 0 ;
42415 char * kwnames[] = {
42416 (char *) "enable", NULL
42417 };
42418
42419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42420 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42421 if (!SWIG_IsOK(ecode1)) {
42422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42423 }
42424 arg1 = static_cast< bool >(val1);
42425 {
42426 PyThreadState* __tstate = wxPyBeginAllowThreads();
42427 wxMenuBar::SetAutoWindowMenu(arg1);
42428 wxPyEndAllowThreads(__tstate);
42429 if (PyErr_Occurred()) SWIG_fail;
42430 }
42431 resultobj = SWIG_Py_Void();
42432 return resultobj;
42433 fail:
42434 return NULL;
42435 }
42436
42437
42438 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42439 PyObject *resultobj = 0;
42440 bool result;
42441
42442 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42443 {
42444 PyThreadState* __tstate = wxPyBeginAllowThreads();
42445 result = (bool)wxMenuBar::GetAutoWindowMenu();
42446 wxPyEndAllowThreads(__tstate);
42447 if (PyErr_Occurred()) SWIG_fail;
42448 }
42449 {
42450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42451 }
42452 return resultobj;
42453 fail:
42454 return NULL;
42455 }
42456
42457
42458 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42459 PyObject *obj;
42460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42461 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42462 return SWIG_Py_Void();
42463 }
42464
42465 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42466 return SWIG_Python_InitShadowInstance(args);
42467 }
42468
42469 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42470 PyObject *resultobj = 0;
42471 wxMenu *arg1 = (wxMenu *) NULL ;
42472 int arg2 = (int) wxID_ANY ;
42473 wxString const &arg3_defvalue = wxPyEmptyString ;
42474 wxString *arg3 = (wxString *) &arg3_defvalue ;
42475 wxString const &arg4_defvalue = wxPyEmptyString ;
42476 wxString *arg4 = (wxString *) &arg4_defvalue ;
42477 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42478 wxMenu *arg6 = (wxMenu *) NULL ;
42479 wxMenuItem *result = 0 ;
42480 void *argp1 = 0 ;
42481 int res1 = 0 ;
42482 int val2 ;
42483 int ecode2 = 0 ;
42484 bool temp3 = false ;
42485 bool temp4 = false ;
42486 int val5 ;
42487 int ecode5 = 0 ;
42488 void *argp6 = 0 ;
42489 int res6 = 0 ;
42490 PyObject * obj0 = 0 ;
42491 PyObject * obj1 = 0 ;
42492 PyObject * obj2 = 0 ;
42493 PyObject * obj3 = 0 ;
42494 PyObject * obj4 = 0 ;
42495 PyObject * obj5 = 0 ;
42496 char * kwnames[] = {
42497 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42498 };
42499
42500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42501 if (obj0) {
42502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42503 if (!SWIG_IsOK(res1)) {
42504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42505 }
42506 arg1 = reinterpret_cast< wxMenu * >(argp1);
42507 }
42508 if (obj1) {
42509 ecode2 = SWIG_AsVal_int(obj1, &val2);
42510 if (!SWIG_IsOK(ecode2)) {
42511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42512 }
42513 arg2 = static_cast< int >(val2);
42514 }
42515 if (obj2) {
42516 {
42517 arg3 = wxString_in_helper(obj2);
42518 if (arg3 == NULL) SWIG_fail;
42519 temp3 = true;
42520 }
42521 }
42522 if (obj3) {
42523 {
42524 arg4 = wxString_in_helper(obj3);
42525 if (arg4 == NULL) SWIG_fail;
42526 temp4 = true;
42527 }
42528 }
42529 if (obj4) {
42530 ecode5 = SWIG_AsVal_int(obj4, &val5);
42531 if (!SWIG_IsOK(ecode5)) {
42532 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42533 }
42534 arg5 = static_cast< wxItemKind >(val5);
42535 }
42536 if (obj5) {
42537 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42538 if (!SWIG_IsOK(res6)) {
42539 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42540 }
42541 arg6 = reinterpret_cast< wxMenu * >(argp6);
42542 }
42543 {
42544 PyThreadState* __tstate = wxPyBeginAllowThreads();
42545 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42546 wxPyEndAllowThreads(__tstate);
42547 if (PyErr_Occurred()) SWIG_fail;
42548 }
42549 {
42550 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42551 }
42552 {
42553 if (temp3)
42554 delete arg3;
42555 }
42556 {
42557 if (temp4)
42558 delete arg4;
42559 }
42560 return resultobj;
42561 fail:
42562 {
42563 if (temp3)
42564 delete arg3;
42565 }
42566 {
42567 if (temp4)
42568 delete arg4;
42569 }
42570 return NULL;
42571 }
42572
42573
42574 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42575 PyObject *resultobj = 0;
42576 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42577 void *argp1 = 0 ;
42578 int res1 = 0 ;
42579 PyObject *swig_obj[1] ;
42580
42581 if (!args) SWIG_fail;
42582 swig_obj[0] = args;
42583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42584 if (!SWIG_IsOK(res1)) {
42585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42586 }
42587 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42588 {
42589 PyThreadState* __tstate = wxPyBeginAllowThreads();
42590 delete arg1;
42591
42592 wxPyEndAllowThreads(__tstate);
42593 if (PyErr_Occurred()) SWIG_fail;
42594 }
42595 resultobj = SWIG_Py_Void();
42596 return resultobj;
42597 fail:
42598 return NULL;
42599 }
42600
42601
42602 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42603 PyObject *resultobj = 0;
42604 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42605 wxMenu *result = 0 ;
42606 void *argp1 = 0 ;
42607 int res1 = 0 ;
42608 PyObject *swig_obj[1] ;
42609
42610 if (!args) SWIG_fail;
42611 swig_obj[0] = args;
42612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42613 if (!SWIG_IsOK(res1)) {
42614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42615 }
42616 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42617 {
42618 PyThreadState* __tstate = wxPyBeginAllowThreads();
42619 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42620 wxPyEndAllowThreads(__tstate);
42621 if (PyErr_Occurred()) SWIG_fail;
42622 }
42623 {
42624 resultobj = wxPyMake_wxObject(result, 0);
42625 }
42626 return resultobj;
42627 fail:
42628 return NULL;
42629 }
42630
42631
42632 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42633 PyObject *resultobj = 0;
42634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42635 wxMenu *arg2 = (wxMenu *) 0 ;
42636 void *argp1 = 0 ;
42637 int res1 = 0 ;
42638 void *argp2 = 0 ;
42639 int res2 = 0 ;
42640 PyObject * obj0 = 0 ;
42641 PyObject * obj1 = 0 ;
42642 char * kwnames[] = {
42643 (char *) "self",(char *) "menu", NULL
42644 };
42645
42646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42648 if (!SWIG_IsOK(res1)) {
42649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42650 }
42651 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42653 if (!SWIG_IsOK(res2)) {
42654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42655 }
42656 arg2 = reinterpret_cast< wxMenu * >(argp2);
42657 {
42658 PyThreadState* __tstate = wxPyBeginAllowThreads();
42659 (arg1)->SetMenu(arg2);
42660 wxPyEndAllowThreads(__tstate);
42661 if (PyErr_Occurred()) SWIG_fail;
42662 }
42663 resultobj = SWIG_Py_Void();
42664 return resultobj;
42665 fail:
42666 return NULL;
42667 }
42668
42669
42670 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42671 PyObject *resultobj = 0;
42672 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42673 int arg2 ;
42674 void *argp1 = 0 ;
42675 int res1 = 0 ;
42676 int val2 ;
42677 int ecode2 = 0 ;
42678 PyObject * obj0 = 0 ;
42679 PyObject * obj1 = 0 ;
42680 char * kwnames[] = {
42681 (char *) "self",(char *) "id", NULL
42682 };
42683
42684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42686 if (!SWIG_IsOK(res1)) {
42687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42688 }
42689 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42690 ecode2 = SWIG_AsVal_int(obj1, &val2);
42691 if (!SWIG_IsOK(ecode2)) {
42692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42693 }
42694 arg2 = static_cast< int >(val2);
42695 {
42696 PyThreadState* __tstate = wxPyBeginAllowThreads();
42697 (arg1)->SetId(arg2);
42698 wxPyEndAllowThreads(__tstate);
42699 if (PyErr_Occurred()) SWIG_fail;
42700 }
42701 resultobj = SWIG_Py_Void();
42702 return resultobj;
42703 fail:
42704 return NULL;
42705 }
42706
42707
42708 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42709 PyObject *resultobj = 0;
42710 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42711 int result;
42712 void *argp1 = 0 ;
42713 int res1 = 0 ;
42714 PyObject *swig_obj[1] ;
42715
42716 if (!args) SWIG_fail;
42717 swig_obj[0] = args;
42718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42719 if (!SWIG_IsOK(res1)) {
42720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42721 }
42722 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42723 {
42724 PyThreadState* __tstate = wxPyBeginAllowThreads();
42725 result = (int)((wxMenuItem const *)arg1)->GetId();
42726 wxPyEndAllowThreads(__tstate);
42727 if (PyErr_Occurred()) SWIG_fail;
42728 }
42729 resultobj = SWIG_From_int(static_cast< int >(result));
42730 return resultobj;
42731 fail:
42732 return NULL;
42733 }
42734
42735
42736 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42737 PyObject *resultobj = 0;
42738 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42739 bool result;
42740 void *argp1 = 0 ;
42741 int res1 = 0 ;
42742 PyObject *swig_obj[1] ;
42743
42744 if (!args) SWIG_fail;
42745 swig_obj[0] = args;
42746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42747 if (!SWIG_IsOK(res1)) {
42748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42749 }
42750 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42751 {
42752 PyThreadState* __tstate = wxPyBeginAllowThreads();
42753 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42754 wxPyEndAllowThreads(__tstate);
42755 if (PyErr_Occurred()) SWIG_fail;
42756 }
42757 {
42758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42759 }
42760 return resultobj;
42761 fail:
42762 return NULL;
42763 }
42764
42765
42766 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42767 PyObject *resultobj = 0;
42768 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42769 wxString *arg2 = 0 ;
42770 void *argp1 = 0 ;
42771 int res1 = 0 ;
42772 bool temp2 = false ;
42773 PyObject * obj0 = 0 ;
42774 PyObject * obj1 = 0 ;
42775 char * kwnames[] = {
42776 (char *) "self",(char *) "str", NULL
42777 };
42778
42779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42781 if (!SWIG_IsOK(res1)) {
42782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42783 }
42784 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42785 {
42786 arg2 = wxString_in_helper(obj1);
42787 if (arg2 == NULL) SWIG_fail;
42788 temp2 = true;
42789 }
42790 {
42791 PyThreadState* __tstate = wxPyBeginAllowThreads();
42792 (arg1)->SetText((wxString const &)*arg2);
42793 wxPyEndAllowThreads(__tstate);
42794 if (PyErr_Occurred()) SWIG_fail;
42795 }
42796 resultobj = SWIG_Py_Void();
42797 {
42798 if (temp2)
42799 delete arg2;
42800 }
42801 return resultobj;
42802 fail:
42803 {
42804 if (temp2)
42805 delete arg2;
42806 }
42807 return NULL;
42808 }
42809
42810
42811 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42812 PyObject *resultobj = 0;
42813 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42814 wxString result;
42815 void *argp1 = 0 ;
42816 int res1 = 0 ;
42817 PyObject *swig_obj[1] ;
42818
42819 if (!args) SWIG_fail;
42820 swig_obj[0] = args;
42821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42822 if (!SWIG_IsOK(res1)) {
42823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42824 }
42825 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42826 {
42827 PyThreadState* __tstate = wxPyBeginAllowThreads();
42828 result = ((wxMenuItem const *)arg1)->GetLabel();
42829 wxPyEndAllowThreads(__tstate);
42830 if (PyErr_Occurred()) SWIG_fail;
42831 }
42832 {
42833 #if wxUSE_UNICODE
42834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42835 #else
42836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42837 #endif
42838 }
42839 return resultobj;
42840 fail:
42841 return NULL;
42842 }
42843
42844
42845 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42846 PyObject *resultobj = 0;
42847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42848 wxString *result = 0 ;
42849 void *argp1 = 0 ;
42850 int res1 = 0 ;
42851 PyObject *swig_obj[1] ;
42852
42853 if (!args) SWIG_fail;
42854 swig_obj[0] = args;
42855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42856 if (!SWIG_IsOK(res1)) {
42857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42858 }
42859 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42860 {
42861 PyThreadState* __tstate = wxPyBeginAllowThreads();
42862 {
42863 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42864 result = (wxString *) &_result_ref;
42865 }
42866 wxPyEndAllowThreads(__tstate);
42867 if (PyErr_Occurred()) SWIG_fail;
42868 }
42869 {
42870 #if wxUSE_UNICODE
42871 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42872 #else
42873 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42874 #endif
42875 }
42876 return resultobj;
42877 fail:
42878 return NULL;
42879 }
42880
42881
42882 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42883 PyObject *resultobj = 0;
42884 wxString *arg1 = 0 ;
42885 wxString result;
42886 bool temp1 = false ;
42887 PyObject * obj0 = 0 ;
42888 char * kwnames[] = {
42889 (char *) "text", NULL
42890 };
42891
42892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42893 {
42894 arg1 = wxString_in_helper(obj0);
42895 if (arg1 == NULL) SWIG_fail;
42896 temp1 = true;
42897 }
42898 {
42899 PyThreadState* __tstate = wxPyBeginAllowThreads();
42900 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42901 wxPyEndAllowThreads(__tstate);
42902 if (PyErr_Occurred()) SWIG_fail;
42903 }
42904 {
42905 #if wxUSE_UNICODE
42906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42907 #else
42908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42909 #endif
42910 }
42911 {
42912 if (temp1)
42913 delete arg1;
42914 }
42915 return resultobj;
42916 fail:
42917 {
42918 if (temp1)
42919 delete arg1;
42920 }
42921 return NULL;
42922 }
42923
42924
42925 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42926 PyObject *resultobj = 0;
42927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42928 wxItemKind result;
42929 void *argp1 = 0 ;
42930 int res1 = 0 ;
42931 PyObject *swig_obj[1] ;
42932
42933 if (!args) SWIG_fail;
42934 swig_obj[0] = args;
42935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42936 if (!SWIG_IsOK(res1)) {
42937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42938 }
42939 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42940 {
42941 PyThreadState* __tstate = wxPyBeginAllowThreads();
42942 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42943 wxPyEndAllowThreads(__tstate);
42944 if (PyErr_Occurred()) SWIG_fail;
42945 }
42946 resultobj = SWIG_From_int(static_cast< int >(result));
42947 return resultobj;
42948 fail:
42949 return NULL;
42950 }
42951
42952
42953 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42954 PyObject *resultobj = 0;
42955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42956 wxItemKind arg2 ;
42957 void *argp1 = 0 ;
42958 int res1 = 0 ;
42959 int val2 ;
42960 int ecode2 = 0 ;
42961 PyObject * obj0 = 0 ;
42962 PyObject * obj1 = 0 ;
42963 char * kwnames[] = {
42964 (char *) "self",(char *) "kind", NULL
42965 };
42966
42967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42969 if (!SWIG_IsOK(res1)) {
42970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42971 }
42972 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42973 ecode2 = SWIG_AsVal_int(obj1, &val2);
42974 if (!SWIG_IsOK(ecode2)) {
42975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42976 }
42977 arg2 = static_cast< wxItemKind >(val2);
42978 {
42979 PyThreadState* __tstate = wxPyBeginAllowThreads();
42980 (arg1)->SetKind(arg2);
42981 wxPyEndAllowThreads(__tstate);
42982 if (PyErr_Occurred()) SWIG_fail;
42983 }
42984 resultobj = SWIG_Py_Void();
42985 return resultobj;
42986 fail:
42987 return NULL;
42988 }
42989
42990
42991 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42992 PyObject *resultobj = 0;
42993 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42994 bool arg2 ;
42995 void *argp1 = 0 ;
42996 int res1 = 0 ;
42997 bool val2 ;
42998 int ecode2 = 0 ;
42999 PyObject * obj0 = 0 ;
43000 PyObject * obj1 = 0 ;
43001 char * kwnames[] = {
43002 (char *) "self",(char *) "checkable", NULL
43003 };
43004
43005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43007 if (!SWIG_IsOK(res1)) {
43008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43009 }
43010 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43011 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43012 if (!SWIG_IsOK(ecode2)) {
43013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43014 }
43015 arg2 = static_cast< bool >(val2);
43016 {
43017 PyThreadState* __tstate = wxPyBeginAllowThreads();
43018 (arg1)->SetCheckable(arg2);
43019 wxPyEndAllowThreads(__tstate);
43020 if (PyErr_Occurred()) SWIG_fail;
43021 }
43022 resultobj = SWIG_Py_Void();
43023 return resultobj;
43024 fail:
43025 return NULL;
43026 }
43027
43028
43029 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43030 PyObject *resultobj = 0;
43031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43032 bool result;
43033 void *argp1 = 0 ;
43034 int res1 = 0 ;
43035 PyObject *swig_obj[1] ;
43036
43037 if (!args) SWIG_fail;
43038 swig_obj[0] = args;
43039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43040 if (!SWIG_IsOK(res1)) {
43041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43042 }
43043 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43044 {
43045 PyThreadState* __tstate = wxPyBeginAllowThreads();
43046 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43047 wxPyEndAllowThreads(__tstate);
43048 if (PyErr_Occurred()) SWIG_fail;
43049 }
43050 {
43051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43052 }
43053 return resultobj;
43054 fail:
43055 return NULL;
43056 }
43057
43058
43059 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43060 PyObject *resultobj = 0;
43061 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43062 bool result;
43063 void *argp1 = 0 ;
43064 int res1 = 0 ;
43065 PyObject *swig_obj[1] ;
43066
43067 if (!args) SWIG_fail;
43068 swig_obj[0] = args;
43069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43070 if (!SWIG_IsOK(res1)) {
43071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43072 }
43073 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43074 {
43075 PyThreadState* __tstate = wxPyBeginAllowThreads();
43076 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43077 wxPyEndAllowThreads(__tstate);
43078 if (PyErr_Occurred()) SWIG_fail;
43079 }
43080 {
43081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43082 }
43083 return resultobj;
43084 fail:
43085 return NULL;
43086 }
43087
43088
43089 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43090 PyObject *resultobj = 0;
43091 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43092 wxMenu *arg2 = (wxMenu *) 0 ;
43093 void *argp1 = 0 ;
43094 int res1 = 0 ;
43095 void *argp2 = 0 ;
43096 int res2 = 0 ;
43097 PyObject * obj0 = 0 ;
43098 PyObject * obj1 = 0 ;
43099 char * kwnames[] = {
43100 (char *) "self",(char *) "menu", NULL
43101 };
43102
43103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43105 if (!SWIG_IsOK(res1)) {
43106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43107 }
43108 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43109 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43110 if (!SWIG_IsOK(res2)) {
43111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43112 }
43113 arg2 = reinterpret_cast< wxMenu * >(argp2);
43114 {
43115 PyThreadState* __tstate = wxPyBeginAllowThreads();
43116 (arg1)->SetSubMenu(arg2);
43117 wxPyEndAllowThreads(__tstate);
43118 if (PyErr_Occurred()) SWIG_fail;
43119 }
43120 resultobj = SWIG_Py_Void();
43121 return resultobj;
43122 fail:
43123 return NULL;
43124 }
43125
43126
43127 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43128 PyObject *resultobj = 0;
43129 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43130 wxMenu *result = 0 ;
43131 void *argp1 = 0 ;
43132 int res1 = 0 ;
43133 PyObject *swig_obj[1] ;
43134
43135 if (!args) SWIG_fail;
43136 swig_obj[0] = args;
43137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43138 if (!SWIG_IsOK(res1)) {
43139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43140 }
43141 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43142 {
43143 PyThreadState* __tstate = wxPyBeginAllowThreads();
43144 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43145 wxPyEndAllowThreads(__tstate);
43146 if (PyErr_Occurred()) SWIG_fail;
43147 }
43148 {
43149 resultobj = wxPyMake_wxObject(result, 0);
43150 }
43151 return resultobj;
43152 fail:
43153 return NULL;
43154 }
43155
43156
43157 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43158 PyObject *resultobj = 0;
43159 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43160 bool arg2 = (bool) true ;
43161 void *argp1 = 0 ;
43162 int res1 = 0 ;
43163 bool val2 ;
43164 int ecode2 = 0 ;
43165 PyObject * obj0 = 0 ;
43166 PyObject * obj1 = 0 ;
43167 char * kwnames[] = {
43168 (char *) "self",(char *) "enable", NULL
43169 };
43170
43171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43173 if (!SWIG_IsOK(res1)) {
43174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43175 }
43176 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43177 if (obj1) {
43178 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43179 if (!SWIG_IsOK(ecode2)) {
43180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43181 }
43182 arg2 = static_cast< bool >(val2);
43183 }
43184 {
43185 PyThreadState* __tstate = wxPyBeginAllowThreads();
43186 (arg1)->Enable(arg2);
43187 wxPyEndAllowThreads(__tstate);
43188 if (PyErr_Occurred()) SWIG_fail;
43189 }
43190 resultobj = SWIG_Py_Void();
43191 return resultobj;
43192 fail:
43193 return NULL;
43194 }
43195
43196
43197 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43198 PyObject *resultobj = 0;
43199 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43200 bool result;
43201 void *argp1 = 0 ;
43202 int res1 = 0 ;
43203 PyObject *swig_obj[1] ;
43204
43205 if (!args) SWIG_fail;
43206 swig_obj[0] = args;
43207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43208 if (!SWIG_IsOK(res1)) {
43209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43210 }
43211 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43212 {
43213 PyThreadState* __tstate = wxPyBeginAllowThreads();
43214 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43215 wxPyEndAllowThreads(__tstate);
43216 if (PyErr_Occurred()) SWIG_fail;
43217 }
43218 {
43219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43220 }
43221 return resultobj;
43222 fail:
43223 return NULL;
43224 }
43225
43226
43227 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43228 PyObject *resultobj = 0;
43229 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43230 bool arg2 = (bool) true ;
43231 void *argp1 = 0 ;
43232 int res1 = 0 ;
43233 bool val2 ;
43234 int ecode2 = 0 ;
43235 PyObject * obj0 = 0 ;
43236 PyObject * obj1 = 0 ;
43237 char * kwnames[] = {
43238 (char *) "self",(char *) "check", NULL
43239 };
43240
43241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43243 if (!SWIG_IsOK(res1)) {
43244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43245 }
43246 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43247 if (obj1) {
43248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43249 if (!SWIG_IsOK(ecode2)) {
43250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43251 }
43252 arg2 = static_cast< bool >(val2);
43253 }
43254 {
43255 PyThreadState* __tstate = wxPyBeginAllowThreads();
43256 (arg1)->Check(arg2);
43257 wxPyEndAllowThreads(__tstate);
43258 if (PyErr_Occurred()) SWIG_fail;
43259 }
43260 resultobj = SWIG_Py_Void();
43261 return resultobj;
43262 fail:
43263 return NULL;
43264 }
43265
43266
43267 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43268 PyObject *resultobj = 0;
43269 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43270 bool result;
43271 void *argp1 = 0 ;
43272 int res1 = 0 ;
43273 PyObject *swig_obj[1] ;
43274
43275 if (!args) SWIG_fail;
43276 swig_obj[0] = args;
43277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43278 if (!SWIG_IsOK(res1)) {
43279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43280 }
43281 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43282 {
43283 PyThreadState* __tstate = wxPyBeginAllowThreads();
43284 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43285 wxPyEndAllowThreads(__tstate);
43286 if (PyErr_Occurred()) SWIG_fail;
43287 }
43288 {
43289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43290 }
43291 return resultobj;
43292 fail:
43293 return NULL;
43294 }
43295
43296
43297 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43298 PyObject *resultobj = 0;
43299 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43300 void *argp1 = 0 ;
43301 int res1 = 0 ;
43302 PyObject *swig_obj[1] ;
43303
43304 if (!args) SWIG_fail;
43305 swig_obj[0] = args;
43306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43307 if (!SWIG_IsOK(res1)) {
43308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43309 }
43310 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43311 {
43312 PyThreadState* __tstate = wxPyBeginAllowThreads();
43313 (arg1)->Toggle();
43314 wxPyEndAllowThreads(__tstate);
43315 if (PyErr_Occurred()) SWIG_fail;
43316 }
43317 resultobj = SWIG_Py_Void();
43318 return resultobj;
43319 fail:
43320 return NULL;
43321 }
43322
43323
43324 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43325 PyObject *resultobj = 0;
43326 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43327 wxString *arg2 = 0 ;
43328 void *argp1 = 0 ;
43329 int res1 = 0 ;
43330 bool temp2 = false ;
43331 PyObject * obj0 = 0 ;
43332 PyObject * obj1 = 0 ;
43333 char * kwnames[] = {
43334 (char *) "self",(char *) "str", NULL
43335 };
43336
43337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",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_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43341 }
43342 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43343 {
43344 arg2 = wxString_in_helper(obj1);
43345 if (arg2 == NULL) SWIG_fail;
43346 temp2 = true;
43347 }
43348 {
43349 PyThreadState* __tstate = wxPyBeginAllowThreads();
43350 (arg1)->SetHelp((wxString const &)*arg2);
43351 wxPyEndAllowThreads(__tstate);
43352 if (PyErr_Occurred()) SWIG_fail;
43353 }
43354 resultobj = SWIG_Py_Void();
43355 {
43356 if (temp2)
43357 delete arg2;
43358 }
43359 return resultobj;
43360 fail:
43361 {
43362 if (temp2)
43363 delete arg2;
43364 }
43365 return NULL;
43366 }
43367
43368
43369 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43370 PyObject *resultobj = 0;
43371 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43372 wxString *result = 0 ;
43373 void *argp1 = 0 ;
43374 int res1 = 0 ;
43375 PyObject *swig_obj[1] ;
43376
43377 if (!args) SWIG_fail;
43378 swig_obj[0] = args;
43379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43380 if (!SWIG_IsOK(res1)) {
43381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43382 }
43383 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43384 {
43385 PyThreadState* __tstate = wxPyBeginAllowThreads();
43386 {
43387 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43388 result = (wxString *) &_result_ref;
43389 }
43390 wxPyEndAllowThreads(__tstate);
43391 if (PyErr_Occurred()) SWIG_fail;
43392 }
43393 {
43394 #if wxUSE_UNICODE
43395 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43396 #else
43397 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43398 #endif
43399 }
43400 return resultobj;
43401 fail:
43402 return NULL;
43403 }
43404
43405
43406 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43407 PyObject *resultobj = 0;
43408 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43409 wxAcceleratorEntry *result = 0 ;
43410 void *argp1 = 0 ;
43411 int res1 = 0 ;
43412 PyObject *swig_obj[1] ;
43413
43414 if (!args) SWIG_fail;
43415 swig_obj[0] = args;
43416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43417 if (!SWIG_IsOK(res1)) {
43418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43419 }
43420 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43421 {
43422 PyThreadState* __tstate = wxPyBeginAllowThreads();
43423 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43424 wxPyEndAllowThreads(__tstate);
43425 if (PyErr_Occurred()) SWIG_fail;
43426 }
43427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43428 return resultobj;
43429 fail:
43430 return NULL;
43431 }
43432
43433
43434 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43435 PyObject *resultobj = 0;
43436 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43437 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43438 void *argp1 = 0 ;
43439 int res1 = 0 ;
43440 void *argp2 = 0 ;
43441 int res2 = 0 ;
43442 PyObject * obj0 = 0 ;
43443 PyObject * obj1 = 0 ;
43444 char * kwnames[] = {
43445 (char *) "self",(char *) "accel", NULL
43446 };
43447
43448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43450 if (!SWIG_IsOK(res1)) {
43451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43452 }
43453 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43455 if (!SWIG_IsOK(res2)) {
43456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43457 }
43458 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43459 {
43460 PyThreadState* __tstate = wxPyBeginAllowThreads();
43461 (arg1)->SetAccel(arg2);
43462 wxPyEndAllowThreads(__tstate);
43463 if (PyErr_Occurred()) SWIG_fail;
43464 }
43465 resultobj = SWIG_Py_Void();
43466 return resultobj;
43467 fail:
43468 return NULL;
43469 }
43470
43471
43472 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43473 PyObject *resultobj = 0;
43474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43475 wxBitmap *arg2 = 0 ;
43476 void *argp1 = 0 ;
43477 int res1 = 0 ;
43478 void *argp2 = 0 ;
43479 int res2 = 0 ;
43480 PyObject * obj0 = 0 ;
43481 PyObject * obj1 = 0 ;
43482 char * kwnames[] = {
43483 (char *) "self",(char *) "bitmap", NULL
43484 };
43485
43486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43488 if (!SWIG_IsOK(res1)) {
43489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43490 }
43491 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43493 if (!SWIG_IsOK(res2)) {
43494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43495 }
43496 if (!argp2) {
43497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43498 }
43499 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43500 {
43501 PyThreadState* __tstate = wxPyBeginAllowThreads();
43502 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43503 wxPyEndAllowThreads(__tstate);
43504 if (PyErr_Occurred()) SWIG_fail;
43505 }
43506 resultobj = SWIG_Py_Void();
43507 return resultobj;
43508 fail:
43509 return NULL;
43510 }
43511
43512
43513 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43514 PyObject *resultobj = 0;
43515 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43516 wxBitmap *result = 0 ;
43517 void *argp1 = 0 ;
43518 int res1 = 0 ;
43519 PyObject *swig_obj[1] ;
43520
43521 if (!args) SWIG_fail;
43522 swig_obj[0] = args;
43523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43524 if (!SWIG_IsOK(res1)) {
43525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43526 }
43527 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43528 {
43529 PyThreadState* __tstate = wxPyBeginAllowThreads();
43530 {
43531 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43532 result = (wxBitmap *) &_result_ref;
43533 }
43534 wxPyEndAllowThreads(__tstate);
43535 if (PyErr_Occurred()) SWIG_fail;
43536 }
43537 {
43538 wxBitmap* resultptr = new wxBitmap(*result);
43539 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43540 }
43541 return resultobj;
43542 fail:
43543 return NULL;
43544 }
43545
43546
43547 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43548 PyObject *resultobj = 0;
43549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43550 wxFont *arg2 = 0 ;
43551 void *argp1 = 0 ;
43552 int res1 = 0 ;
43553 void *argp2 = 0 ;
43554 int res2 = 0 ;
43555 PyObject * obj0 = 0 ;
43556 PyObject * obj1 = 0 ;
43557 char * kwnames[] = {
43558 (char *) "self",(char *) "font", NULL
43559 };
43560
43561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43563 if (!SWIG_IsOK(res1)) {
43564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43565 }
43566 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43567 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43568 if (!SWIG_IsOK(res2)) {
43569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43570 }
43571 if (!argp2) {
43572 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43573 }
43574 arg2 = reinterpret_cast< wxFont * >(argp2);
43575 {
43576 PyThreadState* __tstate = wxPyBeginAllowThreads();
43577 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43578 wxPyEndAllowThreads(__tstate);
43579 if (PyErr_Occurred()) SWIG_fail;
43580 }
43581 resultobj = SWIG_Py_Void();
43582 return resultobj;
43583 fail:
43584 return NULL;
43585 }
43586
43587
43588 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43589 PyObject *resultobj = 0;
43590 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43591 wxFont result;
43592 void *argp1 = 0 ;
43593 int res1 = 0 ;
43594 PyObject *swig_obj[1] ;
43595
43596 if (!args) SWIG_fail;
43597 swig_obj[0] = args;
43598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43599 if (!SWIG_IsOK(res1)) {
43600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43601 }
43602 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43603 {
43604 PyThreadState* __tstate = wxPyBeginAllowThreads();
43605 result = wxMenuItem_GetFont(arg1);
43606 wxPyEndAllowThreads(__tstate);
43607 if (PyErr_Occurred()) SWIG_fail;
43608 }
43609 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43610 return resultobj;
43611 fail:
43612 return NULL;
43613 }
43614
43615
43616 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43617 PyObject *resultobj = 0;
43618 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43619 wxColour *arg2 = 0 ;
43620 void *argp1 = 0 ;
43621 int res1 = 0 ;
43622 wxColour temp2 ;
43623 PyObject * obj0 = 0 ;
43624 PyObject * obj1 = 0 ;
43625 char * kwnames[] = {
43626 (char *) "self",(char *) "colText", NULL
43627 };
43628
43629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43631 if (!SWIG_IsOK(res1)) {
43632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43633 }
43634 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43635 {
43636 arg2 = &temp2;
43637 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43638 }
43639 {
43640 PyThreadState* __tstate = wxPyBeginAllowThreads();
43641 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43642 wxPyEndAllowThreads(__tstate);
43643 if (PyErr_Occurred()) SWIG_fail;
43644 }
43645 resultobj = SWIG_Py_Void();
43646 return resultobj;
43647 fail:
43648 return NULL;
43649 }
43650
43651
43652 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43653 PyObject *resultobj = 0;
43654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43655 wxColour result;
43656 void *argp1 = 0 ;
43657 int res1 = 0 ;
43658 PyObject *swig_obj[1] ;
43659
43660 if (!args) SWIG_fail;
43661 swig_obj[0] = args;
43662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43663 if (!SWIG_IsOK(res1)) {
43664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43665 }
43666 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43667 {
43668 PyThreadState* __tstate = wxPyBeginAllowThreads();
43669 result = wxMenuItem_GetTextColour(arg1);
43670 wxPyEndAllowThreads(__tstate);
43671 if (PyErr_Occurred()) SWIG_fail;
43672 }
43673 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43674 return resultobj;
43675 fail:
43676 return NULL;
43677 }
43678
43679
43680 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43681 PyObject *resultobj = 0;
43682 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43683 wxColour *arg2 = 0 ;
43684 void *argp1 = 0 ;
43685 int res1 = 0 ;
43686 wxColour temp2 ;
43687 PyObject * obj0 = 0 ;
43688 PyObject * obj1 = 0 ;
43689 char * kwnames[] = {
43690 (char *) "self",(char *) "colBack", NULL
43691 };
43692
43693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43695 if (!SWIG_IsOK(res1)) {
43696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43697 }
43698 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43699 {
43700 arg2 = &temp2;
43701 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43702 }
43703 {
43704 PyThreadState* __tstate = wxPyBeginAllowThreads();
43705 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43706 wxPyEndAllowThreads(__tstate);
43707 if (PyErr_Occurred()) SWIG_fail;
43708 }
43709 resultobj = SWIG_Py_Void();
43710 return resultobj;
43711 fail:
43712 return NULL;
43713 }
43714
43715
43716 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43717 PyObject *resultobj = 0;
43718 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43719 wxColour result;
43720 void *argp1 = 0 ;
43721 int res1 = 0 ;
43722 PyObject *swig_obj[1] ;
43723
43724 if (!args) SWIG_fail;
43725 swig_obj[0] = args;
43726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43727 if (!SWIG_IsOK(res1)) {
43728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43729 }
43730 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43731 {
43732 PyThreadState* __tstate = wxPyBeginAllowThreads();
43733 result = wxMenuItem_GetBackgroundColour(arg1);
43734 wxPyEndAllowThreads(__tstate);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 }
43737 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43738 return resultobj;
43739 fail:
43740 return NULL;
43741 }
43742
43743
43744 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43745 PyObject *resultobj = 0;
43746 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43747 wxBitmap *arg2 = 0 ;
43748 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43749 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43750 void *argp1 = 0 ;
43751 int res1 = 0 ;
43752 void *argp2 = 0 ;
43753 int res2 = 0 ;
43754 void *argp3 = 0 ;
43755 int res3 = 0 ;
43756 PyObject * obj0 = 0 ;
43757 PyObject * obj1 = 0 ;
43758 PyObject * obj2 = 0 ;
43759 char * kwnames[] = {
43760 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43761 };
43762
43763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43765 if (!SWIG_IsOK(res1)) {
43766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43767 }
43768 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43769 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43770 if (!SWIG_IsOK(res2)) {
43771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43772 }
43773 if (!argp2) {
43774 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43775 }
43776 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43777 if (obj2) {
43778 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43779 if (!SWIG_IsOK(res3)) {
43780 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43781 }
43782 if (!argp3) {
43783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43784 }
43785 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43786 }
43787 {
43788 PyThreadState* __tstate = wxPyBeginAllowThreads();
43789 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43790 wxPyEndAllowThreads(__tstate);
43791 if (PyErr_Occurred()) SWIG_fail;
43792 }
43793 resultobj = SWIG_Py_Void();
43794 return resultobj;
43795 fail:
43796 return NULL;
43797 }
43798
43799
43800 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43801 PyObject *resultobj = 0;
43802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43803 wxBitmap *arg2 = 0 ;
43804 void *argp1 = 0 ;
43805 int res1 = 0 ;
43806 void *argp2 = 0 ;
43807 int res2 = 0 ;
43808 PyObject * obj0 = 0 ;
43809 PyObject * obj1 = 0 ;
43810 char * kwnames[] = {
43811 (char *) "self",(char *) "bmpDisabled", NULL
43812 };
43813
43814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43816 if (!SWIG_IsOK(res1)) {
43817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43818 }
43819 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43820 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43821 if (!SWIG_IsOK(res2)) {
43822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43823 }
43824 if (!argp2) {
43825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43826 }
43827 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43828 {
43829 PyThreadState* __tstate = wxPyBeginAllowThreads();
43830 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43831 wxPyEndAllowThreads(__tstate);
43832 if (PyErr_Occurred()) SWIG_fail;
43833 }
43834 resultobj = SWIG_Py_Void();
43835 return resultobj;
43836 fail:
43837 return NULL;
43838 }
43839
43840
43841 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43842 PyObject *resultobj = 0;
43843 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43844 wxBitmap *result = 0 ;
43845 void *argp1 = 0 ;
43846 int res1 = 0 ;
43847 PyObject *swig_obj[1] ;
43848
43849 if (!args) SWIG_fail;
43850 swig_obj[0] = args;
43851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43852 if (!SWIG_IsOK(res1)) {
43853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43854 }
43855 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43856 {
43857 PyThreadState* __tstate = wxPyBeginAllowThreads();
43858 {
43859 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43860 result = (wxBitmap *) &_result_ref;
43861 }
43862 wxPyEndAllowThreads(__tstate);
43863 if (PyErr_Occurred()) SWIG_fail;
43864 }
43865 {
43866 wxBitmap* resultptr = new wxBitmap(*result);
43867 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43868 }
43869 return resultobj;
43870 fail:
43871 return NULL;
43872 }
43873
43874
43875 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43876 PyObject *resultobj = 0;
43877 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43878 int arg2 ;
43879 void *argp1 = 0 ;
43880 int res1 = 0 ;
43881 int val2 ;
43882 int ecode2 = 0 ;
43883 PyObject * obj0 = 0 ;
43884 PyObject * obj1 = 0 ;
43885 char * kwnames[] = {
43886 (char *) "self",(char *) "nWidth", NULL
43887 };
43888
43889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43891 if (!SWIG_IsOK(res1)) {
43892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43893 }
43894 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43895 ecode2 = SWIG_AsVal_int(obj1, &val2);
43896 if (!SWIG_IsOK(ecode2)) {
43897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43898 }
43899 arg2 = static_cast< int >(val2);
43900 {
43901 PyThreadState* __tstate = wxPyBeginAllowThreads();
43902 wxMenuItem_SetMarginWidth(arg1,arg2);
43903 wxPyEndAllowThreads(__tstate);
43904 if (PyErr_Occurred()) SWIG_fail;
43905 }
43906 resultobj = SWIG_Py_Void();
43907 return resultobj;
43908 fail:
43909 return NULL;
43910 }
43911
43912
43913 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43914 PyObject *resultobj = 0;
43915 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43916 int result;
43917 void *argp1 = 0 ;
43918 int res1 = 0 ;
43919 PyObject *swig_obj[1] ;
43920
43921 if (!args) SWIG_fail;
43922 swig_obj[0] = args;
43923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43924 if (!SWIG_IsOK(res1)) {
43925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43926 }
43927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43928 {
43929 PyThreadState* __tstate = wxPyBeginAllowThreads();
43930 result = (int)wxMenuItem_GetMarginWidth(arg1);
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 resultobj = SWIG_From_int(static_cast< int >(result));
43935 return resultobj;
43936 fail:
43937 return NULL;
43938 }
43939
43940
43941 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43942 PyObject *resultobj = 0;
43943 int result;
43944
43945 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43946 {
43947 PyThreadState* __tstate = wxPyBeginAllowThreads();
43948 result = (int)wxMenuItem_GetDefaultMarginWidth();
43949 wxPyEndAllowThreads(__tstate);
43950 if (PyErr_Occurred()) SWIG_fail;
43951 }
43952 resultobj = SWIG_From_int(static_cast< int >(result));
43953 return resultobj;
43954 fail:
43955 return NULL;
43956 }
43957
43958
43959 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43960 PyObject *resultobj = 0;
43961 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43962 bool result;
43963 void *argp1 = 0 ;
43964 int res1 = 0 ;
43965 PyObject *swig_obj[1] ;
43966
43967 if (!args) SWIG_fail;
43968 swig_obj[0] = args;
43969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43970 if (!SWIG_IsOK(res1)) {
43971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43972 }
43973 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43974 {
43975 PyThreadState* __tstate = wxPyBeginAllowThreads();
43976 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43977 wxPyEndAllowThreads(__tstate);
43978 if (PyErr_Occurred()) SWIG_fail;
43979 }
43980 {
43981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43982 }
43983 return resultobj;
43984 fail:
43985 return NULL;
43986 }
43987
43988
43989 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43990 PyObject *resultobj = 0;
43991 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43992 bool arg2 = (bool) true ;
43993 void *argp1 = 0 ;
43994 int res1 = 0 ;
43995 bool val2 ;
43996 int ecode2 = 0 ;
43997 PyObject * obj0 = 0 ;
43998 PyObject * obj1 = 0 ;
43999 char * kwnames[] = {
44000 (char *) "self",(char *) "ownerDrawn", NULL
44001 };
44002
44003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44005 if (!SWIG_IsOK(res1)) {
44006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44007 }
44008 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44009 if (obj1) {
44010 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44011 if (!SWIG_IsOK(ecode2)) {
44012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44013 }
44014 arg2 = static_cast< bool >(val2);
44015 }
44016 {
44017 PyThreadState* __tstate = wxPyBeginAllowThreads();
44018 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44019 wxPyEndAllowThreads(__tstate);
44020 if (PyErr_Occurred()) SWIG_fail;
44021 }
44022 resultobj = SWIG_Py_Void();
44023 return resultobj;
44024 fail:
44025 return NULL;
44026 }
44027
44028
44029 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44030 PyObject *resultobj = 0;
44031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44032 void *argp1 = 0 ;
44033 int res1 = 0 ;
44034 PyObject *swig_obj[1] ;
44035
44036 if (!args) SWIG_fail;
44037 swig_obj[0] = args;
44038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44039 if (!SWIG_IsOK(res1)) {
44040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44041 }
44042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44043 {
44044 PyThreadState* __tstate = wxPyBeginAllowThreads();
44045 wxMenuItem_ResetOwnerDrawn(arg1);
44046 wxPyEndAllowThreads(__tstate);
44047 if (PyErr_Occurred()) SWIG_fail;
44048 }
44049 resultobj = SWIG_Py_Void();
44050 return resultobj;
44051 fail:
44052 return NULL;
44053 }
44054
44055
44056 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44057 PyObject *obj;
44058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44059 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44060 return SWIG_Py_Void();
44061 }
44062
44063 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44064 return SWIG_Python_InitShadowInstance(args);
44065 }
44066
44067 SWIGINTERN int ControlNameStr_set(PyObject *) {
44068 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44069 return 1;
44070 }
44071
44072
44073 SWIGINTERN PyObject *ControlNameStr_get(void) {
44074 PyObject *pyobj = 0;
44075
44076 {
44077 #if wxUSE_UNICODE
44078 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44079 #else
44080 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44081 #endif
44082 }
44083 return pyobj;
44084 }
44085
44086
44087 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44088 PyObject *resultobj = 0;
44089 wxWindow *arg1 = (wxWindow *) 0 ;
44090 int arg2 = (int) -1 ;
44091 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44092 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44093 wxSize const &arg4_defvalue = wxDefaultSize ;
44094 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44095 long arg5 = (long) 0 ;
44096 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44097 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44098 wxString const &arg7_defvalue = wxPyControlNameStr ;
44099 wxString *arg7 = (wxString *) &arg7_defvalue ;
44100 wxControl *result = 0 ;
44101 void *argp1 = 0 ;
44102 int res1 = 0 ;
44103 int val2 ;
44104 int ecode2 = 0 ;
44105 wxPoint temp3 ;
44106 wxSize temp4 ;
44107 long val5 ;
44108 int ecode5 = 0 ;
44109 void *argp6 = 0 ;
44110 int res6 = 0 ;
44111 bool temp7 = false ;
44112 PyObject * obj0 = 0 ;
44113 PyObject * obj1 = 0 ;
44114 PyObject * obj2 = 0 ;
44115 PyObject * obj3 = 0 ;
44116 PyObject * obj4 = 0 ;
44117 PyObject * obj5 = 0 ;
44118 PyObject * obj6 = 0 ;
44119 char * kwnames[] = {
44120 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44121 };
44122
44123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44125 if (!SWIG_IsOK(res1)) {
44126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44127 }
44128 arg1 = reinterpret_cast< wxWindow * >(argp1);
44129 if (obj1) {
44130 ecode2 = SWIG_AsVal_int(obj1, &val2);
44131 if (!SWIG_IsOK(ecode2)) {
44132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44133 }
44134 arg2 = static_cast< int >(val2);
44135 }
44136 if (obj2) {
44137 {
44138 arg3 = &temp3;
44139 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44140 }
44141 }
44142 if (obj3) {
44143 {
44144 arg4 = &temp4;
44145 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44146 }
44147 }
44148 if (obj4) {
44149 ecode5 = SWIG_AsVal_long(obj4, &val5);
44150 if (!SWIG_IsOK(ecode5)) {
44151 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44152 }
44153 arg5 = static_cast< long >(val5);
44154 }
44155 if (obj5) {
44156 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44157 if (!SWIG_IsOK(res6)) {
44158 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44159 }
44160 if (!argp6) {
44161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44162 }
44163 arg6 = reinterpret_cast< wxValidator * >(argp6);
44164 }
44165 if (obj6) {
44166 {
44167 arg7 = wxString_in_helper(obj6);
44168 if (arg7 == NULL) SWIG_fail;
44169 temp7 = true;
44170 }
44171 }
44172 {
44173 if (!wxPyCheckForApp()) SWIG_fail;
44174 PyThreadState* __tstate = wxPyBeginAllowThreads();
44175 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44176 wxPyEndAllowThreads(__tstate);
44177 if (PyErr_Occurred()) SWIG_fail;
44178 }
44179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44180 {
44181 if (temp7)
44182 delete arg7;
44183 }
44184 return resultobj;
44185 fail:
44186 {
44187 if (temp7)
44188 delete arg7;
44189 }
44190 return NULL;
44191 }
44192
44193
44194 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44195 PyObject *resultobj = 0;
44196 wxControl *result = 0 ;
44197
44198 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44199 {
44200 if (!wxPyCheckForApp()) SWIG_fail;
44201 PyThreadState* __tstate = wxPyBeginAllowThreads();
44202 result = (wxControl *)new wxControl();
44203 wxPyEndAllowThreads(__tstate);
44204 if (PyErr_Occurred()) SWIG_fail;
44205 }
44206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44207 return resultobj;
44208 fail:
44209 return NULL;
44210 }
44211
44212
44213 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44214 PyObject *resultobj = 0;
44215 wxControl *arg1 = (wxControl *) 0 ;
44216 wxWindow *arg2 = (wxWindow *) 0 ;
44217 int arg3 = (int) -1 ;
44218 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44219 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44220 wxSize const &arg5_defvalue = wxDefaultSize ;
44221 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44222 long arg6 = (long) 0 ;
44223 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44224 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44225 wxString const &arg8_defvalue = wxPyControlNameStr ;
44226 wxString *arg8 = (wxString *) &arg8_defvalue ;
44227 bool result;
44228 void *argp1 = 0 ;
44229 int res1 = 0 ;
44230 void *argp2 = 0 ;
44231 int res2 = 0 ;
44232 int val3 ;
44233 int ecode3 = 0 ;
44234 wxPoint temp4 ;
44235 wxSize temp5 ;
44236 long val6 ;
44237 int ecode6 = 0 ;
44238 void *argp7 = 0 ;
44239 int res7 = 0 ;
44240 bool temp8 = false ;
44241 PyObject * obj0 = 0 ;
44242 PyObject * obj1 = 0 ;
44243 PyObject * obj2 = 0 ;
44244 PyObject * obj3 = 0 ;
44245 PyObject * obj4 = 0 ;
44246 PyObject * obj5 = 0 ;
44247 PyObject * obj6 = 0 ;
44248 PyObject * obj7 = 0 ;
44249 char * kwnames[] = {
44250 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44251 };
44252
44253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44255 if (!SWIG_IsOK(res1)) {
44256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44257 }
44258 arg1 = reinterpret_cast< wxControl * >(argp1);
44259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44260 if (!SWIG_IsOK(res2)) {
44261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44262 }
44263 arg2 = reinterpret_cast< wxWindow * >(argp2);
44264 if (obj2) {
44265 ecode3 = SWIG_AsVal_int(obj2, &val3);
44266 if (!SWIG_IsOK(ecode3)) {
44267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44268 }
44269 arg3 = static_cast< int >(val3);
44270 }
44271 if (obj3) {
44272 {
44273 arg4 = &temp4;
44274 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44275 }
44276 }
44277 if (obj4) {
44278 {
44279 arg5 = &temp5;
44280 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44281 }
44282 }
44283 if (obj5) {
44284 ecode6 = SWIG_AsVal_long(obj5, &val6);
44285 if (!SWIG_IsOK(ecode6)) {
44286 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44287 }
44288 arg6 = static_cast< long >(val6);
44289 }
44290 if (obj6) {
44291 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44292 if (!SWIG_IsOK(res7)) {
44293 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44294 }
44295 if (!argp7) {
44296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44297 }
44298 arg7 = reinterpret_cast< wxValidator * >(argp7);
44299 }
44300 if (obj7) {
44301 {
44302 arg8 = wxString_in_helper(obj7);
44303 if (arg8 == NULL) SWIG_fail;
44304 temp8 = true;
44305 }
44306 }
44307 {
44308 PyThreadState* __tstate = wxPyBeginAllowThreads();
44309 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44310 wxPyEndAllowThreads(__tstate);
44311 if (PyErr_Occurred()) SWIG_fail;
44312 }
44313 {
44314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44315 }
44316 {
44317 if (temp8)
44318 delete arg8;
44319 }
44320 return resultobj;
44321 fail:
44322 {
44323 if (temp8)
44324 delete arg8;
44325 }
44326 return NULL;
44327 }
44328
44329
44330 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44331 PyObject *resultobj = 0;
44332 wxControl *arg1 = (wxControl *) 0 ;
44333 int result;
44334 void *argp1 = 0 ;
44335 int res1 = 0 ;
44336 PyObject *swig_obj[1] ;
44337
44338 if (!args) SWIG_fail;
44339 swig_obj[0] = args;
44340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44341 if (!SWIG_IsOK(res1)) {
44342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44343 }
44344 arg1 = reinterpret_cast< wxControl * >(argp1);
44345 {
44346 PyThreadState* __tstate = wxPyBeginAllowThreads();
44347 result = (int)((wxControl const *)arg1)->GetAlignment();
44348 wxPyEndAllowThreads(__tstate);
44349 if (PyErr_Occurred()) SWIG_fail;
44350 }
44351 resultobj = SWIG_From_int(static_cast< int >(result));
44352 return resultobj;
44353 fail:
44354 return NULL;
44355 }
44356
44357
44358 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44359 PyObject *resultobj = 0;
44360 wxControl *arg1 = (wxControl *) 0 ;
44361 wxString result;
44362 void *argp1 = 0 ;
44363 int res1 = 0 ;
44364 PyObject *swig_obj[1] ;
44365
44366 if (!args) SWIG_fail;
44367 swig_obj[0] = args;
44368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44369 if (!SWIG_IsOK(res1)) {
44370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44371 }
44372 arg1 = reinterpret_cast< wxControl * >(argp1);
44373 {
44374 PyThreadState* __tstate = wxPyBeginAllowThreads();
44375 result = ((wxControl const *)arg1)->GetLabelText();
44376 wxPyEndAllowThreads(__tstate);
44377 if (PyErr_Occurred()) SWIG_fail;
44378 }
44379 {
44380 #if wxUSE_UNICODE
44381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44382 #else
44383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44384 #endif
44385 }
44386 return resultobj;
44387 fail:
44388 return NULL;
44389 }
44390
44391
44392 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44393 PyObject *resultobj = 0;
44394 wxControl *arg1 = (wxControl *) 0 ;
44395 wxCommandEvent *arg2 = 0 ;
44396 void *argp1 = 0 ;
44397 int res1 = 0 ;
44398 void *argp2 = 0 ;
44399 int res2 = 0 ;
44400 PyObject * obj0 = 0 ;
44401 PyObject * obj1 = 0 ;
44402 char * kwnames[] = {
44403 (char *) "self",(char *) "event", NULL
44404 };
44405
44406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44408 if (!SWIG_IsOK(res1)) {
44409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44410 }
44411 arg1 = reinterpret_cast< wxControl * >(argp1);
44412 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44413 if (!SWIG_IsOK(res2)) {
44414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44415 }
44416 if (!argp2) {
44417 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44418 }
44419 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44420 {
44421 PyThreadState* __tstate = wxPyBeginAllowThreads();
44422 (arg1)->Command(*arg2);
44423 wxPyEndAllowThreads(__tstate);
44424 if (PyErr_Occurred()) SWIG_fail;
44425 }
44426 resultobj = SWIG_Py_Void();
44427 return resultobj;
44428 fail:
44429 return NULL;
44430 }
44431
44432
44433 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44434 PyObject *resultobj = 0;
44435 wxControl *arg1 = (wxControl *) 0 ;
44436 wxString result;
44437 void *argp1 = 0 ;
44438 int res1 = 0 ;
44439 PyObject *swig_obj[1] ;
44440
44441 if (!args) SWIG_fail;
44442 swig_obj[0] = args;
44443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44444 if (!SWIG_IsOK(res1)) {
44445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44446 }
44447 arg1 = reinterpret_cast< wxControl * >(argp1);
44448 {
44449 PyThreadState* __tstate = wxPyBeginAllowThreads();
44450 result = (arg1)->GetLabel();
44451 wxPyEndAllowThreads(__tstate);
44452 if (PyErr_Occurred()) SWIG_fail;
44453 }
44454 {
44455 #if wxUSE_UNICODE
44456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44457 #else
44458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44459 #endif
44460 }
44461 return resultobj;
44462 fail:
44463 return NULL;
44464 }
44465
44466
44467 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44468 PyObject *resultobj = 0;
44469 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44470 SwigValueWrapper<wxVisualAttributes > result;
44471 int val1 ;
44472 int ecode1 = 0 ;
44473 PyObject * obj0 = 0 ;
44474 char * kwnames[] = {
44475 (char *) "variant", NULL
44476 };
44477
44478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44479 if (obj0) {
44480 ecode1 = SWIG_AsVal_int(obj0, &val1);
44481 if (!SWIG_IsOK(ecode1)) {
44482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44483 }
44484 arg1 = static_cast< wxWindowVariant >(val1);
44485 }
44486 {
44487 if (!wxPyCheckForApp()) SWIG_fail;
44488 PyThreadState* __tstate = wxPyBeginAllowThreads();
44489 result = wxControl::GetClassDefaultAttributes(arg1);
44490 wxPyEndAllowThreads(__tstate);
44491 if (PyErr_Occurred()) SWIG_fail;
44492 }
44493 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44494 return resultobj;
44495 fail:
44496 return NULL;
44497 }
44498
44499
44500 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44501 PyObject *obj;
44502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44503 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44504 return SWIG_Py_Void();
44505 }
44506
44507 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44508 return SWIG_Python_InitShadowInstance(args);
44509 }
44510
44511 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44512 PyObject *resultobj = 0;
44513 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44514 wxString *arg2 = 0 ;
44515 PyObject *arg3 = (PyObject *) NULL ;
44516 int result;
44517 void *argp1 = 0 ;
44518 int res1 = 0 ;
44519 bool temp2 = false ;
44520 PyObject * obj0 = 0 ;
44521 PyObject * obj1 = 0 ;
44522 PyObject * obj2 = 0 ;
44523 char * kwnames[] = {
44524 (char *) "self",(char *) "item",(char *) "clientData", NULL
44525 };
44526
44527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44529 if (!SWIG_IsOK(res1)) {
44530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44531 }
44532 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44533 {
44534 arg2 = wxString_in_helper(obj1);
44535 if (arg2 == NULL) SWIG_fail;
44536 temp2 = true;
44537 }
44538 if (obj2) {
44539 arg3 = obj2;
44540 }
44541 {
44542 PyThreadState* __tstate = wxPyBeginAllowThreads();
44543 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44544 wxPyEndAllowThreads(__tstate);
44545 if (PyErr_Occurred()) SWIG_fail;
44546 }
44547 resultobj = SWIG_From_int(static_cast< int >(result));
44548 {
44549 if (temp2)
44550 delete arg2;
44551 }
44552 return resultobj;
44553 fail:
44554 {
44555 if (temp2)
44556 delete arg2;
44557 }
44558 return NULL;
44559 }
44560
44561
44562 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44563 PyObject *resultobj = 0;
44564 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44565 wxArrayString *arg2 = 0 ;
44566 void *argp1 = 0 ;
44567 int res1 = 0 ;
44568 bool temp2 = false ;
44569 PyObject * obj0 = 0 ;
44570 PyObject * obj1 = 0 ;
44571 char * kwnames[] = {
44572 (char *) "self",(char *) "strings", NULL
44573 };
44574
44575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44577 if (!SWIG_IsOK(res1)) {
44578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44579 }
44580 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44581 {
44582 if (! PySequence_Check(obj1)) {
44583 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44584 SWIG_fail;
44585 }
44586 arg2 = new wxArrayString;
44587 temp2 = true;
44588 int i, len=PySequence_Length(obj1);
44589 for (i=0; i<len; i++) {
44590 PyObject* item = PySequence_GetItem(obj1, i);
44591 wxString* s = wxString_in_helper(item);
44592 if (PyErr_Occurred()) SWIG_fail;
44593 arg2->Add(*s);
44594 delete s;
44595 Py_DECREF(item);
44596 }
44597 }
44598 {
44599 PyThreadState* __tstate = wxPyBeginAllowThreads();
44600 (arg1)->Append((wxArrayString const &)*arg2);
44601 wxPyEndAllowThreads(__tstate);
44602 if (PyErr_Occurred()) SWIG_fail;
44603 }
44604 resultobj = SWIG_Py_Void();
44605 {
44606 if (temp2) delete arg2;
44607 }
44608 return resultobj;
44609 fail:
44610 {
44611 if (temp2) delete arg2;
44612 }
44613 return NULL;
44614 }
44615
44616
44617 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44618 PyObject *resultobj = 0;
44619 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44620 wxString *arg2 = 0 ;
44621 unsigned int arg3 ;
44622 PyObject *arg4 = (PyObject *) NULL ;
44623 int result;
44624 void *argp1 = 0 ;
44625 int res1 = 0 ;
44626 bool temp2 = false ;
44627 unsigned int val3 ;
44628 int ecode3 = 0 ;
44629 PyObject * obj0 = 0 ;
44630 PyObject * obj1 = 0 ;
44631 PyObject * obj2 = 0 ;
44632 PyObject * obj3 = 0 ;
44633 char * kwnames[] = {
44634 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44635 };
44636
44637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44639 if (!SWIG_IsOK(res1)) {
44640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44641 }
44642 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44643 {
44644 arg2 = wxString_in_helper(obj1);
44645 if (arg2 == NULL) SWIG_fail;
44646 temp2 = true;
44647 }
44648 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44649 if (!SWIG_IsOK(ecode3)) {
44650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44651 }
44652 arg3 = static_cast< unsigned int >(val3);
44653 if (obj3) {
44654 arg4 = obj3;
44655 }
44656 {
44657 PyThreadState* __tstate = wxPyBeginAllowThreads();
44658 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44659 wxPyEndAllowThreads(__tstate);
44660 if (PyErr_Occurred()) SWIG_fail;
44661 }
44662 resultobj = SWIG_From_int(static_cast< int >(result));
44663 {
44664 if (temp2)
44665 delete arg2;
44666 }
44667 return resultobj;
44668 fail:
44669 {
44670 if (temp2)
44671 delete arg2;
44672 }
44673 return NULL;
44674 }
44675
44676
44677 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44678 PyObject *resultobj = 0;
44679 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44680 void *argp1 = 0 ;
44681 int res1 = 0 ;
44682 PyObject *swig_obj[1] ;
44683
44684 if (!args) SWIG_fail;
44685 swig_obj[0] = args;
44686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44687 if (!SWIG_IsOK(res1)) {
44688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44689 }
44690 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44691 {
44692 PyThreadState* __tstate = wxPyBeginAllowThreads();
44693 (arg1)->Clear();
44694 wxPyEndAllowThreads(__tstate);
44695 if (PyErr_Occurred()) SWIG_fail;
44696 }
44697 resultobj = SWIG_Py_Void();
44698 return resultobj;
44699 fail:
44700 return NULL;
44701 }
44702
44703
44704 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44705 PyObject *resultobj = 0;
44706 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44707 unsigned int arg2 ;
44708 void *argp1 = 0 ;
44709 int res1 = 0 ;
44710 unsigned int val2 ;
44711 int ecode2 = 0 ;
44712 PyObject * obj0 = 0 ;
44713 PyObject * obj1 = 0 ;
44714 char * kwnames[] = {
44715 (char *) "self",(char *) "n", NULL
44716 };
44717
44718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44720 if (!SWIG_IsOK(res1)) {
44721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44722 }
44723 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44724 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44725 if (!SWIG_IsOK(ecode2)) {
44726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44727 }
44728 arg2 = static_cast< unsigned int >(val2);
44729 {
44730 PyThreadState* __tstate = wxPyBeginAllowThreads();
44731 (arg1)->Delete(arg2);
44732 wxPyEndAllowThreads(__tstate);
44733 if (PyErr_Occurred()) SWIG_fail;
44734 }
44735 resultobj = SWIG_Py_Void();
44736 return resultobj;
44737 fail:
44738 return NULL;
44739 }
44740
44741
44742 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44743 PyObject *resultobj = 0;
44744 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44745 unsigned int arg2 ;
44746 PyObject *result = 0 ;
44747 void *argp1 = 0 ;
44748 int res1 = 0 ;
44749 unsigned int val2 ;
44750 int ecode2 = 0 ;
44751 PyObject * obj0 = 0 ;
44752 PyObject * obj1 = 0 ;
44753 char * kwnames[] = {
44754 (char *) "self",(char *) "n", NULL
44755 };
44756
44757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44759 if (!SWIG_IsOK(res1)) {
44760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44761 }
44762 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44763 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44764 if (!SWIG_IsOK(ecode2)) {
44765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44766 }
44767 arg2 = static_cast< unsigned int >(val2);
44768 {
44769 PyThreadState* __tstate = wxPyBeginAllowThreads();
44770 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44771 wxPyEndAllowThreads(__tstate);
44772 if (PyErr_Occurred()) SWIG_fail;
44773 }
44774 resultobj = result;
44775 return resultobj;
44776 fail:
44777 return NULL;
44778 }
44779
44780
44781 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44782 PyObject *resultobj = 0;
44783 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44784 unsigned int arg2 ;
44785 PyObject *arg3 = (PyObject *) 0 ;
44786 void *argp1 = 0 ;
44787 int res1 = 0 ;
44788 unsigned int val2 ;
44789 int ecode2 = 0 ;
44790 PyObject * obj0 = 0 ;
44791 PyObject * obj1 = 0 ;
44792 PyObject * obj2 = 0 ;
44793 char * kwnames[] = {
44794 (char *) "self",(char *) "n",(char *) "clientData", NULL
44795 };
44796
44797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44799 if (!SWIG_IsOK(res1)) {
44800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44801 }
44802 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44803 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44804 if (!SWIG_IsOK(ecode2)) {
44805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44806 }
44807 arg2 = static_cast< unsigned int >(val2);
44808 arg3 = obj2;
44809 {
44810 PyThreadState* __tstate = wxPyBeginAllowThreads();
44811 wxItemContainer_SetClientData(arg1,arg2,arg3);
44812 wxPyEndAllowThreads(__tstate);
44813 if (PyErr_Occurred()) SWIG_fail;
44814 }
44815 resultobj = SWIG_Py_Void();
44816 return resultobj;
44817 fail:
44818 return NULL;
44819 }
44820
44821
44822 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44823 PyObject *resultobj = 0;
44824 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44825 unsigned int result;
44826 void *argp1 = 0 ;
44827 int res1 = 0 ;
44828 PyObject *swig_obj[1] ;
44829
44830 if (!args) SWIG_fail;
44831 swig_obj[0] = args;
44832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44833 if (!SWIG_IsOK(res1)) {
44834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44835 }
44836 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44837 {
44838 PyThreadState* __tstate = wxPyBeginAllowThreads();
44839 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44840 wxPyEndAllowThreads(__tstate);
44841 if (PyErr_Occurred()) SWIG_fail;
44842 }
44843 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44844 return resultobj;
44845 fail:
44846 return NULL;
44847 }
44848
44849
44850 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44851 PyObject *resultobj = 0;
44852 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44853 bool result;
44854 void *argp1 = 0 ;
44855 int res1 = 0 ;
44856 PyObject *swig_obj[1] ;
44857
44858 if (!args) SWIG_fail;
44859 swig_obj[0] = args;
44860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44861 if (!SWIG_IsOK(res1)) {
44862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44863 }
44864 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44865 {
44866 PyThreadState* __tstate = wxPyBeginAllowThreads();
44867 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44868 wxPyEndAllowThreads(__tstate);
44869 if (PyErr_Occurred()) SWIG_fail;
44870 }
44871 {
44872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44873 }
44874 return resultobj;
44875 fail:
44876 return NULL;
44877 }
44878
44879
44880 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44881 PyObject *resultobj = 0;
44882 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44883 unsigned int arg2 ;
44884 wxString result;
44885 void *argp1 = 0 ;
44886 int res1 = 0 ;
44887 unsigned int val2 ;
44888 int ecode2 = 0 ;
44889 PyObject * obj0 = 0 ;
44890 PyObject * obj1 = 0 ;
44891 char * kwnames[] = {
44892 (char *) "self",(char *) "n", NULL
44893 };
44894
44895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44897 if (!SWIG_IsOK(res1)) {
44898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44899 }
44900 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44901 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44902 if (!SWIG_IsOK(ecode2)) {
44903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44904 }
44905 arg2 = static_cast< unsigned int >(val2);
44906 {
44907 PyThreadState* __tstate = wxPyBeginAllowThreads();
44908 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44909 wxPyEndAllowThreads(__tstate);
44910 if (PyErr_Occurred()) SWIG_fail;
44911 }
44912 {
44913 #if wxUSE_UNICODE
44914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44915 #else
44916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44917 #endif
44918 }
44919 return resultobj;
44920 fail:
44921 return NULL;
44922 }
44923
44924
44925 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44926 PyObject *resultobj = 0;
44927 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44928 wxArrayString result;
44929 void *argp1 = 0 ;
44930 int res1 = 0 ;
44931 PyObject *swig_obj[1] ;
44932
44933 if (!args) SWIG_fail;
44934 swig_obj[0] = args;
44935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44936 if (!SWIG_IsOK(res1)) {
44937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44938 }
44939 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44940 {
44941 PyThreadState* __tstate = wxPyBeginAllowThreads();
44942 result = ((wxItemContainer const *)arg1)->GetStrings();
44943 wxPyEndAllowThreads(__tstate);
44944 if (PyErr_Occurred()) SWIG_fail;
44945 }
44946 {
44947 resultobj = wxArrayString2PyList_helper(result);
44948 }
44949 return resultobj;
44950 fail:
44951 return NULL;
44952 }
44953
44954
44955 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44956 PyObject *resultobj = 0;
44957 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44958 unsigned int arg2 ;
44959 wxString *arg3 = 0 ;
44960 void *argp1 = 0 ;
44961 int res1 = 0 ;
44962 unsigned int val2 ;
44963 int ecode2 = 0 ;
44964 bool temp3 = false ;
44965 PyObject * obj0 = 0 ;
44966 PyObject * obj1 = 0 ;
44967 PyObject * obj2 = 0 ;
44968 char * kwnames[] = {
44969 (char *) "self",(char *) "n",(char *) "s", NULL
44970 };
44971
44972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44974 if (!SWIG_IsOK(res1)) {
44975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44976 }
44977 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44978 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44979 if (!SWIG_IsOK(ecode2)) {
44980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44981 }
44982 arg2 = static_cast< unsigned int >(val2);
44983 {
44984 arg3 = wxString_in_helper(obj2);
44985 if (arg3 == NULL) SWIG_fail;
44986 temp3 = true;
44987 }
44988 {
44989 PyThreadState* __tstate = wxPyBeginAllowThreads();
44990 (arg1)->SetString(arg2,(wxString const &)*arg3);
44991 wxPyEndAllowThreads(__tstate);
44992 if (PyErr_Occurred()) SWIG_fail;
44993 }
44994 resultobj = SWIG_Py_Void();
44995 {
44996 if (temp3)
44997 delete arg3;
44998 }
44999 return resultobj;
45000 fail:
45001 {
45002 if (temp3)
45003 delete arg3;
45004 }
45005 return NULL;
45006 }
45007
45008
45009 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45010 PyObject *resultobj = 0;
45011 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45012 wxString *arg2 = 0 ;
45013 int result;
45014 void *argp1 = 0 ;
45015 int res1 = 0 ;
45016 bool temp2 = false ;
45017 PyObject * obj0 = 0 ;
45018 PyObject * obj1 = 0 ;
45019 char * kwnames[] = {
45020 (char *) "self",(char *) "s", NULL
45021 };
45022
45023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45025 if (!SWIG_IsOK(res1)) {
45026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45027 }
45028 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45029 {
45030 arg2 = wxString_in_helper(obj1);
45031 if (arg2 == NULL) SWIG_fail;
45032 temp2 = true;
45033 }
45034 {
45035 PyThreadState* __tstate = wxPyBeginAllowThreads();
45036 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45037 wxPyEndAllowThreads(__tstate);
45038 if (PyErr_Occurred()) SWIG_fail;
45039 }
45040 resultobj = SWIG_From_int(static_cast< int >(result));
45041 {
45042 if (temp2)
45043 delete arg2;
45044 }
45045 return resultobj;
45046 fail:
45047 {
45048 if (temp2)
45049 delete arg2;
45050 }
45051 return NULL;
45052 }
45053
45054
45055 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45056 PyObject *resultobj = 0;
45057 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45058 int arg2 ;
45059 void *argp1 = 0 ;
45060 int res1 = 0 ;
45061 int val2 ;
45062 int ecode2 = 0 ;
45063 PyObject * obj0 = 0 ;
45064 PyObject * obj1 = 0 ;
45065 char * kwnames[] = {
45066 (char *) "self",(char *) "n", NULL
45067 };
45068
45069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45071 if (!SWIG_IsOK(res1)) {
45072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45073 }
45074 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45075 ecode2 = SWIG_AsVal_int(obj1, &val2);
45076 if (!SWIG_IsOK(ecode2)) {
45077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45078 }
45079 arg2 = static_cast< int >(val2);
45080 {
45081 PyThreadState* __tstate = wxPyBeginAllowThreads();
45082 (arg1)->SetSelection(arg2);
45083 wxPyEndAllowThreads(__tstate);
45084 if (PyErr_Occurred()) SWIG_fail;
45085 }
45086 resultobj = SWIG_Py_Void();
45087 return resultobj;
45088 fail:
45089 return NULL;
45090 }
45091
45092
45093 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45094 PyObject *resultobj = 0;
45095 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45096 int result;
45097 void *argp1 = 0 ;
45098 int res1 = 0 ;
45099 PyObject *swig_obj[1] ;
45100
45101 if (!args) SWIG_fail;
45102 swig_obj[0] = args;
45103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45104 if (!SWIG_IsOK(res1)) {
45105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45106 }
45107 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45108 {
45109 PyThreadState* __tstate = wxPyBeginAllowThreads();
45110 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45111 wxPyEndAllowThreads(__tstate);
45112 if (PyErr_Occurred()) SWIG_fail;
45113 }
45114 resultobj = SWIG_From_int(static_cast< int >(result));
45115 return resultobj;
45116 fail:
45117 return NULL;
45118 }
45119
45120
45121 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45122 PyObject *resultobj = 0;
45123 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45124 wxString *arg2 = 0 ;
45125 bool result;
45126 void *argp1 = 0 ;
45127 int res1 = 0 ;
45128 bool temp2 = false ;
45129 PyObject * obj0 = 0 ;
45130 PyObject * obj1 = 0 ;
45131 char * kwnames[] = {
45132 (char *) "self",(char *) "s", NULL
45133 };
45134
45135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45137 if (!SWIG_IsOK(res1)) {
45138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45139 }
45140 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45141 {
45142 arg2 = wxString_in_helper(obj1);
45143 if (arg2 == NULL) SWIG_fail;
45144 temp2 = true;
45145 }
45146 {
45147 PyThreadState* __tstate = wxPyBeginAllowThreads();
45148 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45149 wxPyEndAllowThreads(__tstate);
45150 if (PyErr_Occurred()) SWIG_fail;
45151 }
45152 {
45153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45154 }
45155 {
45156 if (temp2)
45157 delete arg2;
45158 }
45159 return resultobj;
45160 fail:
45161 {
45162 if (temp2)
45163 delete arg2;
45164 }
45165 return NULL;
45166 }
45167
45168
45169 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45170 PyObject *resultobj = 0;
45171 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45172 wxString result;
45173 void *argp1 = 0 ;
45174 int res1 = 0 ;
45175 PyObject *swig_obj[1] ;
45176
45177 if (!args) SWIG_fail;
45178 swig_obj[0] = args;
45179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45180 if (!SWIG_IsOK(res1)) {
45181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45182 }
45183 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45184 {
45185 PyThreadState* __tstate = wxPyBeginAllowThreads();
45186 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45187 wxPyEndAllowThreads(__tstate);
45188 if (PyErr_Occurred()) SWIG_fail;
45189 }
45190 {
45191 #if wxUSE_UNICODE
45192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45193 #else
45194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45195 #endif
45196 }
45197 return resultobj;
45198 fail:
45199 return NULL;
45200 }
45201
45202
45203 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45204 PyObject *resultobj = 0;
45205 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45206 int arg2 ;
45207 void *argp1 = 0 ;
45208 int res1 = 0 ;
45209 int val2 ;
45210 int ecode2 = 0 ;
45211 PyObject * obj0 = 0 ;
45212 PyObject * obj1 = 0 ;
45213 char * kwnames[] = {
45214 (char *) "self",(char *) "n", NULL
45215 };
45216
45217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45219 if (!SWIG_IsOK(res1)) {
45220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45221 }
45222 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45223 ecode2 = SWIG_AsVal_int(obj1, &val2);
45224 if (!SWIG_IsOK(ecode2)) {
45225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45226 }
45227 arg2 = static_cast< int >(val2);
45228 {
45229 PyThreadState* __tstate = wxPyBeginAllowThreads();
45230 (arg1)->Select(arg2);
45231 wxPyEndAllowThreads(__tstate);
45232 if (PyErr_Occurred()) SWIG_fail;
45233 }
45234 resultobj = SWIG_Py_Void();
45235 return resultobj;
45236 fail:
45237 return NULL;
45238 }
45239
45240
45241 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45242 PyObject *obj;
45243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45244 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45245 return SWIG_Py_Void();
45246 }
45247
45248 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45249 PyObject *obj;
45250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45251 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45252 return SWIG_Py_Void();
45253 }
45254
45255 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45256 PyObject *resultobj = 0;
45257 wxSizerItem *result = 0 ;
45258
45259 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45260 {
45261 PyThreadState* __tstate = wxPyBeginAllowThreads();
45262 result = (wxSizerItem *)new wxSizerItem();
45263 wxPyEndAllowThreads(__tstate);
45264 if (PyErr_Occurred()) SWIG_fail;
45265 }
45266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45267 return resultobj;
45268 fail:
45269 return NULL;
45270 }
45271
45272
45273 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45274 PyObject *resultobj = 0;
45275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45276 void *argp1 = 0 ;
45277 int res1 = 0 ;
45278 PyObject *swig_obj[1] ;
45279
45280 if (!args) SWIG_fail;
45281 swig_obj[0] = args;
45282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45283 if (!SWIG_IsOK(res1)) {
45284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45285 }
45286 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45287 {
45288 PyThreadState* __tstate = wxPyBeginAllowThreads();
45289 delete arg1;
45290
45291 wxPyEndAllowThreads(__tstate);
45292 if (PyErr_Occurred()) SWIG_fail;
45293 }
45294 resultobj = SWIG_Py_Void();
45295 return resultobj;
45296 fail:
45297 return NULL;
45298 }
45299
45300
45301 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45302 PyObject *resultobj = 0;
45303 wxWindow *arg1 = (wxWindow *) 0 ;
45304 int arg2 ;
45305 int arg3 ;
45306 int arg4 ;
45307 PyObject *arg5 = (PyObject *) NULL ;
45308 wxSizerItem *result = 0 ;
45309 void *argp1 = 0 ;
45310 int res1 = 0 ;
45311 int val2 ;
45312 int ecode2 = 0 ;
45313 int val3 ;
45314 int ecode3 = 0 ;
45315 int val4 ;
45316 int ecode4 = 0 ;
45317 PyObject * obj0 = 0 ;
45318 PyObject * obj1 = 0 ;
45319 PyObject * obj2 = 0 ;
45320 PyObject * obj3 = 0 ;
45321 PyObject * obj4 = 0 ;
45322 char * kwnames[] = {
45323 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45324 };
45325
45326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45328 if (!SWIG_IsOK(res1)) {
45329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45330 }
45331 arg1 = reinterpret_cast< wxWindow * >(argp1);
45332 ecode2 = SWIG_AsVal_int(obj1, &val2);
45333 if (!SWIG_IsOK(ecode2)) {
45334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45335 }
45336 arg2 = static_cast< int >(val2);
45337 ecode3 = SWIG_AsVal_int(obj2, &val3);
45338 if (!SWIG_IsOK(ecode3)) {
45339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45340 }
45341 arg3 = static_cast< int >(val3);
45342 ecode4 = SWIG_AsVal_int(obj3, &val4);
45343 if (!SWIG_IsOK(ecode4)) {
45344 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45345 }
45346 arg4 = static_cast< int >(val4);
45347 if (obj4) {
45348 arg5 = obj4;
45349 }
45350 {
45351 PyThreadState* __tstate = wxPyBeginAllowThreads();
45352 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45353 wxPyEndAllowThreads(__tstate);
45354 if (PyErr_Occurred()) SWIG_fail;
45355 }
45356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45357 return resultobj;
45358 fail:
45359 return NULL;
45360 }
45361
45362
45363 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45364 PyObject *resultobj = 0;
45365 int arg1 ;
45366 int arg2 ;
45367 int arg3 ;
45368 int arg4 ;
45369 int arg5 ;
45370 PyObject *arg6 = (PyObject *) NULL ;
45371 wxSizerItem *result = 0 ;
45372 int val1 ;
45373 int ecode1 = 0 ;
45374 int val2 ;
45375 int ecode2 = 0 ;
45376 int val3 ;
45377 int ecode3 = 0 ;
45378 int val4 ;
45379 int ecode4 = 0 ;
45380 int val5 ;
45381 int ecode5 = 0 ;
45382 PyObject * obj0 = 0 ;
45383 PyObject * obj1 = 0 ;
45384 PyObject * obj2 = 0 ;
45385 PyObject * obj3 = 0 ;
45386 PyObject * obj4 = 0 ;
45387 PyObject * obj5 = 0 ;
45388 char * kwnames[] = {
45389 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45390 };
45391
45392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45393 ecode1 = SWIG_AsVal_int(obj0, &val1);
45394 if (!SWIG_IsOK(ecode1)) {
45395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45396 }
45397 arg1 = static_cast< int >(val1);
45398 ecode2 = SWIG_AsVal_int(obj1, &val2);
45399 if (!SWIG_IsOK(ecode2)) {
45400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45401 }
45402 arg2 = static_cast< int >(val2);
45403 ecode3 = SWIG_AsVal_int(obj2, &val3);
45404 if (!SWIG_IsOK(ecode3)) {
45405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45406 }
45407 arg3 = static_cast< int >(val3);
45408 ecode4 = SWIG_AsVal_int(obj3, &val4);
45409 if (!SWIG_IsOK(ecode4)) {
45410 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45411 }
45412 arg4 = static_cast< int >(val4);
45413 ecode5 = SWIG_AsVal_int(obj4, &val5);
45414 if (!SWIG_IsOK(ecode5)) {
45415 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45416 }
45417 arg5 = static_cast< int >(val5);
45418 if (obj5) {
45419 arg6 = obj5;
45420 }
45421 {
45422 PyThreadState* __tstate = wxPyBeginAllowThreads();
45423 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45424 wxPyEndAllowThreads(__tstate);
45425 if (PyErr_Occurred()) SWIG_fail;
45426 }
45427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45428 return resultobj;
45429 fail:
45430 return NULL;
45431 }
45432
45433
45434 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45435 PyObject *resultobj = 0;
45436 wxSizer *arg1 = (wxSizer *) 0 ;
45437 int arg2 ;
45438 int arg3 ;
45439 int arg4 ;
45440 PyObject *arg5 = (PyObject *) NULL ;
45441 wxSizerItem *result = 0 ;
45442 int res1 = 0 ;
45443 int val2 ;
45444 int ecode2 = 0 ;
45445 int val3 ;
45446 int ecode3 = 0 ;
45447 int val4 ;
45448 int ecode4 = 0 ;
45449 PyObject * obj0 = 0 ;
45450 PyObject * obj1 = 0 ;
45451 PyObject * obj2 = 0 ;
45452 PyObject * obj3 = 0 ;
45453 PyObject * obj4 = 0 ;
45454 char * kwnames[] = {
45455 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45456 };
45457
45458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45459 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45460 if (!SWIG_IsOK(res1)) {
45461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45462 }
45463 ecode2 = SWIG_AsVal_int(obj1, &val2);
45464 if (!SWIG_IsOK(ecode2)) {
45465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45466 }
45467 arg2 = static_cast< int >(val2);
45468 ecode3 = SWIG_AsVal_int(obj2, &val3);
45469 if (!SWIG_IsOK(ecode3)) {
45470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45471 }
45472 arg3 = static_cast< int >(val3);
45473 ecode4 = SWIG_AsVal_int(obj3, &val4);
45474 if (!SWIG_IsOK(ecode4)) {
45475 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45476 }
45477 arg4 = static_cast< int >(val4);
45478 if (obj4) {
45479 arg5 = obj4;
45480 }
45481 {
45482 PyThreadState* __tstate = wxPyBeginAllowThreads();
45483 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45484 wxPyEndAllowThreads(__tstate);
45485 if (PyErr_Occurred()) SWIG_fail;
45486 }
45487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45488 return resultobj;
45489 fail:
45490 return NULL;
45491 }
45492
45493
45494 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45495 PyObject *resultobj = 0;
45496 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45497 void *argp1 = 0 ;
45498 int res1 = 0 ;
45499 PyObject *swig_obj[1] ;
45500
45501 if (!args) SWIG_fail;
45502 swig_obj[0] = args;
45503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45504 if (!SWIG_IsOK(res1)) {
45505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45506 }
45507 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45508 {
45509 PyThreadState* __tstate = wxPyBeginAllowThreads();
45510 (arg1)->DeleteWindows();
45511 wxPyEndAllowThreads(__tstate);
45512 if (PyErr_Occurred()) SWIG_fail;
45513 }
45514 resultobj = SWIG_Py_Void();
45515 return resultobj;
45516 fail:
45517 return NULL;
45518 }
45519
45520
45521 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45522 PyObject *resultobj = 0;
45523 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45524 void *argp1 = 0 ;
45525 int res1 = 0 ;
45526 PyObject *swig_obj[1] ;
45527
45528 if (!args) SWIG_fail;
45529 swig_obj[0] = args;
45530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45531 if (!SWIG_IsOK(res1)) {
45532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45533 }
45534 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45535 {
45536 PyThreadState* __tstate = wxPyBeginAllowThreads();
45537 (arg1)->DetachSizer();
45538 wxPyEndAllowThreads(__tstate);
45539 if (PyErr_Occurred()) SWIG_fail;
45540 }
45541 resultobj = SWIG_Py_Void();
45542 return resultobj;
45543 fail:
45544 return NULL;
45545 }
45546
45547
45548 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45549 PyObject *resultobj = 0;
45550 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45551 wxSize result;
45552 void *argp1 = 0 ;
45553 int res1 = 0 ;
45554 PyObject *swig_obj[1] ;
45555
45556 if (!args) SWIG_fail;
45557 swig_obj[0] = args;
45558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45559 if (!SWIG_IsOK(res1)) {
45560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45561 }
45562 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45563 {
45564 PyThreadState* __tstate = wxPyBeginAllowThreads();
45565 result = (arg1)->GetSize();
45566 wxPyEndAllowThreads(__tstate);
45567 if (PyErr_Occurred()) SWIG_fail;
45568 }
45569 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45570 return resultobj;
45571 fail:
45572 return NULL;
45573 }
45574
45575
45576 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45577 PyObject *resultobj = 0;
45578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45579 wxSize result;
45580 void *argp1 = 0 ;
45581 int res1 = 0 ;
45582 PyObject *swig_obj[1] ;
45583
45584 if (!args) SWIG_fail;
45585 swig_obj[0] = args;
45586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45587 if (!SWIG_IsOK(res1)) {
45588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45589 }
45590 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45591 {
45592 PyThreadState* __tstate = wxPyBeginAllowThreads();
45593 result = (arg1)->CalcMin();
45594 wxPyEndAllowThreads(__tstate);
45595 if (PyErr_Occurred()) SWIG_fail;
45596 }
45597 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45598 return resultobj;
45599 fail:
45600 return NULL;
45601 }
45602
45603
45604 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45605 PyObject *resultobj = 0;
45606 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45607 wxPoint *arg2 = 0 ;
45608 wxSize *arg3 = 0 ;
45609 void *argp1 = 0 ;
45610 int res1 = 0 ;
45611 wxPoint temp2 ;
45612 wxSize temp3 ;
45613 PyObject * obj0 = 0 ;
45614 PyObject * obj1 = 0 ;
45615 PyObject * obj2 = 0 ;
45616 char * kwnames[] = {
45617 (char *) "self",(char *) "pos",(char *) "size", NULL
45618 };
45619
45620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45622 if (!SWIG_IsOK(res1)) {
45623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45624 }
45625 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45626 {
45627 arg2 = &temp2;
45628 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45629 }
45630 {
45631 arg3 = &temp3;
45632 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45633 }
45634 {
45635 PyThreadState* __tstate = wxPyBeginAllowThreads();
45636 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45637 wxPyEndAllowThreads(__tstate);
45638 if (PyErr_Occurred()) SWIG_fail;
45639 }
45640 resultobj = SWIG_Py_Void();
45641 return resultobj;
45642 fail:
45643 return NULL;
45644 }
45645
45646
45647 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45648 PyObject *resultobj = 0;
45649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45650 wxSize result;
45651 void *argp1 = 0 ;
45652 int res1 = 0 ;
45653 PyObject *swig_obj[1] ;
45654
45655 if (!args) SWIG_fail;
45656 swig_obj[0] = args;
45657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45658 if (!SWIG_IsOK(res1)) {
45659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45660 }
45661 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45662 {
45663 PyThreadState* __tstate = wxPyBeginAllowThreads();
45664 result = (arg1)->GetMinSize();
45665 wxPyEndAllowThreads(__tstate);
45666 if (PyErr_Occurred()) SWIG_fail;
45667 }
45668 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45669 return resultobj;
45670 fail:
45671 return NULL;
45672 }
45673
45674
45675 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45676 PyObject *resultobj = 0;
45677 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45678 wxSize result;
45679 void *argp1 = 0 ;
45680 int res1 = 0 ;
45681 PyObject *swig_obj[1] ;
45682
45683 if (!args) SWIG_fail;
45684 swig_obj[0] = args;
45685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45686 if (!SWIG_IsOK(res1)) {
45687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45688 }
45689 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45690 {
45691 PyThreadState* __tstate = wxPyBeginAllowThreads();
45692 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45693 wxPyEndAllowThreads(__tstate);
45694 if (PyErr_Occurred()) SWIG_fail;
45695 }
45696 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45697 return resultobj;
45698 fail:
45699 return NULL;
45700 }
45701
45702
45703 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45704 PyObject *resultobj = 0;
45705 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45706 int arg2 ;
45707 int arg3 ;
45708 void *argp1 = 0 ;
45709 int res1 = 0 ;
45710 int val2 ;
45711 int ecode2 = 0 ;
45712 int val3 ;
45713 int ecode3 = 0 ;
45714 PyObject * obj0 = 0 ;
45715 PyObject * obj1 = 0 ;
45716 PyObject * obj2 = 0 ;
45717 char * kwnames[] = {
45718 (char *) "self",(char *) "x",(char *) "y", NULL
45719 };
45720
45721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45723 if (!SWIG_IsOK(res1)) {
45724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45725 }
45726 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45727 ecode2 = SWIG_AsVal_int(obj1, &val2);
45728 if (!SWIG_IsOK(ecode2)) {
45729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45730 }
45731 arg2 = static_cast< int >(val2);
45732 ecode3 = SWIG_AsVal_int(obj2, &val3);
45733 if (!SWIG_IsOK(ecode3)) {
45734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45735 }
45736 arg3 = static_cast< int >(val3);
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 (arg1)->SetInitSize(arg2,arg3);
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 resultobj = SWIG_Py_Void();
45744 return resultobj;
45745 fail:
45746 return NULL;
45747 }
45748
45749
45750 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45751 PyObject *resultobj = 0;
45752 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45753 int arg2 ;
45754 int arg3 ;
45755 void *argp1 = 0 ;
45756 int res1 = 0 ;
45757 int val2 ;
45758 int ecode2 = 0 ;
45759 int val3 ;
45760 int ecode3 = 0 ;
45761 PyObject * obj0 = 0 ;
45762 PyObject * obj1 = 0 ;
45763 PyObject * obj2 = 0 ;
45764 char * kwnames[] = {
45765 (char *) "self",(char *) "width",(char *) "height", NULL
45766 };
45767
45768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45770 if (!SWIG_IsOK(res1)) {
45771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45772 }
45773 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45774 ecode2 = SWIG_AsVal_int(obj1, &val2);
45775 if (!SWIG_IsOK(ecode2)) {
45776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45777 }
45778 arg2 = static_cast< int >(val2);
45779 ecode3 = SWIG_AsVal_int(obj2, &val3);
45780 if (!SWIG_IsOK(ecode3)) {
45781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45782 }
45783 arg3 = static_cast< int >(val3);
45784 {
45785 PyThreadState* __tstate = wxPyBeginAllowThreads();
45786 (arg1)->SetRatio(arg2,arg3);
45787 wxPyEndAllowThreads(__tstate);
45788 if (PyErr_Occurred()) SWIG_fail;
45789 }
45790 resultobj = SWIG_Py_Void();
45791 return resultobj;
45792 fail:
45793 return NULL;
45794 }
45795
45796
45797 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45798 PyObject *resultobj = 0;
45799 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45800 wxSize *arg2 = 0 ;
45801 void *argp1 = 0 ;
45802 int res1 = 0 ;
45803 wxSize temp2 ;
45804 PyObject * obj0 = 0 ;
45805 PyObject * obj1 = 0 ;
45806 char * kwnames[] = {
45807 (char *) "self",(char *) "size", NULL
45808 };
45809
45810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45812 if (!SWIG_IsOK(res1)) {
45813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45814 }
45815 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45816 {
45817 arg2 = &temp2;
45818 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45819 }
45820 {
45821 PyThreadState* __tstate = wxPyBeginAllowThreads();
45822 (arg1)->SetRatio((wxSize const &)*arg2);
45823 wxPyEndAllowThreads(__tstate);
45824 if (PyErr_Occurred()) SWIG_fail;
45825 }
45826 resultobj = SWIG_Py_Void();
45827 return resultobj;
45828 fail:
45829 return NULL;
45830 }
45831
45832
45833 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45834 PyObject *resultobj = 0;
45835 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45836 float arg2 ;
45837 void *argp1 = 0 ;
45838 int res1 = 0 ;
45839 float val2 ;
45840 int ecode2 = 0 ;
45841 PyObject * obj0 = 0 ;
45842 PyObject * obj1 = 0 ;
45843 char * kwnames[] = {
45844 (char *) "self",(char *) "ratio", NULL
45845 };
45846
45847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45849 if (!SWIG_IsOK(res1)) {
45850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45851 }
45852 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45853 ecode2 = SWIG_AsVal_float(obj1, &val2);
45854 if (!SWIG_IsOK(ecode2)) {
45855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45856 }
45857 arg2 = static_cast< float >(val2);
45858 {
45859 PyThreadState* __tstate = wxPyBeginAllowThreads();
45860 (arg1)->SetRatio(arg2);
45861 wxPyEndAllowThreads(__tstate);
45862 if (PyErr_Occurred()) SWIG_fail;
45863 }
45864 resultobj = SWIG_Py_Void();
45865 return resultobj;
45866 fail:
45867 return NULL;
45868 }
45869
45870
45871 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45872 PyObject *resultobj = 0;
45873 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45874 float result;
45875 void *argp1 = 0 ;
45876 int res1 = 0 ;
45877 PyObject *swig_obj[1] ;
45878
45879 if (!args) SWIG_fail;
45880 swig_obj[0] = args;
45881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45882 if (!SWIG_IsOK(res1)) {
45883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45884 }
45885 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45886 {
45887 PyThreadState* __tstate = wxPyBeginAllowThreads();
45888 result = (float)(arg1)->GetRatio();
45889 wxPyEndAllowThreads(__tstate);
45890 if (PyErr_Occurred()) SWIG_fail;
45891 }
45892 resultobj = SWIG_From_float(static_cast< float >(result));
45893 return resultobj;
45894 fail:
45895 return NULL;
45896 }
45897
45898
45899 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45900 PyObject *resultobj = 0;
45901 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45902 wxRect result;
45903 void *argp1 = 0 ;
45904 int res1 = 0 ;
45905 PyObject *swig_obj[1] ;
45906
45907 if (!args) SWIG_fail;
45908 swig_obj[0] = args;
45909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45910 if (!SWIG_IsOK(res1)) {
45911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45912 }
45913 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45914 {
45915 PyThreadState* __tstate = wxPyBeginAllowThreads();
45916 result = (arg1)->GetRect();
45917 wxPyEndAllowThreads(__tstate);
45918 if (PyErr_Occurred()) SWIG_fail;
45919 }
45920 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45921 return resultobj;
45922 fail:
45923 return NULL;
45924 }
45925
45926
45927 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45928 PyObject *resultobj = 0;
45929 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45930 bool result;
45931 void *argp1 = 0 ;
45932 int res1 = 0 ;
45933 PyObject *swig_obj[1] ;
45934
45935 if (!args) SWIG_fail;
45936 swig_obj[0] = args;
45937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45938 if (!SWIG_IsOK(res1)) {
45939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45940 }
45941 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45942 {
45943 PyThreadState* __tstate = wxPyBeginAllowThreads();
45944 result = (bool)(arg1)->IsWindow();
45945 wxPyEndAllowThreads(__tstate);
45946 if (PyErr_Occurred()) SWIG_fail;
45947 }
45948 {
45949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45950 }
45951 return resultobj;
45952 fail:
45953 return NULL;
45954 }
45955
45956
45957 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45958 PyObject *resultobj = 0;
45959 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45960 bool result;
45961 void *argp1 = 0 ;
45962 int res1 = 0 ;
45963 PyObject *swig_obj[1] ;
45964
45965 if (!args) SWIG_fail;
45966 swig_obj[0] = args;
45967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45968 if (!SWIG_IsOK(res1)) {
45969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45970 }
45971 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45972 {
45973 PyThreadState* __tstate = wxPyBeginAllowThreads();
45974 result = (bool)(arg1)->IsSizer();
45975 wxPyEndAllowThreads(__tstate);
45976 if (PyErr_Occurred()) SWIG_fail;
45977 }
45978 {
45979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45980 }
45981 return resultobj;
45982 fail:
45983 return NULL;
45984 }
45985
45986
45987 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45988 PyObject *resultobj = 0;
45989 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45990 bool result;
45991 void *argp1 = 0 ;
45992 int res1 = 0 ;
45993 PyObject *swig_obj[1] ;
45994
45995 if (!args) SWIG_fail;
45996 swig_obj[0] = args;
45997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45998 if (!SWIG_IsOK(res1)) {
45999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46000 }
46001 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46002 {
46003 PyThreadState* __tstate = wxPyBeginAllowThreads();
46004 result = (bool)(arg1)->IsSpacer();
46005 wxPyEndAllowThreads(__tstate);
46006 if (PyErr_Occurred()) SWIG_fail;
46007 }
46008 {
46009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46010 }
46011 return resultobj;
46012 fail:
46013 return NULL;
46014 }
46015
46016
46017 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46018 PyObject *resultobj = 0;
46019 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46020 int arg2 ;
46021 void *argp1 = 0 ;
46022 int res1 = 0 ;
46023 int val2 ;
46024 int ecode2 = 0 ;
46025 PyObject * obj0 = 0 ;
46026 PyObject * obj1 = 0 ;
46027 char * kwnames[] = {
46028 (char *) "self",(char *) "proportion", NULL
46029 };
46030
46031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46033 if (!SWIG_IsOK(res1)) {
46034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46035 }
46036 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46037 ecode2 = SWIG_AsVal_int(obj1, &val2);
46038 if (!SWIG_IsOK(ecode2)) {
46039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46040 }
46041 arg2 = static_cast< int >(val2);
46042 {
46043 PyThreadState* __tstate = wxPyBeginAllowThreads();
46044 (arg1)->SetProportion(arg2);
46045 wxPyEndAllowThreads(__tstate);
46046 if (PyErr_Occurred()) SWIG_fail;
46047 }
46048 resultobj = SWIG_Py_Void();
46049 return resultobj;
46050 fail:
46051 return NULL;
46052 }
46053
46054
46055 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46056 PyObject *resultobj = 0;
46057 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46058 int result;
46059 void *argp1 = 0 ;
46060 int res1 = 0 ;
46061 PyObject *swig_obj[1] ;
46062
46063 if (!args) SWIG_fail;
46064 swig_obj[0] = args;
46065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46066 if (!SWIG_IsOK(res1)) {
46067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46068 }
46069 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46070 {
46071 PyThreadState* __tstate = wxPyBeginAllowThreads();
46072 result = (int)(arg1)->GetProportion();
46073 wxPyEndAllowThreads(__tstate);
46074 if (PyErr_Occurred()) SWIG_fail;
46075 }
46076 resultobj = SWIG_From_int(static_cast< int >(result));
46077 return resultobj;
46078 fail:
46079 return NULL;
46080 }
46081
46082
46083 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46084 PyObject *resultobj = 0;
46085 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46086 int arg2 ;
46087 void *argp1 = 0 ;
46088 int res1 = 0 ;
46089 int val2 ;
46090 int ecode2 = 0 ;
46091 PyObject * obj0 = 0 ;
46092 PyObject * obj1 = 0 ;
46093 char * kwnames[] = {
46094 (char *) "self",(char *) "flag", NULL
46095 };
46096
46097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46099 if (!SWIG_IsOK(res1)) {
46100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46101 }
46102 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46103 ecode2 = SWIG_AsVal_int(obj1, &val2);
46104 if (!SWIG_IsOK(ecode2)) {
46105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46106 }
46107 arg2 = static_cast< int >(val2);
46108 {
46109 PyThreadState* __tstate = wxPyBeginAllowThreads();
46110 (arg1)->SetFlag(arg2);
46111 wxPyEndAllowThreads(__tstate);
46112 if (PyErr_Occurred()) SWIG_fail;
46113 }
46114 resultobj = SWIG_Py_Void();
46115 return resultobj;
46116 fail:
46117 return NULL;
46118 }
46119
46120
46121 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46122 PyObject *resultobj = 0;
46123 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46124 int result;
46125 void *argp1 = 0 ;
46126 int res1 = 0 ;
46127 PyObject *swig_obj[1] ;
46128
46129 if (!args) SWIG_fail;
46130 swig_obj[0] = args;
46131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46132 if (!SWIG_IsOK(res1)) {
46133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46134 }
46135 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46136 {
46137 PyThreadState* __tstate = wxPyBeginAllowThreads();
46138 result = (int)(arg1)->GetFlag();
46139 wxPyEndAllowThreads(__tstate);
46140 if (PyErr_Occurred()) SWIG_fail;
46141 }
46142 resultobj = SWIG_From_int(static_cast< int >(result));
46143 return resultobj;
46144 fail:
46145 return NULL;
46146 }
46147
46148
46149 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46150 PyObject *resultobj = 0;
46151 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46152 int arg2 ;
46153 void *argp1 = 0 ;
46154 int res1 = 0 ;
46155 int val2 ;
46156 int ecode2 = 0 ;
46157 PyObject * obj0 = 0 ;
46158 PyObject * obj1 = 0 ;
46159 char * kwnames[] = {
46160 (char *) "self",(char *) "border", NULL
46161 };
46162
46163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46165 if (!SWIG_IsOK(res1)) {
46166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46167 }
46168 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46169 ecode2 = SWIG_AsVal_int(obj1, &val2);
46170 if (!SWIG_IsOK(ecode2)) {
46171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46172 }
46173 arg2 = static_cast< int >(val2);
46174 {
46175 PyThreadState* __tstate = wxPyBeginAllowThreads();
46176 (arg1)->SetBorder(arg2);
46177 wxPyEndAllowThreads(__tstate);
46178 if (PyErr_Occurred()) SWIG_fail;
46179 }
46180 resultobj = SWIG_Py_Void();
46181 return resultobj;
46182 fail:
46183 return NULL;
46184 }
46185
46186
46187 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46188 PyObject *resultobj = 0;
46189 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46190 int result;
46191 void *argp1 = 0 ;
46192 int res1 = 0 ;
46193 PyObject *swig_obj[1] ;
46194
46195 if (!args) SWIG_fail;
46196 swig_obj[0] = args;
46197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46198 if (!SWIG_IsOK(res1)) {
46199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46200 }
46201 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46202 {
46203 PyThreadState* __tstate = wxPyBeginAllowThreads();
46204 result = (int)(arg1)->GetBorder();
46205 wxPyEndAllowThreads(__tstate);
46206 if (PyErr_Occurred()) SWIG_fail;
46207 }
46208 resultobj = SWIG_From_int(static_cast< int >(result));
46209 return resultobj;
46210 fail:
46211 return NULL;
46212 }
46213
46214
46215 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46216 PyObject *resultobj = 0;
46217 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46218 wxWindow *result = 0 ;
46219 void *argp1 = 0 ;
46220 int res1 = 0 ;
46221 PyObject *swig_obj[1] ;
46222
46223 if (!args) SWIG_fail;
46224 swig_obj[0] = args;
46225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46226 if (!SWIG_IsOK(res1)) {
46227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46228 }
46229 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46230 {
46231 PyThreadState* __tstate = wxPyBeginAllowThreads();
46232 result = (wxWindow *)(arg1)->GetWindow();
46233 wxPyEndAllowThreads(__tstate);
46234 if (PyErr_Occurred()) SWIG_fail;
46235 }
46236 {
46237 resultobj = wxPyMake_wxObject(result, 0);
46238 }
46239 return resultobj;
46240 fail:
46241 return NULL;
46242 }
46243
46244
46245 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46246 PyObject *resultobj = 0;
46247 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46248 wxWindow *arg2 = (wxWindow *) 0 ;
46249 void *argp1 = 0 ;
46250 int res1 = 0 ;
46251 void *argp2 = 0 ;
46252 int res2 = 0 ;
46253 PyObject * obj0 = 0 ;
46254 PyObject * obj1 = 0 ;
46255 char * kwnames[] = {
46256 (char *) "self",(char *) "window", NULL
46257 };
46258
46259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46261 if (!SWIG_IsOK(res1)) {
46262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46263 }
46264 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46265 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46266 if (!SWIG_IsOK(res2)) {
46267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46268 }
46269 arg2 = reinterpret_cast< wxWindow * >(argp2);
46270 {
46271 PyThreadState* __tstate = wxPyBeginAllowThreads();
46272 (arg1)->SetWindow(arg2);
46273 wxPyEndAllowThreads(__tstate);
46274 if (PyErr_Occurred()) SWIG_fail;
46275 }
46276 resultobj = SWIG_Py_Void();
46277 return resultobj;
46278 fail:
46279 return NULL;
46280 }
46281
46282
46283 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46284 PyObject *resultobj = 0;
46285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46286 wxSizer *result = 0 ;
46287 void *argp1 = 0 ;
46288 int res1 = 0 ;
46289 PyObject *swig_obj[1] ;
46290
46291 if (!args) SWIG_fail;
46292 swig_obj[0] = args;
46293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46294 if (!SWIG_IsOK(res1)) {
46295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46296 }
46297 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46298 {
46299 PyThreadState* __tstate = wxPyBeginAllowThreads();
46300 result = (wxSizer *)(arg1)->GetSizer();
46301 wxPyEndAllowThreads(__tstate);
46302 if (PyErr_Occurred()) SWIG_fail;
46303 }
46304 {
46305 resultobj = wxPyMake_wxObject(result, (bool)0);
46306 }
46307 return resultobj;
46308 fail:
46309 return NULL;
46310 }
46311
46312
46313 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46314 PyObject *resultobj = 0;
46315 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46316 wxSizer *arg2 = (wxSizer *) 0 ;
46317 void *argp1 = 0 ;
46318 int res1 = 0 ;
46319 int res2 = 0 ;
46320 PyObject * obj0 = 0 ;
46321 PyObject * obj1 = 0 ;
46322 char * kwnames[] = {
46323 (char *) "self",(char *) "sizer", NULL
46324 };
46325
46326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46328 if (!SWIG_IsOK(res1)) {
46329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46330 }
46331 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46332 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46333 if (!SWIG_IsOK(res2)) {
46334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46335 }
46336 {
46337 PyThreadState* __tstate = wxPyBeginAllowThreads();
46338 (arg1)->SetSizer(arg2);
46339 wxPyEndAllowThreads(__tstate);
46340 if (PyErr_Occurred()) SWIG_fail;
46341 }
46342 resultobj = SWIG_Py_Void();
46343 return resultobj;
46344 fail:
46345 return NULL;
46346 }
46347
46348
46349 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46350 PyObject *resultobj = 0;
46351 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46352 wxSize *result = 0 ;
46353 void *argp1 = 0 ;
46354 int res1 = 0 ;
46355 PyObject *swig_obj[1] ;
46356
46357 if (!args) SWIG_fail;
46358 swig_obj[0] = args;
46359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46360 if (!SWIG_IsOK(res1)) {
46361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46362 }
46363 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46364 {
46365 PyThreadState* __tstate = wxPyBeginAllowThreads();
46366 {
46367 wxSize const &_result_ref = (arg1)->GetSpacer();
46368 result = (wxSize *) &_result_ref;
46369 }
46370 wxPyEndAllowThreads(__tstate);
46371 if (PyErr_Occurred()) SWIG_fail;
46372 }
46373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46374 return resultobj;
46375 fail:
46376 return NULL;
46377 }
46378
46379
46380 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46381 PyObject *resultobj = 0;
46382 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46383 wxSize *arg2 = 0 ;
46384 void *argp1 = 0 ;
46385 int res1 = 0 ;
46386 wxSize temp2 ;
46387 PyObject * obj0 = 0 ;
46388 PyObject * obj1 = 0 ;
46389 char * kwnames[] = {
46390 (char *) "self",(char *) "size", NULL
46391 };
46392
46393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46395 if (!SWIG_IsOK(res1)) {
46396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46397 }
46398 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46399 {
46400 arg2 = &temp2;
46401 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46402 }
46403 {
46404 PyThreadState* __tstate = wxPyBeginAllowThreads();
46405 (arg1)->SetSpacer((wxSize const &)*arg2);
46406 wxPyEndAllowThreads(__tstate);
46407 if (PyErr_Occurred()) SWIG_fail;
46408 }
46409 resultobj = SWIG_Py_Void();
46410 return resultobj;
46411 fail:
46412 return NULL;
46413 }
46414
46415
46416 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46417 PyObject *resultobj = 0;
46418 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46419 bool arg2 ;
46420 void *argp1 = 0 ;
46421 int res1 = 0 ;
46422 bool val2 ;
46423 int ecode2 = 0 ;
46424 PyObject * obj0 = 0 ;
46425 PyObject * obj1 = 0 ;
46426 char * kwnames[] = {
46427 (char *) "self",(char *) "show", NULL
46428 };
46429
46430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46432 if (!SWIG_IsOK(res1)) {
46433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46434 }
46435 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46437 if (!SWIG_IsOK(ecode2)) {
46438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46439 }
46440 arg2 = static_cast< bool >(val2);
46441 {
46442 PyThreadState* __tstate = wxPyBeginAllowThreads();
46443 (arg1)->Show(arg2);
46444 wxPyEndAllowThreads(__tstate);
46445 if (PyErr_Occurred()) SWIG_fail;
46446 }
46447 resultobj = SWIG_Py_Void();
46448 return resultobj;
46449 fail:
46450 return NULL;
46451 }
46452
46453
46454 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46455 PyObject *resultobj = 0;
46456 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46457 bool result;
46458 void *argp1 = 0 ;
46459 int res1 = 0 ;
46460 PyObject *swig_obj[1] ;
46461
46462 if (!args) SWIG_fail;
46463 swig_obj[0] = args;
46464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46465 if (!SWIG_IsOK(res1)) {
46466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46467 }
46468 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46469 {
46470 PyThreadState* __tstate = wxPyBeginAllowThreads();
46471 result = (bool)(arg1)->IsShown();
46472 wxPyEndAllowThreads(__tstate);
46473 if (PyErr_Occurred()) SWIG_fail;
46474 }
46475 {
46476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46477 }
46478 return resultobj;
46479 fail:
46480 return NULL;
46481 }
46482
46483
46484 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46485 PyObject *resultobj = 0;
46486 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46487 wxPoint result;
46488 void *argp1 = 0 ;
46489 int res1 = 0 ;
46490 PyObject *swig_obj[1] ;
46491
46492 if (!args) SWIG_fail;
46493 swig_obj[0] = args;
46494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46495 if (!SWIG_IsOK(res1)) {
46496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46497 }
46498 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46499 {
46500 PyThreadState* __tstate = wxPyBeginAllowThreads();
46501 result = (arg1)->GetPosition();
46502 wxPyEndAllowThreads(__tstate);
46503 if (PyErr_Occurred()) SWIG_fail;
46504 }
46505 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46506 return resultobj;
46507 fail:
46508 return NULL;
46509 }
46510
46511
46512 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46513 PyObject *resultobj = 0;
46514 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46515 PyObject *result = 0 ;
46516 void *argp1 = 0 ;
46517 int res1 = 0 ;
46518 PyObject *swig_obj[1] ;
46519
46520 if (!args) SWIG_fail;
46521 swig_obj[0] = args;
46522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46523 if (!SWIG_IsOK(res1)) {
46524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46525 }
46526 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46527 {
46528 PyThreadState* __tstate = wxPyBeginAllowThreads();
46529 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46530 wxPyEndAllowThreads(__tstate);
46531 if (PyErr_Occurred()) SWIG_fail;
46532 }
46533 resultobj = result;
46534 return resultobj;
46535 fail:
46536 return NULL;
46537 }
46538
46539
46540 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46541 PyObject *resultobj = 0;
46542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46543 PyObject *arg2 = (PyObject *) 0 ;
46544 void *argp1 = 0 ;
46545 int res1 = 0 ;
46546 PyObject * obj0 = 0 ;
46547 PyObject * obj1 = 0 ;
46548 char * kwnames[] = {
46549 (char *) "self",(char *) "userData", NULL
46550 };
46551
46552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46554 if (!SWIG_IsOK(res1)) {
46555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46556 }
46557 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46558 arg2 = obj1;
46559 {
46560 PyThreadState* __tstate = wxPyBeginAllowThreads();
46561 wxSizerItem_SetUserData(arg1,arg2);
46562 wxPyEndAllowThreads(__tstate);
46563 if (PyErr_Occurred()) SWIG_fail;
46564 }
46565 resultobj = SWIG_Py_Void();
46566 return resultobj;
46567 fail:
46568 return NULL;
46569 }
46570
46571
46572 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46573 PyObject *obj;
46574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46575 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46576 return SWIG_Py_Void();
46577 }
46578
46579 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46580 return SWIG_Python_InitShadowInstance(args);
46581 }
46582
46583 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46584 PyObject *resultobj = 0;
46585 wxSizer *arg1 = (wxSizer *) 0 ;
46586 void *argp1 = 0 ;
46587 int res1 = 0 ;
46588 PyObject *swig_obj[1] ;
46589
46590 if (!args) SWIG_fail;
46591 swig_obj[0] = args;
46592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46593 if (!SWIG_IsOK(res1)) {
46594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46595 }
46596 arg1 = reinterpret_cast< wxSizer * >(argp1);
46597 {
46598 PyThreadState* __tstate = wxPyBeginAllowThreads();
46599 delete arg1;
46600
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__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46612 PyObject *resultobj = 0;
46613 wxSizer *arg1 = (wxSizer *) 0 ;
46614 PyObject *arg2 = (PyObject *) 0 ;
46615 void *argp1 = 0 ;
46616 int res1 = 0 ;
46617 PyObject * obj0 = 0 ;
46618 PyObject * obj1 = 0 ;
46619 char * kwnames[] = {
46620 (char *) "self",(char *) "_self", NULL
46621 };
46622
46623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46625 if (!SWIG_IsOK(res1)) {
46626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46627 }
46628 arg1 = reinterpret_cast< wxSizer * >(argp1);
46629 arg2 = obj1;
46630 {
46631 PyThreadState* __tstate = wxPyBeginAllowThreads();
46632 wxSizer__setOORInfo(arg1,arg2);
46633 wxPyEndAllowThreads(__tstate);
46634 if (PyErr_Occurred()) SWIG_fail;
46635 }
46636 resultobj = SWIG_Py_Void();
46637 return resultobj;
46638 fail:
46639 return NULL;
46640 }
46641
46642
46643 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46644 PyObject *resultobj = 0;
46645 wxSizer *arg1 = (wxSizer *) 0 ;
46646 PyObject *arg2 = (PyObject *) 0 ;
46647 int arg3 = (int) 0 ;
46648 int arg4 = (int) 0 ;
46649 int arg5 = (int) 0 ;
46650 PyObject *arg6 = (PyObject *) NULL ;
46651 wxSizerItem *result = 0 ;
46652 void *argp1 = 0 ;
46653 int res1 = 0 ;
46654 int val3 ;
46655 int ecode3 = 0 ;
46656 int val4 ;
46657 int ecode4 = 0 ;
46658 int val5 ;
46659 int ecode5 = 0 ;
46660 PyObject * obj0 = 0 ;
46661 PyObject * obj1 = 0 ;
46662 PyObject * obj2 = 0 ;
46663 PyObject * obj3 = 0 ;
46664 PyObject * obj4 = 0 ;
46665 PyObject * obj5 = 0 ;
46666 char * kwnames[] = {
46667 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46668 };
46669
46670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46672 if (!SWIG_IsOK(res1)) {
46673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46674 }
46675 arg1 = reinterpret_cast< wxSizer * >(argp1);
46676 arg2 = obj1;
46677 if (obj2) {
46678 ecode3 = SWIG_AsVal_int(obj2, &val3);
46679 if (!SWIG_IsOK(ecode3)) {
46680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46681 }
46682 arg3 = static_cast< int >(val3);
46683 }
46684 if (obj3) {
46685 ecode4 = SWIG_AsVal_int(obj3, &val4);
46686 if (!SWIG_IsOK(ecode4)) {
46687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46688 }
46689 arg4 = static_cast< int >(val4);
46690 }
46691 if (obj4) {
46692 ecode5 = SWIG_AsVal_int(obj4, &val5);
46693 if (!SWIG_IsOK(ecode5)) {
46694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46695 }
46696 arg5 = static_cast< int >(val5);
46697 }
46698 if (obj5) {
46699 arg6 = obj5;
46700 }
46701 {
46702 PyThreadState* __tstate = wxPyBeginAllowThreads();
46703 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46704 wxPyEndAllowThreads(__tstate);
46705 if (PyErr_Occurred()) SWIG_fail;
46706 }
46707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46708 return resultobj;
46709 fail:
46710 return NULL;
46711 }
46712
46713
46714 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46715 PyObject *resultobj = 0;
46716 wxSizer *arg1 = (wxSizer *) 0 ;
46717 int arg2 ;
46718 PyObject *arg3 = (PyObject *) 0 ;
46719 int arg4 = (int) 0 ;
46720 int arg5 = (int) 0 ;
46721 int arg6 = (int) 0 ;
46722 PyObject *arg7 = (PyObject *) NULL ;
46723 wxSizerItem *result = 0 ;
46724 void *argp1 = 0 ;
46725 int res1 = 0 ;
46726 int val2 ;
46727 int ecode2 = 0 ;
46728 int val4 ;
46729 int ecode4 = 0 ;
46730 int val5 ;
46731 int ecode5 = 0 ;
46732 int val6 ;
46733 int ecode6 = 0 ;
46734 PyObject * obj0 = 0 ;
46735 PyObject * obj1 = 0 ;
46736 PyObject * obj2 = 0 ;
46737 PyObject * obj3 = 0 ;
46738 PyObject * obj4 = 0 ;
46739 PyObject * obj5 = 0 ;
46740 PyObject * obj6 = 0 ;
46741 char * kwnames[] = {
46742 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46743 };
46744
46745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46747 if (!SWIG_IsOK(res1)) {
46748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46749 }
46750 arg1 = reinterpret_cast< wxSizer * >(argp1);
46751 ecode2 = SWIG_AsVal_int(obj1, &val2);
46752 if (!SWIG_IsOK(ecode2)) {
46753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46754 }
46755 arg2 = static_cast< int >(val2);
46756 arg3 = obj2;
46757 if (obj3) {
46758 ecode4 = SWIG_AsVal_int(obj3, &val4);
46759 if (!SWIG_IsOK(ecode4)) {
46760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46761 }
46762 arg4 = static_cast< int >(val4);
46763 }
46764 if (obj4) {
46765 ecode5 = SWIG_AsVal_int(obj4, &val5);
46766 if (!SWIG_IsOK(ecode5)) {
46767 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46768 }
46769 arg5 = static_cast< int >(val5);
46770 }
46771 if (obj5) {
46772 ecode6 = SWIG_AsVal_int(obj5, &val6);
46773 if (!SWIG_IsOK(ecode6)) {
46774 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46775 }
46776 arg6 = static_cast< int >(val6);
46777 }
46778 if (obj6) {
46779 arg7 = obj6;
46780 }
46781 {
46782 PyThreadState* __tstate = wxPyBeginAllowThreads();
46783 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46784 wxPyEndAllowThreads(__tstate);
46785 if (PyErr_Occurred()) SWIG_fail;
46786 }
46787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46788 return resultobj;
46789 fail:
46790 return NULL;
46791 }
46792
46793
46794 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46795 PyObject *resultobj = 0;
46796 wxSizer *arg1 = (wxSizer *) 0 ;
46797 PyObject *arg2 = (PyObject *) 0 ;
46798 int arg3 = (int) 0 ;
46799 int arg4 = (int) 0 ;
46800 int arg5 = (int) 0 ;
46801 PyObject *arg6 = (PyObject *) NULL ;
46802 wxSizerItem *result = 0 ;
46803 void *argp1 = 0 ;
46804 int res1 = 0 ;
46805 int val3 ;
46806 int ecode3 = 0 ;
46807 int val4 ;
46808 int ecode4 = 0 ;
46809 int val5 ;
46810 int ecode5 = 0 ;
46811 PyObject * obj0 = 0 ;
46812 PyObject * obj1 = 0 ;
46813 PyObject * obj2 = 0 ;
46814 PyObject * obj3 = 0 ;
46815 PyObject * obj4 = 0 ;
46816 PyObject * obj5 = 0 ;
46817 char * kwnames[] = {
46818 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46819 };
46820
46821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46823 if (!SWIG_IsOK(res1)) {
46824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46825 }
46826 arg1 = reinterpret_cast< wxSizer * >(argp1);
46827 arg2 = obj1;
46828 if (obj2) {
46829 ecode3 = SWIG_AsVal_int(obj2, &val3);
46830 if (!SWIG_IsOK(ecode3)) {
46831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46832 }
46833 arg3 = static_cast< int >(val3);
46834 }
46835 if (obj3) {
46836 ecode4 = SWIG_AsVal_int(obj3, &val4);
46837 if (!SWIG_IsOK(ecode4)) {
46838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46839 }
46840 arg4 = static_cast< int >(val4);
46841 }
46842 if (obj4) {
46843 ecode5 = SWIG_AsVal_int(obj4, &val5);
46844 if (!SWIG_IsOK(ecode5)) {
46845 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46846 }
46847 arg5 = static_cast< int >(val5);
46848 }
46849 if (obj5) {
46850 arg6 = obj5;
46851 }
46852 {
46853 PyThreadState* __tstate = wxPyBeginAllowThreads();
46854 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46855 wxPyEndAllowThreads(__tstate);
46856 if (PyErr_Occurred()) SWIG_fail;
46857 }
46858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46859 return resultobj;
46860 fail:
46861 return NULL;
46862 }
46863
46864
46865 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46866 PyObject *resultobj = 0;
46867 wxSizer *arg1 = (wxSizer *) 0 ;
46868 PyObject *arg2 = (PyObject *) 0 ;
46869 bool result;
46870 void *argp1 = 0 ;
46871 int res1 = 0 ;
46872 PyObject * obj0 = 0 ;
46873 PyObject * obj1 = 0 ;
46874 char * kwnames[] = {
46875 (char *) "self",(char *) "item", NULL
46876 };
46877
46878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46880 if (!SWIG_IsOK(res1)) {
46881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46882 }
46883 arg1 = reinterpret_cast< wxSizer * >(argp1);
46884 arg2 = obj1;
46885 {
46886 PyThreadState* __tstate = wxPyBeginAllowThreads();
46887 result = (bool)wxSizer_Remove(arg1,arg2);
46888 wxPyEndAllowThreads(__tstate);
46889 if (PyErr_Occurred()) SWIG_fail;
46890 }
46891 {
46892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46893 }
46894 return resultobj;
46895 fail:
46896 return NULL;
46897 }
46898
46899
46900 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46901 PyObject *resultobj = 0;
46902 wxSizer *arg1 = (wxSizer *) 0 ;
46903 PyObject *arg2 = (PyObject *) 0 ;
46904 bool result;
46905 void *argp1 = 0 ;
46906 int res1 = 0 ;
46907 PyObject * obj0 = 0 ;
46908 PyObject * obj1 = 0 ;
46909 char * kwnames[] = {
46910 (char *) "self",(char *) "item", NULL
46911 };
46912
46913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46915 if (!SWIG_IsOK(res1)) {
46916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46917 }
46918 arg1 = reinterpret_cast< wxSizer * >(argp1);
46919 arg2 = obj1;
46920 {
46921 PyThreadState* __tstate = wxPyBeginAllowThreads();
46922 result = (bool)wxSizer_Detach(arg1,arg2);
46923 wxPyEndAllowThreads(__tstate);
46924 if (PyErr_Occurred()) SWIG_fail;
46925 }
46926 {
46927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46928 }
46929 return resultobj;
46930 fail:
46931 return NULL;
46932 }
46933
46934
46935 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46936 PyObject *resultobj = 0;
46937 wxSizer *arg1 = (wxSizer *) 0 ;
46938 PyObject *arg2 = (PyObject *) 0 ;
46939 wxSizerItem *result = 0 ;
46940 void *argp1 = 0 ;
46941 int res1 = 0 ;
46942 PyObject * obj0 = 0 ;
46943 PyObject * obj1 = 0 ;
46944 char * kwnames[] = {
46945 (char *) "self",(char *) "item", NULL
46946 };
46947
46948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46950 if (!SWIG_IsOK(res1)) {
46951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46952 }
46953 arg1 = reinterpret_cast< wxSizer * >(argp1);
46954 arg2 = obj1;
46955 {
46956 PyThreadState* __tstate = wxPyBeginAllowThreads();
46957 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46958 wxPyEndAllowThreads(__tstate);
46959 if (PyErr_Occurred()) SWIG_fail;
46960 }
46961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46962 return resultobj;
46963 fail:
46964 return NULL;
46965 }
46966
46967
46968 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46969 PyObject *resultobj = 0;
46970 wxSizer *arg1 = (wxSizer *) 0 ;
46971 PyObject *arg2 = (PyObject *) 0 ;
46972 wxSize *arg3 = 0 ;
46973 void *argp1 = 0 ;
46974 int res1 = 0 ;
46975 wxSize temp3 ;
46976 PyObject * obj0 = 0 ;
46977 PyObject * obj1 = 0 ;
46978 PyObject * obj2 = 0 ;
46979 char * kwnames[] = {
46980 (char *) "self",(char *) "item",(char *) "size", NULL
46981 };
46982
46983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46985 if (!SWIG_IsOK(res1)) {
46986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46987 }
46988 arg1 = reinterpret_cast< wxSizer * >(argp1);
46989 arg2 = obj1;
46990 {
46991 arg3 = &temp3;
46992 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46993 }
46994 {
46995 PyThreadState* __tstate = wxPyBeginAllowThreads();
46996 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46997 wxPyEndAllowThreads(__tstate);
46998 if (PyErr_Occurred()) SWIG_fail;
46999 }
47000 resultobj = SWIG_Py_Void();
47001 return resultobj;
47002 fail:
47003 return NULL;
47004 }
47005
47006
47007 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47008 PyObject *resultobj = 0;
47009 wxSizer *arg1 = (wxSizer *) 0 ;
47010 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47011 wxSizerItem *result = 0 ;
47012 void *argp1 = 0 ;
47013 int res1 = 0 ;
47014 int res2 = 0 ;
47015 PyObject * obj0 = 0 ;
47016 PyObject * obj1 = 0 ;
47017 char * kwnames[] = {
47018 (char *) "self",(char *) "item", NULL
47019 };
47020
47021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47023 if (!SWIG_IsOK(res1)) {
47024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47025 }
47026 arg1 = reinterpret_cast< wxSizer * >(argp1);
47027 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47028 if (!SWIG_IsOK(res2)) {
47029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47030 }
47031 {
47032 PyThreadState* __tstate = wxPyBeginAllowThreads();
47033 result = (wxSizerItem *)(arg1)->Add(arg2);
47034 wxPyEndAllowThreads(__tstate);
47035 if (PyErr_Occurred()) SWIG_fail;
47036 }
47037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47038 return resultobj;
47039 fail:
47040 return NULL;
47041 }
47042
47043
47044 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47045 PyObject *resultobj = 0;
47046 wxSizer *arg1 = (wxSizer *) 0 ;
47047 size_t arg2 ;
47048 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47049 wxSizerItem *result = 0 ;
47050 void *argp1 = 0 ;
47051 int res1 = 0 ;
47052 size_t val2 ;
47053 int ecode2 = 0 ;
47054 int res3 = 0 ;
47055 PyObject * obj0 = 0 ;
47056 PyObject * obj1 = 0 ;
47057 PyObject * obj2 = 0 ;
47058 char * kwnames[] = {
47059 (char *) "self",(char *) "index",(char *) "item", NULL
47060 };
47061
47062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47064 if (!SWIG_IsOK(res1)) {
47065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47066 }
47067 arg1 = reinterpret_cast< wxSizer * >(argp1);
47068 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47069 if (!SWIG_IsOK(ecode2)) {
47070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47071 }
47072 arg2 = static_cast< size_t >(val2);
47073 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47074 if (!SWIG_IsOK(res3)) {
47075 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47076 }
47077 {
47078 PyThreadState* __tstate = wxPyBeginAllowThreads();
47079 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47080 wxPyEndAllowThreads(__tstate);
47081 if (PyErr_Occurred()) SWIG_fail;
47082 }
47083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47084 return resultobj;
47085 fail:
47086 return NULL;
47087 }
47088
47089
47090 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47091 PyObject *resultobj = 0;
47092 wxSizer *arg1 = (wxSizer *) 0 ;
47093 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47094 wxSizerItem *result = 0 ;
47095 void *argp1 = 0 ;
47096 int res1 = 0 ;
47097 int res2 = 0 ;
47098 PyObject * obj0 = 0 ;
47099 PyObject * obj1 = 0 ;
47100 char * kwnames[] = {
47101 (char *) "self",(char *) "item", NULL
47102 };
47103
47104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47106 if (!SWIG_IsOK(res1)) {
47107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47108 }
47109 arg1 = reinterpret_cast< wxSizer * >(argp1);
47110 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47111 if (!SWIG_IsOK(res2)) {
47112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47113 }
47114 {
47115 PyThreadState* __tstate = wxPyBeginAllowThreads();
47116 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47117 wxPyEndAllowThreads(__tstate);
47118 if (PyErr_Occurred()) SWIG_fail;
47119 }
47120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47121 return resultobj;
47122 fail:
47123 return NULL;
47124 }
47125
47126
47127 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47128 PyObject *resultobj = 0;
47129 wxSizer *arg1 = (wxSizer *) 0 ;
47130 int arg2 ;
47131 int arg3 ;
47132 int arg4 ;
47133 int arg5 ;
47134 void *argp1 = 0 ;
47135 int res1 = 0 ;
47136 int val2 ;
47137 int ecode2 = 0 ;
47138 int val3 ;
47139 int ecode3 = 0 ;
47140 int val4 ;
47141 int ecode4 = 0 ;
47142 int val5 ;
47143 int ecode5 = 0 ;
47144 PyObject * obj0 = 0 ;
47145 PyObject * obj1 = 0 ;
47146 PyObject * obj2 = 0 ;
47147 PyObject * obj3 = 0 ;
47148 PyObject * obj4 = 0 ;
47149 char * kwnames[] = {
47150 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47151 };
47152
47153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47155 if (!SWIG_IsOK(res1)) {
47156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47157 }
47158 arg1 = reinterpret_cast< wxSizer * >(argp1);
47159 ecode2 = SWIG_AsVal_int(obj1, &val2);
47160 if (!SWIG_IsOK(ecode2)) {
47161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47162 }
47163 arg2 = static_cast< int >(val2);
47164 ecode3 = SWIG_AsVal_int(obj2, &val3);
47165 if (!SWIG_IsOK(ecode3)) {
47166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47167 }
47168 arg3 = static_cast< int >(val3);
47169 ecode4 = SWIG_AsVal_int(obj3, &val4);
47170 if (!SWIG_IsOK(ecode4)) {
47171 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47172 }
47173 arg4 = static_cast< int >(val4);
47174 ecode5 = SWIG_AsVal_int(obj4, &val5);
47175 if (!SWIG_IsOK(ecode5)) {
47176 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47177 }
47178 arg5 = static_cast< int >(val5);
47179 {
47180 PyThreadState* __tstate = wxPyBeginAllowThreads();
47181 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47182 wxPyEndAllowThreads(__tstate);
47183 if (PyErr_Occurred()) SWIG_fail;
47184 }
47185 resultobj = SWIG_Py_Void();
47186 return resultobj;
47187 fail:
47188 return NULL;
47189 }
47190
47191
47192 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47193 PyObject *resultobj = 0;
47194 wxSizer *arg1 = (wxSizer *) 0 ;
47195 wxSize *arg2 = 0 ;
47196 void *argp1 = 0 ;
47197 int res1 = 0 ;
47198 wxSize temp2 ;
47199 PyObject * obj0 = 0 ;
47200 PyObject * obj1 = 0 ;
47201 char * kwnames[] = {
47202 (char *) "self",(char *) "size", NULL
47203 };
47204
47205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47207 if (!SWIG_IsOK(res1)) {
47208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47209 }
47210 arg1 = reinterpret_cast< wxSizer * >(argp1);
47211 {
47212 arg2 = &temp2;
47213 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47214 }
47215 {
47216 PyThreadState* __tstate = wxPyBeginAllowThreads();
47217 (arg1)->SetMinSize((wxSize const &)*arg2);
47218 wxPyEndAllowThreads(__tstate);
47219 if (PyErr_Occurred()) SWIG_fail;
47220 }
47221 resultobj = SWIG_Py_Void();
47222 return resultobj;
47223 fail:
47224 return NULL;
47225 }
47226
47227
47228 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47229 PyObject *resultobj = 0;
47230 wxSizer *arg1 = (wxSizer *) 0 ;
47231 wxSize result;
47232 void *argp1 = 0 ;
47233 int res1 = 0 ;
47234 PyObject *swig_obj[1] ;
47235
47236 if (!args) SWIG_fail;
47237 swig_obj[0] = args;
47238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47239 if (!SWIG_IsOK(res1)) {
47240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47241 }
47242 arg1 = reinterpret_cast< wxSizer * >(argp1);
47243 {
47244 PyThreadState* __tstate = wxPyBeginAllowThreads();
47245 result = (arg1)->GetSize();
47246 wxPyEndAllowThreads(__tstate);
47247 if (PyErr_Occurred()) SWIG_fail;
47248 }
47249 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47250 return resultobj;
47251 fail:
47252 return NULL;
47253 }
47254
47255
47256 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47257 PyObject *resultobj = 0;
47258 wxSizer *arg1 = (wxSizer *) 0 ;
47259 wxPoint result;
47260 void *argp1 = 0 ;
47261 int res1 = 0 ;
47262 PyObject *swig_obj[1] ;
47263
47264 if (!args) SWIG_fail;
47265 swig_obj[0] = args;
47266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47267 if (!SWIG_IsOK(res1)) {
47268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47269 }
47270 arg1 = reinterpret_cast< wxSizer * >(argp1);
47271 {
47272 PyThreadState* __tstate = wxPyBeginAllowThreads();
47273 result = (arg1)->GetPosition();
47274 wxPyEndAllowThreads(__tstate);
47275 if (PyErr_Occurred()) SWIG_fail;
47276 }
47277 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47278 return resultobj;
47279 fail:
47280 return NULL;
47281 }
47282
47283
47284 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47285 PyObject *resultobj = 0;
47286 wxSizer *arg1 = (wxSizer *) 0 ;
47287 wxSize result;
47288 void *argp1 = 0 ;
47289 int res1 = 0 ;
47290 PyObject *swig_obj[1] ;
47291
47292 if (!args) SWIG_fail;
47293 swig_obj[0] = args;
47294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47295 if (!SWIG_IsOK(res1)) {
47296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47297 }
47298 arg1 = reinterpret_cast< wxSizer * >(argp1);
47299 {
47300 PyThreadState* __tstate = wxPyBeginAllowThreads();
47301 result = (arg1)->GetMinSize();
47302 wxPyEndAllowThreads(__tstate);
47303 if (PyErr_Occurred()) SWIG_fail;
47304 }
47305 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47306 return resultobj;
47307 fail:
47308 return NULL;
47309 }
47310
47311
47312 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47313 PyObject *resultobj = 0;
47314 wxSizer *arg1 = (wxSizer *) 0 ;
47315 void *argp1 = 0 ;
47316 int res1 = 0 ;
47317 PyObject *swig_obj[1] ;
47318
47319 if (!args) SWIG_fail;
47320 swig_obj[0] = args;
47321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47322 if (!SWIG_IsOK(res1)) {
47323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47324 }
47325 arg1 = reinterpret_cast< wxSizer * >(argp1);
47326 {
47327 PyThreadState* __tstate = wxPyBeginAllowThreads();
47328 (arg1)->RecalcSizes();
47329 wxPyEndAllowThreads(__tstate);
47330 if (PyErr_Occurred()) SWIG_fail;
47331 }
47332 resultobj = SWIG_Py_Void();
47333 return resultobj;
47334 fail:
47335 return NULL;
47336 }
47337
47338
47339 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47340 PyObject *resultobj = 0;
47341 wxSizer *arg1 = (wxSizer *) 0 ;
47342 wxSize result;
47343 void *argp1 = 0 ;
47344 int res1 = 0 ;
47345 PyObject *swig_obj[1] ;
47346
47347 if (!args) SWIG_fail;
47348 swig_obj[0] = args;
47349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47350 if (!SWIG_IsOK(res1)) {
47351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47352 }
47353 arg1 = reinterpret_cast< wxSizer * >(argp1);
47354 {
47355 PyThreadState* __tstate = wxPyBeginAllowThreads();
47356 result = (arg1)->CalcMin();
47357 wxPyEndAllowThreads(__tstate);
47358 if (PyErr_Occurred()) SWIG_fail;
47359 }
47360 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47361 return resultobj;
47362 fail:
47363 return NULL;
47364 }
47365
47366
47367 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47368 PyObject *resultobj = 0;
47369 wxSizer *arg1 = (wxSizer *) 0 ;
47370 void *argp1 = 0 ;
47371 int res1 = 0 ;
47372 PyObject *swig_obj[1] ;
47373
47374 if (!args) SWIG_fail;
47375 swig_obj[0] = args;
47376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47377 if (!SWIG_IsOK(res1)) {
47378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47379 }
47380 arg1 = reinterpret_cast< wxSizer * >(argp1);
47381 {
47382 PyThreadState* __tstate = wxPyBeginAllowThreads();
47383 (arg1)->Layout();
47384 wxPyEndAllowThreads(__tstate);
47385 if (PyErr_Occurred()) SWIG_fail;
47386 }
47387 resultobj = SWIG_Py_Void();
47388 return resultobj;
47389 fail:
47390 return NULL;
47391 }
47392
47393
47394 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47395 PyObject *resultobj = 0;
47396 wxSizer *arg1 = (wxSizer *) 0 ;
47397 wxWindow *arg2 = (wxWindow *) 0 ;
47398 wxSize result;
47399 void *argp1 = 0 ;
47400 int res1 = 0 ;
47401 void *argp2 = 0 ;
47402 int res2 = 0 ;
47403 PyObject * obj0 = 0 ;
47404 PyObject * obj1 = 0 ;
47405 char * kwnames[] = {
47406 (char *) "self",(char *) "window", NULL
47407 };
47408
47409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47411 if (!SWIG_IsOK(res1)) {
47412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47413 }
47414 arg1 = reinterpret_cast< wxSizer * >(argp1);
47415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47416 if (!SWIG_IsOK(res2)) {
47417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47418 }
47419 arg2 = reinterpret_cast< wxWindow * >(argp2);
47420 {
47421 PyThreadState* __tstate = wxPyBeginAllowThreads();
47422 result = (arg1)->Fit(arg2);
47423 wxPyEndAllowThreads(__tstate);
47424 if (PyErr_Occurred()) SWIG_fail;
47425 }
47426 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47427 return resultobj;
47428 fail:
47429 return NULL;
47430 }
47431
47432
47433 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47434 PyObject *resultobj = 0;
47435 wxSizer *arg1 = (wxSizer *) 0 ;
47436 wxWindow *arg2 = (wxWindow *) 0 ;
47437 void *argp1 = 0 ;
47438 int res1 = 0 ;
47439 void *argp2 = 0 ;
47440 int res2 = 0 ;
47441 PyObject * obj0 = 0 ;
47442 PyObject * obj1 = 0 ;
47443 char * kwnames[] = {
47444 (char *) "self",(char *) "window", NULL
47445 };
47446
47447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47449 if (!SWIG_IsOK(res1)) {
47450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47451 }
47452 arg1 = reinterpret_cast< wxSizer * >(argp1);
47453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47454 if (!SWIG_IsOK(res2)) {
47455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47456 }
47457 arg2 = reinterpret_cast< wxWindow * >(argp2);
47458 {
47459 PyThreadState* __tstate = wxPyBeginAllowThreads();
47460 (arg1)->FitInside(arg2);
47461 wxPyEndAllowThreads(__tstate);
47462 if (PyErr_Occurred()) SWIG_fail;
47463 }
47464 resultobj = SWIG_Py_Void();
47465 return resultobj;
47466 fail:
47467 return NULL;
47468 }
47469
47470
47471 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47472 PyObject *resultobj = 0;
47473 wxSizer *arg1 = (wxSizer *) 0 ;
47474 wxWindow *arg2 = (wxWindow *) 0 ;
47475 void *argp1 = 0 ;
47476 int res1 = 0 ;
47477 void *argp2 = 0 ;
47478 int res2 = 0 ;
47479 PyObject * obj0 = 0 ;
47480 PyObject * obj1 = 0 ;
47481 char * kwnames[] = {
47482 (char *) "self",(char *) "window", NULL
47483 };
47484
47485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47487 if (!SWIG_IsOK(res1)) {
47488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47489 }
47490 arg1 = reinterpret_cast< wxSizer * >(argp1);
47491 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47492 if (!SWIG_IsOK(res2)) {
47493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47494 }
47495 arg2 = reinterpret_cast< wxWindow * >(argp2);
47496 {
47497 PyThreadState* __tstate = wxPyBeginAllowThreads();
47498 (arg1)->SetSizeHints(arg2);
47499 wxPyEndAllowThreads(__tstate);
47500 if (PyErr_Occurred()) SWIG_fail;
47501 }
47502 resultobj = SWIG_Py_Void();
47503 return resultobj;
47504 fail:
47505 return NULL;
47506 }
47507
47508
47509 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47510 PyObject *resultobj = 0;
47511 wxSizer *arg1 = (wxSizer *) 0 ;
47512 wxWindow *arg2 = (wxWindow *) 0 ;
47513 void *argp1 = 0 ;
47514 int res1 = 0 ;
47515 void *argp2 = 0 ;
47516 int res2 = 0 ;
47517 PyObject * obj0 = 0 ;
47518 PyObject * obj1 = 0 ;
47519 char * kwnames[] = {
47520 (char *) "self",(char *) "window", NULL
47521 };
47522
47523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47525 if (!SWIG_IsOK(res1)) {
47526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47527 }
47528 arg1 = reinterpret_cast< wxSizer * >(argp1);
47529 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47530 if (!SWIG_IsOK(res2)) {
47531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47532 }
47533 arg2 = reinterpret_cast< wxWindow * >(argp2);
47534 {
47535 PyThreadState* __tstate = wxPyBeginAllowThreads();
47536 (arg1)->SetVirtualSizeHints(arg2);
47537 wxPyEndAllowThreads(__tstate);
47538 if (PyErr_Occurred()) SWIG_fail;
47539 }
47540 resultobj = SWIG_Py_Void();
47541 return resultobj;
47542 fail:
47543 return NULL;
47544 }
47545
47546
47547 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47548 PyObject *resultobj = 0;
47549 wxSizer *arg1 = (wxSizer *) 0 ;
47550 bool arg2 = (bool) false ;
47551 void *argp1 = 0 ;
47552 int res1 = 0 ;
47553 bool val2 ;
47554 int ecode2 = 0 ;
47555 PyObject * obj0 = 0 ;
47556 PyObject * obj1 = 0 ;
47557 char * kwnames[] = {
47558 (char *) "self",(char *) "deleteWindows", NULL
47559 };
47560
47561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47563 if (!SWIG_IsOK(res1)) {
47564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47565 }
47566 arg1 = reinterpret_cast< wxSizer * >(argp1);
47567 if (obj1) {
47568 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47569 if (!SWIG_IsOK(ecode2)) {
47570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47571 }
47572 arg2 = static_cast< bool >(val2);
47573 }
47574 {
47575 PyThreadState* __tstate = wxPyBeginAllowThreads();
47576 (arg1)->Clear(arg2);
47577 wxPyEndAllowThreads(__tstate);
47578 if (PyErr_Occurred()) SWIG_fail;
47579 }
47580 resultobj = SWIG_Py_Void();
47581 return resultobj;
47582 fail:
47583 return NULL;
47584 }
47585
47586
47587 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47588 PyObject *resultobj = 0;
47589 wxSizer *arg1 = (wxSizer *) 0 ;
47590 void *argp1 = 0 ;
47591 int res1 = 0 ;
47592 PyObject *swig_obj[1] ;
47593
47594 if (!args) SWIG_fail;
47595 swig_obj[0] = args;
47596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47597 if (!SWIG_IsOK(res1)) {
47598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47599 }
47600 arg1 = reinterpret_cast< wxSizer * >(argp1);
47601 {
47602 PyThreadState* __tstate = wxPyBeginAllowThreads();
47603 (arg1)->DeleteWindows();
47604 wxPyEndAllowThreads(__tstate);
47605 if (PyErr_Occurred()) SWIG_fail;
47606 }
47607 resultobj = SWIG_Py_Void();
47608 return resultobj;
47609 fail:
47610 return NULL;
47611 }
47612
47613
47614 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47615 PyObject *resultobj = 0;
47616 wxSizer *arg1 = (wxSizer *) 0 ;
47617 PyObject *result = 0 ;
47618 void *argp1 = 0 ;
47619 int res1 = 0 ;
47620 PyObject *swig_obj[1] ;
47621
47622 if (!args) SWIG_fail;
47623 swig_obj[0] = args;
47624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47625 if (!SWIG_IsOK(res1)) {
47626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47627 }
47628 arg1 = reinterpret_cast< wxSizer * >(argp1);
47629 {
47630 PyThreadState* __tstate = wxPyBeginAllowThreads();
47631 result = (PyObject *)wxSizer_GetChildren(arg1);
47632 wxPyEndAllowThreads(__tstate);
47633 if (PyErr_Occurred()) SWIG_fail;
47634 }
47635 resultobj = result;
47636 return resultobj;
47637 fail:
47638 return NULL;
47639 }
47640
47641
47642 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47643 PyObject *resultobj = 0;
47644 wxSizer *arg1 = (wxSizer *) 0 ;
47645 PyObject *arg2 = (PyObject *) 0 ;
47646 bool arg3 = (bool) true ;
47647 bool arg4 = (bool) false ;
47648 bool result;
47649 void *argp1 = 0 ;
47650 int res1 = 0 ;
47651 bool val3 ;
47652 int ecode3 = 0 ;
47653 bool val4 ;
47654 int ecode4 = 0 ;
47655 PyObject * obj0 = 0 ;
47656 PyObject * obj1 = 0 ;
47657 PyObject * obj2 = 0 ;
47658 PyObject * obj3 = 0 ;
47659 char * kwnames[] = {
47660 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47661 };
47662
47663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47665 if (!SWIG_IsOK(res1)) {
47666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47667 }
47668 arg1 = reinterpret_cast< wxSizer * >(argp1);
47669 arg2 = obj1;
47670 if (obj2) {
47671 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47672 if (!SWIG_IsOK(ecode3)) {
47673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47674 }
47675 arg3 = static_cast< bool >(val3);
47676 }
47677 if (obj3) {
47678 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47679 if (!SWIG_IsOK(ecode4)) {
47680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47681 }
47682 arg4 = static_cast< bool >(val4);
47683 }
47684 {
47685 PyThreadState* __tstate = wxPyBeginAllowThreads();
47686 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47687 wxPyEndAllowThreads(__tstate);
47688 if (PyErr_Occurred()) SWIG_fail;
47689 }
47690 {
47691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47692 }
47693 return resultobj;
47694 fail:
47695 return NULL;
47696 }
47697
47698
47699 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47700 PyObject *resultobj = 0;
47701 wxSizer *arg1 = (wxSizer *) 0 ;
47702 PyObject *arg2 = (PyObject *) 0 ;
47703 bool result;
47704 void *argp1 = 0 ;
47705 int res1 = 0 ;
47706 PyObject * obj0 = 0 ;
47707 PyObject * obj1 = 0 ;
47708 char * kwnames[] = {
47709 (char *) "self",(char *) "item", NULL
47710 };
47711
47712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47714 if (!SWIG_IsOK(res1)) {
47715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47716 }
47717 arg1 = reinterpret_cast< wxSizer * >(argp1);
47718 arg2 = obj1;
47719 {
47720 PyThreadState* __tstate = wxPyBeginAllowThreads();
47721 result = (bool)wxSizer_IsShown(arg1,arg2);
47722 wxPyEndAllowThreads(__tstate);
47723 if (PyErr_Occurred()) SWIG_fail;
47724 }
47725 {
47726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47727 }
47728 return resultobj;
47729 fail:
47730 return NULL;
47731 }
47732
47733
47734 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47735 PyObject *resultobj = 0;
47736 wxSizer *arg1 = (wxSizer *) 0 ;
47737 bool arg2 ;
47738 void *argp1 = 0 ;
47739 int res1 = 0 ;
47740 bool val2 ;
47741 int ecode2 = 0 ;
47742 PyObject * obj0 = 0 ;
47743 PyObject * obj1 = 0 ;
47744 char * kwnames[] = {
47745 (char *) "self",(char *) "show", NULL
47746 };
47747
47748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47750 if (!SWIG_IsOK(res1)) {
47751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47752 }
47753 arg1 = reinterpret_cast< wxSizer * >(argp1);
47754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47755 if (!SWIG_IsOK(ecode2)) {
47756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47757 }
47758 arg2 = static_cast< bool >(val2);
47759 {
47760 PyThreadState* __tstate = wxPyBeginAllowThreads();
47761 (arg1)->ShowItems(arg2);
47762 wxPyEndAllowThreads(__tstate);
47763 if (PyErr_Occurred()) SWIG_fail;
47764 }
47765 resultobj = SWIG_Py_Void();
47766 return resultobj;
47767 fail:
47768 return NULL;
47769 }
47770
47771
47772 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47773 PyObject *obj;
47774 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47775 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47776 return SWIG_Py_Void();
47777 }
47778
47779 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47780 PyObject *resultobj = 0;
47781 wxPySizer *result = 0 ;
47782
47783 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47784 {
47785 PyThreadState* __tstate = wxPyBeginAllowThreads();
47786 result = (wxPySizer *)new wxPySizer();
47787 wxPyEndAllowThreads(__tstate);
47788 if (PyErr_Occurred()) SWIG_fail;
47789 }
47790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47791 return resultobj;
47792 fail:
47793 return NULL;
47794 }
47795
47796
47797 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47798 PyObject *resultobj = 0;
47799 wxPySizer *arg1 = (wxPySizer *) 0 ;
47800 PyObject *arg2 = (PyObject *) 0 ;
47801 PyObject *arg3 = (PyObject *) 0 ;
47802 void *argp1 = 0 ;
47803 int res1 = 0 ;
47804 PyObject * obj0 = 0 ;
47805 PyObject * obj1 = 0 ;
47806 PyObject * obj2 = 0 ;
47807 char * kwnames[] = {
47808 (char *) "self",(char *) "self",(char *) "_class", NULL
47809 };
47810
47811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47813 if (!SWIG_IsOK(res1)) {
47814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47815 }
47816 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47817 arg2 = obj1;
47818 arg3 = obj2;
47819 {
47820 PyThreadState* __tstate = wxPyBeginAllowThreads();
47821 (arg1)->_setCallbackInfo(arg2,arg3);
47822 wxPyEndAllowThreads(__tstate);
47823 if (PyErr_Occurred()) SWIG_fail;
47824 }
47825 resultobj = SWIG_Py_Void();
47826 return resultobj;
47827 fail:
47828 return NULL;
47829 }
47830
47831
47832 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47833 PyObject *obj;
47834 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47835 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47836 return SWIG_Py_Void();
47837 }
47838
47839 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47840 return SWIG_Python_InitShadowInstance(args);
47841 }
47842
47843 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47844 PyObject *resultobj = 0;
47845 int arg1 = (int) wxHORIZONTAL ;
47846 wxBoxSizer *result = 0 ;
47847 int val1 ;
47848 int ecode1 = 0 ;
47849 PyObject * obj0 = 0 ;
47850 char * kwnames[] = {
47851 (char *) "orient", NULL
47852 };
47853
47854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47855 if (obj0) {
47856 ecode1 = SWIG_AsVal_int(obj0, &val1);
47857 if (!SWIG_IsOK(ecode1)) {
47858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47859 }
47860 arg1 = static_cast< int >(val1);
47861 }
47862 {
47863 PyThreadState* __tstate = wxPyBeginAllowThreads();
47864 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47865 wxPyEndAllowThreads(__tstate);
47866 if (PyErr_Occurred()) SWIG_fail;
47867 }
47868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47869 return resultobj;
47870 fail:
47871 return NULL;
47872 }
47873
47874
47875 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47876 PyObject *resultobj = 0;
47877 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47878 int result;
47879 void *argp1 = 0 ;
47880 int res1 = 0 ;
47881 PyObject *swig_obj[1] ;
47882
47883 if (!args) SWIG_fail;
47884 swig_obj[0] = args;
47885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47886 if (!SWIG_IsOK(res1)) {
47887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47888 }
47889 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47890 {
47891 PyThreadState* __tstate = wxPyBeginAllowThreads();
47892 result = (int)(arg1)->GetOrientation();
47893 wxPyEndAllowThreads(__tstate);
47894 if (PyErr_Occurred()) SWIG_fail;
47895 }
47896 resultobj = SWIG_From_int(static_cast< int >(result));
47897 return resultobj;
47898 fail:
47899 return NULL;
47900 }
47901
47902
47903 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47904 PyObject *resultobj = 0;
47905 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47906 int arg2 ;
47907 void *argp1 = 0 ;
47908 int res1 = 0 ;
47909 int val2 ;
47910 int ecode2 = 0 ;
47911 PyObject * obj0 = 0 ;
47912 PyObject * obj1 = 0 ;
47913 char * kwnames[] = {
47914 (char *) "self",(char *) "orient", NULL
47915 };
47916
47917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47919 if (!SWIG_IsOK(res1)) {
47920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47921 }
47922 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47923 ecode2 = SWIG_AsVal_int(obj1, &val2);
47924 if (!SWIG_IsOK(ecode2)) {
47925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47926 }
47927 arg2 = static_cast< int >(val2);
47928 {
47929 PyThreadState* __tstate = wxPyBeginAllowThreads();
47930 (arg1)->SetOrientation(arg2);
47931 wxPyEndAllowThreads(__tstate);
47932 if (PyErr_Occurred()) SWIG_fail;
47933 }
47934 resultobj = SWIG_Py_Void();
47935 return resultobj;
47936 fail:
47937 return NULL;
47938 }
47939
47940
47941 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47942 PyObject *obj;
47943 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47944 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47945 return SWIG_Py_Void();
47946 }
47947
47948 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47949 return SWIG_Python_InitShadowInstance(args);
47950 }
47951
47952 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47953 PyObject *resultobj = 0;
47954 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47955 int arg2 = (int) wxHORIZONTAL ;
47956 wxStaticBoxSizer *result = 0 ;
47957 void *argp1 = 0 ;
47958 int res1 = 0 ;
47959 int val2 ;
47960 int ecode2 = 0 ;
47961 PyObject * obj0 = 0 ;
47962 PyObject * obj1 = 0 ;
47963 char * kwnames[] = {
47964 (char *) "box",(char *) "orient", NULL
47965 };
47966
47967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47969 if (!SWIG_IsOK(res1)) {
47970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47971 }
47972 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47973 if (obj1) {
47974 ecode2 = SWIG_AsVal_int(obj1, &val2);
47975 if (!SWIG_IsOK(ecode2)) {
47976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47977 }
47978 arg2 = static_cast< int >(val2);
47979 }
47980 {
47981 PyThreadState* __tstate = wxPyBeginAllowThreads();
47982 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47983 wxPyEndAllowThreads(__tstate);
47984 if (PyErr_Occurred()) SWIG_fail;
47985 }
47986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47987 return resultobj;
47988 fail:
47989 return NULL;
47990 }
47991
47992
47993 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47994 PyObject *resultobj = 0;
47995 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47996 wxStaticBox *result = 0 ;
47997 void *argp1 = 0 ;
47998 int res1 = 0 ;
47999 PyObject *swig_obj[1] ;
48000
48001 if (!args) SWIG_fail;
48002 swig_obj[0] = args;
48003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48004 if (!SWIG_IsOK(res1)) {
48005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48006 }
48007 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48008 {
48009 PyThreadState* __tstate = wxPyBeginAllowThreads();
48010 result = (wxStaticBox *)(arg1)->GetStaticBox();
48011 wxPyEndAllowThreads(__tstate);
48012 if (PyErr_Occurred()) SWIG_fail;
48013 }
48014 {
48015 resultobj = wxPyMake_wxObject(result, (bool)0);
48016 }
48017 return resultobj;
48018 fail:
48019 return NULL;
48020 }
48021
48022
48023 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48024 PyObject *obj;
48025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48026 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48027 return SWIG_Py_Void();
48028 }
48029
48030 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48031 return SWIG_Python_InitShadowInstance(args);
48032 }
48033
48034 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48035 PyObject *resultobj = 0;
48036 int arg1 = (int) 1 ;
48037 int arg2 = (int) 0 ;
48038 int arg3 = (int) 0 ;
48039 int arg4 = (int) 0 ;
48040 wxGridSizer *result = 0 ;
48041 int val1 ;
48042 int ecode1 = 0 ;
48043 int val2 ;
48044 int ecode2 = 0 ;
48045 int val3 ;
48046 int ecode3 = 0 ;
48047 int val4 ;
48048 int ecode4 = 0 ;
48049 PyObject * obj0 = 0 ;
48050 PyObject * obj1 = 0 ;
48051 PyObject * obj2 = 0 ;
48052 PyObject * obj3 = 0 ;
48053 char * kwnames[] = {
48054 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48055 };
48056
48057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48058 if (obj0) {
48059 ecode1 = SWIG_AsVal_int(obj0, &val1);
48060 if (!SWIG_IsOK(ecode1)) {
48061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48062 }
48063 arg1 = static_cast< int >(val1);
48064 }
48065 if (obj1) {
48066 ecode2 = SWIG_AsVal_int(obj1, &val2);
48067 if (!SWIG_IsOK(ecode2)) {
48068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48069 }
48070 arg2 = static_cast< int >(val2);
48071 }
48072 if (obj2) {
48073 ecode3 = SWIG_AsVal_int(obj2, &val3);
48074 if (!SWIG_IsOK(ecode3)) {
48075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48076 }
48077 arg3 = static_cast< int >(val3);
48078 }
48079 if (obj3) {
48080 ecode4 = SWIG_AsVal_int(obj3, &val4);
48081 if (!SWIG_IsOK(ecode4)) {
48082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48083 }
48084 arg4 = static_cast< int >(val4);
48085 }
48086 {
48087 PyThreadState* __tstate = wxPyBeginAllowThreads();
48088 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48089 wxPyEndAllowThreads(__tstate);
48090 if (PyErr_Occurred()) SWIG_fail;
48091 }
48092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48093 return resultobj;
48094 fail:
48095 return NULL;
48096 }
48097
48098
48099 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48100 PyObject *resultobj = 0;
48101 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48102 int arg2 ;
48103 void *argp1 = 0 ;
48104 int res1 = 0 ;
48105 int val2 ;
48106 int ecode2 = 0 ;
48107 PyObject * obj0 = 0 ;
48108 PyObject * obj1 = 0 ;
48109 char * kwnames[] = {
48110 (char *) "self",(char *) "cols", NULL
48111 };
48112
48113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48115 if (!SWIG_IsOK(res1)) {
48116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48117 }
48118 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48119 ecode2 = SWIG_AsVal_int(obj1, &val2);
48120 if (!SWIG_IsOK(ecode2)) {
48121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48122 }
48123 arg2 = static_cast< int >(val2);
48124 {
48125 PyThreadState* __tstate = wxPyBeginAllowThreads();
48126 (arg1)->SetCols(arg2);
48127 wxPyEndAllowThreads(__tstate);
48128 if (PyErr_Occurred()) SWIG_fail;
48129 }
48130 resultobj = SWIG_Py_Void();
48131 return resultobj;
48132 fail:
48133 return NULL;
48134 }
48135
48136
48137 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48138 PyObject *resultobj = 0;
48139 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48140 int arg2 ;
48141 void *argp1 = 0 ;
48142 int res1 = 0 ;
48143 int val2 ;
48144 int ecode2 = 0 ;
48145 PyObject * obj0 = 0 ;
48146 PyObject * obj1 = 0 ;
48147 char * kwnames[] = {
48148 (char *) "self",(char *) "rows", NULL
48149 };
48150
48151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48153 if (!SWIG_IsOK(res1)) {
48154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48155 }
48156 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48157 ecode2 = SWIG_AsVal_int(obj1, &val2);
48158 if (!SWIG_IsOK(ecode2)) {
48159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48160 }
48161 arg2 = static_cast< int >(val2);
48162 {
48163 PyThreadState* __tstate = wxPyBeginAllowThreads();
48164 (arg1)->SetRows(arg2);
48165 wxPyEndAllowThreads(__tstate);
48166 if (PyErr_Occurred()) SWIG_fail;
48167 }
48168 resultobj = SWIG_Py_Void();
48169 return resultobj;
48170 fail:
48171 return NULL;
48172 }
48173
48174
48175 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48176 PyObject *resultobj = 0;
48177 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48178 int arg2 ;
48179 void *argp1 = 0 ;
48180 int res1 = 0 ;
48181 int val2 ;
48182 int ecode2 = 0 ;
48183 PyObject * obj0 = 0 ;
48184 PyObject * obj1 = 0 ;
48185 char * kwnames[] = {
48186 (char *) "self",(char *) "gap", NULL
48187 };
48188
48189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48191 if (!SWIG_IsOK(res1)) {
48192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48193 }
48194 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48195 ecode2 = SWIG_AsVal_int(obj1, &val2);
48196 if (!SWIG_IsOK(ecode2)) {
48197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48198 }
48199 arg2 = static_cast< int >(val2);
48200 {
48201 PyThreadState* __tstate = wxPyBeginAllowThreads();
48202 (arg1)->SetVGap(arg2);
48203 wxPyEndAllowThreads(__tstate);
48204 if (PyErr_Occurred()) SWIG_fail;
48205 }
48206 resultobj = SWIG_Py_Void();
48207 return resultobj;
48208 fail:
48209 return NULL;
48210 }
48211
48212
48213 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48214 PyObject *resultobj = 0;
48215 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48216 int arg2 ;
48217 void *argp1 = 0 ;
48218 int res1 = 0 ;
48219 int val2 ;
48220 int ecode2 = 0 ;
48221 PyObject * obj0 = 0 ;
48222 PyObject * obj1 = 0 ;
48223 char * kwnames[] = {
48224 (char *) "self",(char *) "gap", NULL
48225 };
48226
48227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48229 if (!SWIG_IsOK(res1)) {
48230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48231 }
48232 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48233 ecode2 = SWIG_AsVal_int(obj1, &val2);
48234 if (!SWIG_IsOK(ecode2)) {
48235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48236 }
48237 arg2 = static_cast< int >(val2);
48238 {
48239 PyThreadState* __tstate = wxPyBeginAllowThreads();
48240 (arg1)->SetHGap(arg2);
48241 wxPyEndAllowThreads(__tstate);
48242 if (PyErr_Occurred()) SWIG_fail;
48243 }
48244 resultobj = SWIG_Py_Void();
48245 return resultobj;
48246 fail:
48247 return NULL;
48248 }
48249
48250
48251 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48252 PyObject *resultobj = 0;
48253 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48254 int result;
48255 void *argp1 = 0 ;
48256 int res1 = 0 ;
48257 PyObject *swig_obj[1] ;
48258
48259 if (!args) SWIG_fail;
48260 swig_obj[0] = args;
48261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48262 if (!SWIG_IsOK(res1)) {
48263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48264 }
48265 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48266 {
48267 PyThreadState* __tstate = wxPyBeginAllowThreads();
48268 result = (int)(arg1)->GetCols();
48269 wxPyEndAllowThreads(__tstate);
48270 if (PyErr_Occurred()) SWIG_fail;
48271 }
48272 resultobj = SWIG_From_int(static_cast< int >(result));
48273 return resultobj;
48274 fail:
48275 return NULL;
48276 }
48277
48278
48279 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48280 PyObject *resultobj = 0;
48281 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48282 int result;
48283 void *argp1 = 0 ;
48284 int res1 = 0 ;
48285 PyObject *swig_obj[1] ;
48286
48287 if (!args) SWIG_fail;
48288 swig_obj[0] = args;
48289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48290 if (!SWIG_IsOK(res1)) {
48291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48292 }
48293 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48294 {
48295 PyThreadState* __tstate = wxPyBeginAllowThreads();
48296 result = (int)(arg1)->GetRows();
48297 wxPyEndAllowThreads(__tstate);
48298 if (PyErr_Occurred()) SWIG_fail;
48299 }
48300 resultobj = SWIG_From_int(static_cast< int >(result));
48301 return resultobj;
48302 fail:
48303 return NULL;
48304 }
48305
48306
48307 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48308 PyObject *resultobj = 0;
48309 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48310 int result;
48311 void *argp1 = 0 ;
48312 int res1 = 0 ;
48313 PyObject *swig_obj[1] ;
48314
48315 if (!args) SWIG_fail;
48316 swig_obj[0] = args;
48317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48318 if (!SWIG_IsOK(res1)) {
48319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48320 }
48321 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48322 {
48323 PyThreadState* __tstate = wxPyBeginAllowThreads();
48324 result = (int)(arg1)->GetVGap();
48325 wxPyEndAllowThreads(__tstate);
48326 if (PyErr_Occurred()) SWIG_fail;
48327 }
48328 resultobj = SWIG_From_int(static_cast< int >(result));
48329 return resultobj;
48330 fail:
48331 return NULL;
48332 }
48333
48334
48335 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48336 PyObject *resultobj = 0;
48337 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48338 int result;
48339 void *argp1 = 0 ;
48340 int res1 = 0 ;
48341 PyObject *swig_obj[1] ;
48342
48343 if (!args) SWIG_fail;
48344 swig_obj[0] = args;
48345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48346 if (!SWIG_IsOK(res1)) {
48347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48348 }
48349 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48350 {
48351 PyThreadState* __tstate = wxPyBeginAllowThreads();
48352 result = (int)(arg1)->GetHGap();
48353 wxPyEndAllowThreads(__tstate);
48354 if (PyErr_Occurred()) SWIG_fail;
48355 }
48356 resultobj = SWIG_From_int(static_cast< int >(result));
48357 return resultobj;
48358 fail:
48359 return NULL;
48360 }
48361
48362
48363 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48364 PyObject *obj;
48365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48366 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48367 return SWIG_Py_Void();
48368 }
48369
48370 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48371 return SWIG_Python_InitShadowInstance(args);
48372 }
48373
48374 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48375 PyObject *resultobj = 0;
48376 int arg1 = (int) 1 ;
48377 int arg2 = (int) 0 ;
48378 int arg3 = (int) 0 ;
48379 int arg4 = (int) 0 ;
48380 wxFlexGridSizer *result = 0 ;
48381 int val1 ;
48382 int ecode1 = 0 ;
48383 int val2 ;
48384 int ecode2 = 0 ;
48385 int val3 ;
48386 int ecode3 = 0 ;
48387 int val4 ;
48388 int ecode4 = 0 ;
48389 PyObject * obj0 = 0 ;
48390 PyObject * obj1 = 0 ;
48391 PyObject * obj2 = 0 ;
48392 PyObject * obj3 = 0 ;
48393 char * kwnames[] = {
48394 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48395 };
48396
48397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48398 if (obj0) {
48399 ecode1 = SWIG_AsVal_int(obj0, &val1);
48400 if (!SWIG_IsOK(ecode1)) {
48401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48402 }
48403 arg1 = static_cast< int >(val1);
48404 }
48405 if (obj1) {
48406 ecode2 = SWIG_AsVal_int(obj1, &val2);
48407 if (!SWIG_IsOK(ecode2)) {
48408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48409 }
48410 arg2 = static_cast< int >(val2);
48411 }
48412 if (obj2) {
48413 ecode3 = SWIG_AsVal_int(obj2, &val3);
48414 if (!SWIG_IsOK(ecode3)) {
48415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48416 }
48417 arg3 = static_cast< int >(val3);
48418 }
48419 if (obj3) {
48420 ecode4 = SWIG_AsVal_int(obj3, &val4);
48421 if (!SWIG_IsOK(ecode4)) {
48422 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48423 }
48424 arg4 = static_cast< int >(val4);
48425 }
48426 {
48427 PyThreadState* __tstate = wxPyBeginAllowThreads();
48428 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48429 wxPyEndAllowThreads(__tstate);
48430 if (PyErr_Occurred()) SWIG_fail;
48431 }
48432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48433 return resultobj;
48434 fail:
48435 return NULL;
48436 }
48437
48438
48439 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48440 PyObject *resultobj = 0;
48441 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48442 size_t arg2 ;
48443 int arg3 = (int) 0 ;
48444 void *argp1 = 0 ;
48445 int res1 = 0 ;
48446 size_t val2 ;
48447 int ecode2 = 0 ;
48448 int val3 ;
48449 int ecode3 = 0 ;
48450 PyObject * obj0 = 0 ;
48451 PyObject * obj1 = 0 ;
48452 PyObject * obj2 = 0 ;
48453 char * kwnames[] = {
48454 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48455 };
48456
48457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48459 if (!SWIG_IsOK(res1)) {
48460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48461 }
48462 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48463 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48464 if (!SWIG_IsOK(ecode2)) {
48465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48466 }
48467 arg2 = static_cast< size_t >(val2);
48468 if (obj2) {
48469 ecode3 = SWIG_AsVal_int(obj2, &val3);
48470 if (!SWIG_IsOK(ecode3)) {
48471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48472 }
48473 arg3 = static_cast< int >(val3);
48474 }
48475 {
48476 PyThreadState* __tstate = wxPyBeginAllowThreads();
48477 (arg1)->AddGrowableRow(arg2,arg3);
48478 wxPyEndAllowThreads(__tstate);
48479 if (PyErr_Occurred()) SWIG_fail;
48480 }
48481 resultobj = SWIG_Py_Void();
48482 return resultobj;
48483 fail:
48484 return NULL;
48485 }
48486
48487
48488 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48489 PyObject *resultobj = 0;
48490 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48491 size_t arg2 ;
48492 void *argp1 = 0 ;
48493 int res1 = 0 ;
48494 size_t val2 ;
48495 int ecode2 = 0 ;
48496 PyObject * obj0 = 0 ;
48497 PyObject * obj1 = 0 ;
48498 char * kwnames[] = {
48499 (char *) "self",(char *) "idx", NULL
48500 };
48501
48502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48504 if (!SWIG_IsOK(res1)) {
48505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48506 }
48507 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48508 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48509 if (!SWIG_IsOK(ecode2)) {
48510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48511 }
48512 arg2 = static_cast< size_t >(val2);
48513 {
48514 PyThreadState* __tstate = wxPyBeginAllowThreads();
48515 (arg1)->RemoveGrowableRow(arg2);
48516 wxPyEndAllowThreads(__tstate);
48517 if (PyErr_Occurred()) SWIG_fail;
48518 }
48519 resultobj = SWIG_Py_Void();
48520 return resultobj;
48521 fail:
48522 return NULL;
48523 }
48524
48525
48526 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48527 PyObject *resultobj = 0;
48528 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48529 size_t arg2 ;
48530 int arg3 = (int) 0 ;
48531 void *argp1 = 0 ;
48532 int res1 = 0 ;
48533 size_t val2 ;
48534 int ecode2 = 0 ;
48535 int val3 ;
48536 int ecode3 = 0 ;
48537 PyObject * obj0 = 0 ;
48538 PyObject * obj1 = 0 ;
48539 PyObject * obj2 = 0 ;
48540 char * kwnames[] = {
48541 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48542 };
48543
48544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48546 if (!SWIG_IsOK(res1)) {
48547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48548 }
48549 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48550 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48551 if (!SWIG_IsOK(ecode2)) {
48552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48553 }
48554 arg2 = static_cast< size_t >(val2);
48555 if (obj2) {
48556 ecode3 = SWIG_AsVal_int(obj2, &val3);
48557 if (!SWIG_IsOK(ecode3)) {
48558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48559 }
48560 arg3 = static_cast< int >(val3);
48561 }
48562 {
48563 PyThreadState* __tstate = wxPyBeginAllowThreads();
48564 (arg1)->AddGrowableCol(arg2,arg3);
48565 wxPyEndAllowThreads(__tstate);
48566 if (PyErr_Occurred()) SWIG_fail;
48567 }
48568 resultobj = SWIG_Py_Void();
48569 return resultobj;
48570 fail:
48571 return NULL;
48572 }
48573
48574
48575 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48576 PyObject *resultobj = 0;
48577 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48578 size_t arg2 ;
48579 void *argp1 = 0 ;
48580 int res1 = 0 ;
48581 size_t val2 ;
48582 int ecode2 = 0 ;
48583 PyObject * obj0 = 0 ;
48584 PyObject * obj1 = 0 ;
48585 char * kwnames[] = {
48586 (char *) "self",(char *) "idx", NULL
48587 };
48588
48589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48591 if (!SWIG_IsOK(res1)) {
48592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48593 }
48594 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48595 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48596 if (!SWIG_IsOK(ecode2)) {
48597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48598 }
48599 arg2 = static_cast< size_t >(val2);
48600 {
48601 PyThreadState* __tstate = wxPyBeginAllowThreads();
48602 (arg1)->RemoveGrowableCol(arg2);
48603 wxPyEndAllowThreads(__tstate);
48604 if (PyErr_Occurred()) SWIG_fail;
48605 }
48606 resultobj = SWIG_Py_Void();
48607 return resultobj;
48608 fail:
48609 return NULL;
48610 }
48611
48612
48613 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48614 PyObject *resultobj = 0;
48615 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48616 int arg2 ;
48617 void *argp1 = 0 ;
48618 int res1 = 0 ;
48619 int val2 ;
48620 int ecode2 = 0 ;
48621 PyObject * obj0 = 0 ;
48622 PyObject * obj1 = 0 ;
48623 char * kwnames[] = {
48624 (char *) "self",(char *) "direction", NULL
48625 };
48626
48627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48629 if (!SWIG_IsOK(res1)) {
48630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48631 }
48632 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48633 ecode2 = SWIG_AsVal_int(obj1, &val2);
48634 if (!SWIG_IsOK(ecode2)) {
48635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48636 }
48637 arg2 = static_cast< int >(val2);
48638 {
48639 PyThreadState* __tstate = wxPyBeginAllowThreads();
48640 (arg1)->SetFlexibleDirection(arg2);
48641 wxPyEndAllowThreads(__tstate);
48642 if (PyErr_Occurred()) SWIG_fail;
48643 }
48644 resultobj = SWIG_Py_Void();
48645 return resultobj;
48646 fail:
48647 return NULL;
48648 }
48649
48650
48651 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48652 PyObject *resultobj = 0;
48653 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48654 int result;
48655 void *argp1 = 0 ;
48656 int res1 = 0 ;
48657 PyObject *swig_obj[1] ;
48658
48659 if (!args) SWIG_fail;
48660 swig_obj[0] = args;
48661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48662 if (!SWIG_IsOK(res1)) {
48663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48664 }
48665 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48666 {
48667 PyThreadState* __tstate = wxPyBeginAllowThreads();
48668 result = (int)(arg1)->GetFlexibleDirection();
48669 wxPyEndAllowThreads(__tstate);
48670 if (PyErr_Occurred()) SWIG_fail;
48671 }
48672 resultobj = SWIG_From_int(static_cast< int >(result));
48673 return resultobj;
48674 fail:
48675 return NULL;
48676 }
48677
48678
48679 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48680 PyObject *resultobj = 0;
48681 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48682 wxFlexSizerGrowMode arg2 ;
48683 void *argp1 = 0 ;
48684 int res1 = 0 ;
48685 int val2 ;
48686 int ecode2 = 0 ;
48687 PyObject * obj0 = 0 ;
48688 PyObject * obj1 = 0 ;
48689 char * kwnames[] = {
48690 (char *) "self",(char *) "mode", NULL
48691 };
48692
48693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48695 if (!SWIG_IsOK(res1)) {
48696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48697 }
48698 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48699 ecode2 = SWIG_AsVal_int(obj1, &val2);
48700 if (!SWIG_IsOK(ecode2)) {
48701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48702 }
48703 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48704 {
48705 PyThreadState* __tstate = wxPyBeginAllowThreads();
48706 (arg1)->SetNonFlexibleGrowMode(arg2);
48707 wxPyEndAllowThreads(__tstate);
48708 if (PyErr_Occurred()) SWIG_fail;
48709 }
48710 resultobj = SWIG_Py_Void();
48711 return resultobj;
48712 fail:
48713 return NULL;
48714 }
48715
48716
48717 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48718 PyObject *resultobj = 0;
48719 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48720 wxFlexSizerGrowMode result;
48721 void *argp1 = 0 ;
48722 int res1 = 0 ;
48723 PyObject *swig_obj[1] ;
48724
48725 if (!args) SWIG_fail;
48726 swig_obj[0] = args;
48727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48728 if (!SWIG_IsOK(res1)) {
48729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48730 }
48731 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48732 {
48733 PyThreadState* __tstate = wxPyBeginAllowThreads();
48734 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48735 wxPyEndAllowThreads(__tstate);
48736 if (PyErr_Occurred()) SWIG_fail;
48737 }
48738 resultobj = SWIG_From_int(static_cast< int >(result));
48739 return resultobj;
48740 fail:
48741 return NULL;
48742 }
48743
48744
48745 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48746 PyObject *resultobj = 0;
48747 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48748 wxArrayInt *result = 0 ;
48749 void *argp1 = 0 ;
48750 int res1 = 0 ;
48751 PyObject *swig_obj[1] ;
48752
48753 if (!args) SWIG_fail;
48754 swig_obj[0] = args;
48755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48756 if (!SWIG_IsOK(res1)) {
48757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48758 }
48759 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48760 {
48761 PyThreadState* __tstate = wxPyBeginAllowThreads();
48762 {
48763 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48764 result = (wxArrayInt *) &_result_ref;
48765 }
48766 wxPyEndAllowThreads(__tstate);
48767 if (PyErr_Occurred()) SWIG_fail;
48768 }
48769 {
48770 resultobj = PyList_New(0);
48771 size_t idx;
48772 for (idx = 0; idx < result->GetCount(); idx += 1) {
48773 PyObject* val = PyInt_FromLong( result->Item(idx) );
48774 PyList_Append(resultobj, val);
48775 Py_DECREF(val);
48776 }
48777 }
48778 return resultobj;
48779 fail:
48780 return NULL;
48781 }
48782
48783
48784 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48785 PyObject *resultobj = 0;
48786 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48787 wxArrayInt *result = 0 ;
48788 void *argp1 = 0 ;
48789 int res1 = 0 ;
48790 PyObject *swig_obj[1] ;
48791
48792 if (!args) SWIG_fail;
48793 swig_obj[0] = args;
48794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48795 if (!SWIG_IsOK(res1)) {
48796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48797 }
48798 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48799 {
48800 PyThreadState* __tstate = wxPyBeginAllowThreads();
48801 {
48802 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48803 result = (wxArrayInt *) &_result_ref;
48804 }
48805 wxPyEndAllowThreads(__tstate);
48806 if (PyErr_Occurred()) SWIG_fail;
48807 }
48808 {
48809 resultobj = PyList_New(0);
48810 size_t idx;
48811 for (idx = 0; idx < result->GetCount(); idx += 1) {
48812 PyObject* val = PyInt_FromLong( result->Item(idx) );
48813 PyList_Append(resultobj, val);
48814 Py_DECREF(val);
48815 }
48816 }
48817 return resultobj;
48818 fail:
48819 return NULL;
48820 }
48821
48822
48823 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48824 PyObject *obj;
48825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48826 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48827 return SWIG_Py_Void();
48828 }
48829
48830 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48831 return SWIG_Python_InitShadowInstance(args);
48832 }
48833
48834 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48835 PyObject *resultobj = 0;
48836 wxStdDialogButtonSizer *result = 0 ;
48837
48838 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48839 {
48840 PyThreadState* __tstate = wxPyBeginAllowThreads();
48841 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48842 wxPyEndAllowThreads(__tstate);
48843 if (PyErr_Occurred()) SWIG_fail;
48844 }
48845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48846 return resultobj;
48847 fail:
48848 return NULL;
48849 }
48850
48851
48852 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48853 PyObject *resultobj = 0;
48854 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48855 wxButton *arg2 = (wxButton *) 0 ;
48856 void *argp1 = 0 ;
48857 int res1 = 0 ;
48858 void *argp2 = 0 ;
48859 int res2 = 0 ;
48860 PyObject * obj0 = 0 ;
48861 PyObject * obj1 = 0 ;
48862 char * kwnames[] = {
48863 (char *) "self",(char *) "button", NULL
48864 };
48865
48866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48868 if (!SWIG_IsOK(res1)) {
48869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48870 }
48871 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48872 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48873 if (!SWIG_IsOK(res2)) {
48874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48875 }
48876 arg2 = reinterpret_cast< wxButton * >(argp2);
48877 {
48878 PyThreadState* __tstate = wxPyBeginAllowThreads();
48879 (arg1)->AddButton(arg2);
48880 wxPyEndAllowThreads(__tstate);
48881 if (PyErr_Occurred()) SWIG_fail;
48882 }
48883 resultobj = SWIG_Py_Void();
48884 return resultobj;
48885 fail:
48886 return NULL;
48887 }
48888
48889
48890 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48891 PyObject *resultobj = 0;
48892 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48893 void *argp1 = 0 ;
48894 int res1 = 0 ;
48895 PyObject *swig_obj[1] ;
48896
48897 if (!args) SWIG_fail;
48898 swig_obj[0] = args;
48899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48900 if (!SWIG_IsOK(res1)) {
48901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48902 }
48903 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48904 {
48905 PyThreadState* __tstate = wxPyBeginAllowThreads();
48906 (arg1)->Realize();
48907 wxPyEndAllowThreads(__tstate);
48908 if (PyErr_Occurred()) SWIG_fail;
48909 }
48910 resultobj = SWIG_Py_Void();
48911 return resultobj;
48912 fail:
48913 return NULL;
48914 }
48915
48916
48917 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48918 PyObject *resultobj = 0;
48919 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48920 wxButton *arg2 = (wxButton *) 0 ;
48921 void *argp1 = 0 ;
48922 int res1 = 0 ;
48923 void *argp2 = 0 ;
48924 int res2 = 0 ;
48925 PyObject * obj0 = 0 ;
48926 PyObject * obj1 = 0 ;
48927 char * kwnames[] = {
48928 (char *) "self",(char *) "button", NULL
48929 };
48930
48931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48933 if (!SWIG_IsOK(res1)) {
48934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48935 }
48936 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48937 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48938 if (!SWIG_IsOK(res2)) {
48939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48940 }
48941 arg2 = reinterpret_cast< wxButton * >(argp2);
48942 {
48943 PyThreadState* __tstate = wxPyBeginAllowThreads();
48944 (arg1)->SetAffirmativeButton(arg2);
48945 wxPyEndAllowThreads(__tstate);
48946 if (PyErr_Occurred()) SWIG_fail;
48947 }
48948 resultobj = SWIG_Py_Void();
48949 return resultobj;
48950 fail:
48951 return NULL;
48952 }
48953
48954
48955 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48956 PyObject *resultobj = 0;
48957 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48958 wxButton *arg2 = (wxButton *) 0 ;
48959 void *argp1 = 0 ;
48960 int res1 = 0 ;
48961 void *argp2 = 0 ;
48962 int res2 = 0 ;
48963 PyObject * obj0 = 0 ;
48964 PyObject * obj1 = 0 ;
48965 char * kwnames[] = {
48966 (char *) "self",(char *) "button", NULL
48967 };
48968
48969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48971 if (!SWIG_IsOK(res1)) {
48972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48973 }
48974 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48975 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48976 if (!SWIG_IsOK(res2)) {
48977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48978 }
48979 arg2 = reinterpret_cast< wxButton * >(argp2);
48980 {
48981 PyThreadState* __tstate = wxPyBeginAllowThreads();
48982 (arg1)->SetNegativeButton(arg2);
48983 wxPyEndAllowThreads(__tstate);
48984 if (PyErr_Occurred()) SWIG_fail;
48985 }
48986 resultobj = SWIG_Py_Void();
48987 return resultobj;
48988 fail:
48989 return NULL;
48990 }
48991
48992
48993 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48994 PyObject *resultobj = 0;
48995 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48996 wxButton *arg2 = (wxButton *) 0 ;
48997 void *argp1 = 0 ;
48998 int res1 = 0 ;
48999 void *argp2 = 0 ;
49000 int res2 = 0 ;
49001 PyObject * obj0 = 0 ;
49002 PyObject * obj1 = 0 ;
49003 char * kwnames[] = {
49004 (char *) "self",(char *) "button", NULL
49005 };
49006
49007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49009 if (!SWIG_IsOK(res1)) {
49010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49011 }
49012 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49013 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49014 if (!SWIG_IsOK(res2)) {
49015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49016 }
49017 arg2 = reinterpret_cast< wxButton * >(argp2);
49018 {
49019 PyThreadState* __tstate = wxPyBeginAllowThreads();
49020 (arg1)->SetCancelButton(arg2);
49021 wxPyEndAllowThreads(__tstate);
49022 if (PyErr_Occurred()) SWIG_fail;
49023 }
49024 resultobj = SWIG_Py_Void();
49025 return resultobj;
49026 fail:
49027 return NULL;
49028 }
49029
49030
49031 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49032 PyObject *resultobj = 0;
49033 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49034 wxButton *result = 0 ;
49035 void *argp1 = 0 ;
49036 int res1 = 0 ;
49037 PyObject *swig_obj[1] ;
49038
49039 if (!args) SWIG_fail;
49040 swig_obj[0] = args;
49041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49042 if (!SWIG_IsOK(res1)) {
49043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49044 }
49045 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49046 {
49047 PyThreadState* __tstate = wxPyBeginAllowThreads();
49048 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49049 wxPyEndAllowThreads(__tstate);
49050 if (PyErr_Occurred()) SWIG_fail;
49051 }
49052 {
49053 resultobj = wxPyMake_wxObject(result, (bool)0);
49054 }
49055 return resultobj;
49056 fail:
49057 return NULL;
49058 }
49059
49060
49061 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49062 PyObject *resultobj = 0;
49063 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49064 wxButton *result = 0 ;
49065 void *argp1 = 0 ;
49066 int res1 = 0 ;
49067 PyObject *swig_obj[1] ;
49068
49069 if (!args) SWIG_fail;
49070 swig_obj[0] = args;
49071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49072 if (!SWIG_IsOK(res1)) {
49073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49074 }
49075 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49076 {
49077 PyThreadState* __tstate = wxPyBeginAllowThreads();
49078 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49079 wxPyEndAllowThreads(__tstate);
49080 if (PyErr_Occurred()) SWIG_fail;
49081 }
49082 {
49083 resultobj = wxPyMake_wxObject(result, (bool)0);
49084 }
49085 return resultobj;
49086 fail:
49087 return NULL;
49088 }
49089
49090
49091 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49092 PyObject *resultobj = 0;
49093 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49094 wxButton *result = 0 ;
49095 void *argp1 = 0 ;
49096 int res1 = 0 ;
49097 PyObject *swig_obj[1] ;
49098
49099 if (!args) SWIG_fail;
49100 swig_obj[0] = args;
49101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49102 if (!SWIG_IsOK(res1)) {
49103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49104 }
49105 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49106 {
49107 PyThreadState* __tstate = wxPyBeginAllowThreads();
49108 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49109 wxPyEndAllowThreads(__tstate);
49110 if (PyErr_Occurred()) SWIG_fail;
49111 }
49112 {
49113 resultobj = wxPyMake_wxObject(result, (bool)0);
49114 }
49115 return resultobj;
49116 fail:
49117 return NULL;
49118 }
49119
49120
49121 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49122 PyObject *resultobj = 0;
49123 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49124 wxButton *result = 0 ;
49125 void *argp1 = 0 ;
49126 int res1 = 0 ;
49127 PyObject *swig_obj[1] ;
49128
49129 if (!args) SWIG_fail;
49130 swig_obj[0] = args;
49131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49132 if (!SWIG_IsOK(res1)) {
49133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49134 }
49135 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49136 {
49137 PyThreadState* __tstate = wxPyBeginAllowThreads();
49138 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49139 wxPyEndAllowThreads(__tstate);
49140 if (PyErr_Occurred()) SWIG_fail;
49141 }
49142 {
49143 resultobj = wxPyMake_wxObject(result, (bool)0);
49144 }
49145 return resultobj;
49146 fail:
49147 return NULL;
49148 }
49149
49150
49151 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49152 PyObject *resultobj = 0;
49153 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49154 wxButton *result = 0 ;
49155 void *argp1 = 0 ;
49156 int res1 = 0 ;
49157 PyObject *swig_obj[1] ;
49158
49159 if (!args) SWIG_fail;
49160 swig_obj[0] = args;
49161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49162 if (!SWIG_IsOK(res1)) {
49163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49164 }
49165 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49166 {
49167 PyThreadState* __tstate = wxPyBeginAllowThreads();
49168 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49169 wxPyEndAllowThreads(__tstate);
49170 if (PyErr_Occurred()) SWIG_fail;
49171 }
49172 {
49173 resultobj = wxPyMake_wxObject(result, (bool)0);
49174 }
49175 return resultobj;
49176 fail:
49177 return NULL;
49178 }
49179
49180
49181 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49182 PyObject *obj;
49183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49184 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49185 return SWIG_Py_Void();
49186 }
49187
49188 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49189 return SWIG_Python_InitShadowInstance(args);
49190 }
49191
49192 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49193 PyObject *resultobj = 0;
49194 int arg1 = (int) 0 ;
49195 int arg2 = (int) 0 ;
49196 wxGBPosition *result = 0 ;
49197 int val1 ;
49198 int ecode1 = 0 ;
49199 int val2 ;
49200 int ecode2 = 0 ;
49201 PyObject * obj0 = 0 ;
49202 PyObject * obj1 = 0 ;
49203 char * kwnames[] = {
49204 (char *) "row",(char *) "col", NULL
49205 };
49206
49207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49208 if (obj0) {
49209 ecode1 = SWIG_AsVal_int(obj0, &val1);
49210 if (!SWIG_IsOK(ecode1)) {
49211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49212 }
49213 arg1 = static_cast< int >(val1);
49214 }
49215 if (obj1) {
49216 ecode2 = SWIG_AsVal_int(obj1, &val2);
49217 if (!SWIG_IsOK(ecode2)) {
49218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49219 }
49220 arg2 = static_cast< int >(val2);
49221 }
49222 {
49223 PyThreadState* __tstate = wxPyBeginAllowThreads();
49224 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49225 wxPyEndAllowThreads(__tstate);
49226 if (PyErr_Occurred()) SWIG_fail;
49227 }
49228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49229 return resultobj;
49230 fail:
49231 return NULL;
49232 }
49233
49234
49235 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49236 PyObject *resultobj = 0;
49237 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49238 void *argp1 = 0 ;
49239 int res1 = 0 ;
49240 PyObject *swig_obj[1] ;
49241
49242 if (!args) SWIG_fail;
49243 swig_obj[0] = args;
49244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49245 if (!SWIG_IsOK(res1)) {
49246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49247 }
49248 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49249 {
49250 PyThreadState* __tstate = wxPyBeginAllowThreads();
49251 delete arg1;
49252
49253 wxPyEndAllowThreads(__tstate);
49254 if (PyErr_Occurred()) SWIG_fail;
49255 }
49256 resultobj = SWIG_Py_Void();
49257 return resultobj;
49258 fail:
49259 return NULL;
49260 }
49261
49262
49263 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49264 PyObject *resultobj = 0;
49265 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49266 int result;
49267 void *argp1 = 0 ;
49268 int res1 = 0 ;
49269 PyObject *swig_obj[1] ;
49270
49271 if (!args) SWIG_fail;
49272 swig_obj[0] = args;
49273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49274 if (!SWIG_IsOK(res1)) {
49275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49276 }
49277 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49278 {
49279 PyThreadState* __tstate = wxPyBeginAllowThreads();
49280 result = (int)((wxGBPosition const *)arg1)->GetRow();
49281 wxPyEndAllowThreads(__tstate);
49282 if (PyErr_Occurred()) SWIG_fail;
49283 }
49284 resultobj = SWIG_From_int(static_cast< int >(result));
49285 return resultobj;
49286 fail:
49287 return NULL;
49288 }
49289
49290
49291 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49292 PyObject *resultobj = 0;
49293 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49294 int result;
49295 void *argp1 = 0 ;
49296 int res1 = 0 ;
49297 PyObject *swig_obj[1] ;
49298
49299 if (!args) SWIG_fail;
49300 swig_obj[0] = args;
49301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49302 if (!SWIG_IsOK(res1)) {
49303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49304 }
49305 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49306 {
49307 PyThreadState* __tstate = wxPyBeginAllowThreads();
49308 result = (int)((wxGBPosition const *)arg1)->GetCol();
49309 wxPyEndAllowThreads(__tstate);
49310 if (PyErr_Occurred()) SWIG_fail;
49311 }
49312 resultobj = SWIG_From_int(static_cast< int >(result));
49313 return resultobj;
49314 fail:
49315 return NULL;
49316 }
49317
49318
49319 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49320 PyObject *resultobj = 0;
49321 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49322 int arg2 ;
49323 void *argp1 = 0 ;
49324 int res1 = 0 ;
49325 int val2 ;
49326 int ecode2 = 0 ;
49327 PyObject * obj0 = 0 ;
49328 PyObject * obj1 = 0 ;
49329 char * kwnames[] = {
49330 (char *) "self",(char *) "row", NULL
49331 };
49332
49333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49335 if (!SWIG_IsOK(res1)) {
49336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49337 }
49338 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49339 ecode2 = SWIG_AsVal_int(obj1, &val2);
49340 if (!SWIG_IsOK(ecode2)) {
49341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49342 }
49343 arg2 = static_cast< int >(val2);
49344 {
49345 PyThreadState* __tstate = wxPyBeginAllowThreads();
49346 (arg1)->SetRow(arg2);
49347 wxPyEndAllowThreads(__tstate);
49348 if (PyErr_Occurred()) SWIG_fail;
49349 }
49350 resultobj = SWIG_Py_Void();
49351 return resultobj;
49352 fail:
49353 return NULL;
49354 }
49355
49356
49357 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49358 PyObject *resultobj = 0;
49359 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49360 int arg2 ;
49361 void *argp1 = 0 ;
49362 int res1 = 0 ;
49363 int val2 ;
49364 int ecode2 = 0 ;
49365 PyObject * obj0 = 0 ;
49366 PyObject * obj1 = 0 ;
49367 char * kwnames[] = {
49368 (char *) "self",(char *) "col", NULL
49369 };
49370
49371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49373 if (!SWIG_IsOK(res1)) {
49374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49375 }
49376 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49377 ecode2 = SWIG_AsVal_int(obj1, &val2);
49378 if (!SWIG_IsOK(ecode2)) {
49379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49380 }
49381 arg2 = static_cast< int >(val2);
49382 {
49383 PyThreadState* __tstate = wxPyBeginAllowThreads();
49384 (arg1)->SetCol(arg2);
49385 wxPyEndAllowThreads(__tstate);
49386 if (PyErr_Occurred()) SWIG_fail;
49387 }
49388 resultobj = SWIG_Py_Void();
49389 return resultobj;
49390 fail:
49391 return NULL;
49392 }
49393
49394
49395 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49396 PyObject *resultobj = 0;
49397 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49398 PyObject *arg2 = (PyObject *) 0 ;
49399 bool result;
49400 void *argp1 = 0 ;
49401 int res1 = 0 ;
49402 PyObject * obj0 = 0 ;
49403 PyObject * obj1 = 0 ;
49404 char * kwnames[] = {
49405 (char *) "self",(char *) "other", NULL
49406 };
49407
49408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49410 if (!SWIG_IsOK(res1)) {
49411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49412 }
49413 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49414 arg2 = obj1;
49415 {
49416 result = (bool)wxGBPosition___eq__(arg1,arg2);
49417 if (PyErr_Occurred()) SWIG_fail;
49418 }
49419 {
49420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49421 }
49422 return resultobj;
49423 fail:
49424 return NULL;
49425 }
49426
49427
49428 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49429 PyObject *resultobj = 0;
49430 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49431 PyObject *arg2 = (PyObject *) 0 ;
49432 bool result;
49433 void *argp1 = 0 ;
49434 int res1 = 0 ;
49435 PyObject * obj0 = 0 ;
49436 PyObject * obj1 = 0 ;
49437 char * kwnames[] = {
49438 (char *) "self",(char *) "other", NULL
49439 };
49440
49441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49443 if (!SWIG_IsOK(res1)) {
49444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49445 }
49446 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49447 arg2 = obj1;
49448 {
49449 result = (bool)wxGBPosition___ne__(arg1,arg2);
49450 if (PyErr_Occurred()) SWIG_fail;
49451 }
49452 {
49453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49454 }
49455 return resultobj;
49456 fail:
49457 return NULL;
49458 }
49459
49460
49461 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49462 PyObject *resultobj = 0;
49463 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49464 int arg2 = (int) 0 ;
49465 int arg3 = (int) 0 ;
49466 void *argp1 = 0 ;
49467 int res1 = 0 ;
49468 int val2 ;
49469 int ecode2 = 0 ;
49470 int val3 ;
49471 int ecode3 = 0 ;
49472 PyObject * obj0 = 0 ;
49473 PyObject * obj1 = 0 ;
49474 PyObject * obj2 = 0 ;
49475 char * kwnames[] = {
49476 (char *) "self",(char *) "row",(char *) "col", NULL
49477 };
49478
49479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49481 if (!SWIG_IsOK(res1)) {
49482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49483 }
49484 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49485 if (obj1) {
49486 ecode2 = SWIG_AsVal_int(obj1, &val2);
49487 if (!SWIG_IsOK(ecode2)) {
49488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49489 }
49490 arg2 = static_cast< int >(val2);
49491 }
49492 if (obj2) {
49493 ecode3 = SWIG_AsVal_int(obj2, &val3);
49494 if (!SWIG_IsOK(ecode3)) {
49495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49496 }
49497 arg3 = static_cast< int >(val3);
49498 }
49499 {
49500 PyThreadState* __tstate = wxPyBeginAllowThreads();
49501 wxGBPosition_Set(arg1,arg2,arg3);
49502 wxPyEndAllowThreads(__tstate);
49503 if (PyErr_Occurred()) SWIG_fail;
49504 }
49505 resultobj = SWIG_Py_Void();
49506 return resultobj;
49507 fail:
49508 return NULL;
49509 }
49510
49511
49512 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49513 PyObject *resultobj = 0;
49514 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49515 PyObject *result = 0 ;
49516 void *argp1 = 0 ;
49517 int res1 = 0 ;
49518 PyObject *swig_obj[1] ;
49519
49520 if (!args) SWIG_fail;
49521 swig_obj[0] = args;
49522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49523 if (!SWIG_IsOK(res1)) {
49524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49525 }
49526 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49527 {
49528 PyThreadState* __tstate = wxPyBeginAllowThreads();
49529 result = (PyObject *)wxGBPosition_Get(arg1);
49530 wxPyEndAllowThreads(__tstate);
49531 if (PyErr_Occurred()) SWIG_fail;
49532 }
49533 resultobj = result;
49534 return resultobj;
49535 fail:
49536 return NULL;
49537 }
49538
49539
49540 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49541 PyObject *obj;
49542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49543 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49544 return SWIG_Py_Void();
49545 }
49546
49547 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49548 return SWIG_Python_InitShadowInstance(args);
49549 }
49550
49551 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49552 PyObject *resultobj = 0;
49553 int arg1 = (int) 1 ;
49554 int arg2 = (int) 1 ;
49555 wxGBSpan *result = 0 ;
49556 int val1 ;
49557 int ecode1 = 0 ;
49558 int val2 ;
49559 int ecode2 = 0 ;
49560 PyObject * obj0 = 0 ;
49561 PyObject * obj1 = 0 ;
49562 char * kwnames[] = {
49563 (char *) "rowspan",(char *) "colspan", NULL
49564 };
49565
49566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49567 if (obj0) {
49568 ecode1 = SWIG_AsVal_int(obj0, &val1);
49569 if (!SWIG_IsOK(ecode1)) {
49570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49571 }
49572 arg1 = static_cast< int >(val1);
49573 }
49574 if (obj1) {
49575 ecode2 = SWIG_AsVal_int(obj1, &val2);
49576 if (!SWIG_IsOK(ecode2)) {
49577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49578 }
49579 arg2 = static_cast< int >(val2);
49580 }
49581 {
49582 PyThreadState* __tstate = wxPyBeginAllowThreads();
49583 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49584 wxPyEndAllowThreads(__tstate);
49585 if (PyErr_Occurred()) SWIG_fail;
49586 }
49587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49588 return resultobj;
49589 fail:
49590 return NULL;
49591 }
49592
49593
49594 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49595 PyObject *resultobj = 0;
49596 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49597 void *argp1 = 0 ;
49598 int res1 = 0 ;
49599 PyObject *swig_obj[1] ;
49600
49601 if (!args) SWIG_fail;
49602 swig_obj[0] = args;
49603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49604 if (!SWIG_IsOK(res1)) {
49605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49606 }
49607 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49608 {
49609 PyThreadState* __tstate = wxPyBeginAllowThreads();
49610 delete arg1;
49611
49612 wxPyEndAllowThreads(__tstate);
49613 if (PyErr_Occurred()) SWIG_fail;
49614 }
49615 resultobj = SWIG_Py_Void();
49616 return resultobj;
49617 fail:
49618 return NULL;
49619 }
49620
49621
49622 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49623 PyObject *resultobj = 0;
49624 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49625 int result;
49626 void *argp1 = 0 ;
49627 int res1 = 0 ;
49628 PyObject *swig_obj[1] ;
49629
49630 if (!args) SWIG_fail;
49631 swig_obj[0] = args;
49632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49633 if (!SWIG_IsOK(res1)) {
49634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49635 }
49636 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49637 {
49638 PyThreadState* __tstate = wxPyBeginAllowThreads();
49639 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49640 wxPyEndAllowThreads(__tstate);
49641 if (PyErr_Occurred()) SWIG_fail;
49642 }
49643 resultobj = SWIG_From_int(static_cast< int >(result));
49644 return resultobj;
49645 fail:
49646 return NULL;
49647 }
49648
49649
49650 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49651 PyObject *resultobj = 0;
49652 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49653 int result;
49654 void *argp1 = 0 ;
49655 int res1 = 0 ;
49656 PyObject *swig_obj[1] ;
49657
49658 if (!args) SWIG_fail;
49659 swig_obj[0] = args;
49660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49661 if (!SWIG_IsOK(res1)) {
49662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49663 }
49664 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49665 {
49666 PyThreadState* __tstate = wxPyBeginAllowThreads();
49667 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49668 wxPyEndAllowThreads(__tstate);
49669 if (PyErr_Occurred()) SWIG_fail;
49670 }
49671 resultobj = SWIG_From_int(static_cast< int >(result));
49672 return resultobj;
49673 fail:
49674 return NULL;
49675 }
49676
49677
49678 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49679 PyObject *resultobj = 0;
49680 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49681 int arg2 ;
49682 void *argp1 = 0 ;
49683 int res1 = 0 ;
49684 int val2 ;
49685 int ecode2 = 0 ;
49686 PyObject * obj0 = 0 ;
49687 PyObject * obj1 = 0 ;
49688 char * kwnames[] = {
49689 (char *) "self",(char *) "rowspan", NULL
49690 };
49691
49692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49694 if (!SWIG_IsOK(res1)) {
49695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49696 }
49697 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49698 ecode2 = SWIG_AsVal_int(obj1, &val2);
49699 if (!SWIG_IsOK(ecode2)) {
49700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49701 }
49702 arg2 = static_cast< int >(val2);
49703 {
49704 PyThreadState* __tstate = wxPyBeginAllowThreads();
49705 (arg1)->SetRowspan(arg2);
49706 wxPyEndAllowThreads(__tstate);
49707 if (PyErr_Occurred()) SWIG_fail;
49708 }
49709 resultobj = SWIG_Py_Void();
49710 return resultobj;
49711 fail:
49712 return NULL;
49713 }
49714
49715
49716 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49717 PyObject *resultobj = 0;
49718 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49719 int arg2 ;
49720 void *argp1 = 0 ;
49721 int res1 = 0 ;
49722 int val2 ;
49723 int ecode2 = 0 ;
49724 PyObject * obj0 = 0 ;
49725 PyObject * obj1 = 0 ;
49726 char * kwnames[] = {
49727 (char *) "self",(char *) "colspan", NULL
49728 };
49729
49730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49732 if (!SWIG_IsOK(res1)) {
49733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49734 }
49735 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49736 ecode2 = SWIG_AsVal_int(obj1, &val2);
49737 if (!SWIG_IsOK(ecode2)) {
49738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49739 }
49740 arg2 = static_cast< int >(val2);
49741 {
49742 PyThreadState* __tstate = wxPyBeginAllowThreads();
49743 (arg1)->SetColspan(arg2);
49744 wxPyEndAllowThreads(__tstate);
49745 if (PyErr_Occurred()) SWIG_fail;
49746 }
49747 resultobj = SWIG_Py_Void();
49748 return resultobj;
49749 fail:
49750 return NULL;
49751 }
49752
49753
49754 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49755 PyObject *resultobj = 0;
49756 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49757 PyObject *arg2 = (PyObject *) 0 ;
49758 bool result;
49759 void *argp1 = 0 ;
49760 int res1 = 0 ;
49761 PyObject * obj0 = 0 ;
49762 PyObject * obj1 = 0 ;
49763 char * kwnames[] = {
49764 (char *) "self",(char *) "other", NULL
49765 };
49766
49767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49769 if (!SWIG_IsOK(res1)) {
49770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49771 }
49772 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49773 arg2 = obj1;
49774 {
49775 result = (bool)wxGBSpan___eq__(arg1,arg2);
49776 if (PyErr_Occurred()) SWIG_fail;
49777 }
49778 {
49779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49780 }
49781 return resultobj;
49782 fail:
49783 return NULL;
49784 }
49785
49786
49787 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49788 PyObject *resultobj = 0;
49789 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49790 PyObject *arg2 = (PyObject *) 0 ;
49791 bool result;
49792 void *argp1 = 0 ;
49793 int res1 = 0 ;
49794 PyObject * obj0 = 0 ;
49795 PyObject * obj1 = 0 ;
49796 char * kwnames[] = {
49797 (char *) "self",(char *) "other", NULL
49798 };
49799
49800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49802 if (!SWIG_IsOK(res1)) {
49803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49804 }
49805 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49806 arg2 = obj1;
49807 {
49808 result = (bool)wxGBSpan___ne__(arg1,arg2);
49809 if (PyErr_Occurred()) SWIG_fail;
49810 }
49811 {
49812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49813 }
49814 return resultobj;
49815 fail:
49816 return NULL;
49817 }
49818
49819
49820 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49821 PyObject *resultobj = 0;
49822 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49823 int arg2 = (int) 1 ;
49824 int arg3 = (int) 1 ;
49825 void *argp1 = 0 ;
49826 int res1 = 0 ;
49827 int val2 ;
49828 int ecode2 = 0 ;
49829 int val3 ;
49830 int ecode3 = 0 ;
49831 PyObject * obj0 = 0 ;
49832 PyObject * obj1 = 0 ;
49833 PyObject * obj2 = 0 ;
49834 char * kwnames[] = {
49835 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49836 };
49837
49838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49840 if (!SWIG_IsOK(res1)) {
49841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49842 }
49843 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49844 if (obj1) {
49845 ecode2 = SWIG_AsVal_int(obj1, &val2);
49846 if (!SWIG_IsOK(ecode2)) {
49847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49848 }
49849 arg2 = static_cast< int >(val2);
49850 }
49851 if (obj2) {
49852 ecode3 = SWIG_AsVal_int(obj2, &val3);
49853 if (!SWIG_IsOK(ecode3)) {
49854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49855 }
49856 arg3 = static_cast< int >(val3);
49857 }
49858 {
49859 PyThreadState* __tstate = wxPyBeginAllowThreads();
49860 wxGBSpan_Set(arg1,arg2,arg3);
49861 wxPyEndAllowThreads(__tstate);
49862 if (PyErr_Occurred()) SWIG_fail;
49863 }
49864 resultobj = SWIG_Py_Void();
49865 return resultobj;
49866 fail:
49867 return NULL;
49868 }
49869
49870
49871 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49872 PyObject *resultobj = 0;
49873 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49874 PyObject *result = 0 ;
49875 void *argp1 = 0 ;
49876 int res1 = 0 ;
49877 PyObject *swig_obj[1] ;
49878
49879 if (!args) SWIG_fail;
49880 swig_obj[0] = args;
49881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49882 if (!SWIG_IsOK(res1)) {
49883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49884 }
49885 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49886 {
49887 PyThreadState* __tstate = wxPyBeginAllowThreads();
49888 result = (PyObject *)wxGBSpan_Get(arg1);
49889 wxPyEndAllowThreads(__tstate);
49890 if (PyErr_Occurred()) SWIG_fail;
49891 }
49892 resultobj = result;
49893 return resultobj;
49894 fail:
49895 return NULL;
49896 }
49897
49898
49899 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49900 PyObject *obj;
49901 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49902 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49903 return SWIG_Py_Void();
49904 }
49905
49906 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49907 return SWIG_Python_InitShadowInstance(args);
49908 }
49909
49910 SWIGINTERN int DefaultSpan_set(PyObject *) {
49911 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49912 return 1;
49913 }
49914
49915
49916 SWIGINTERN PyObject *DefaultSpan_get(void) {
49917 PyObject *pyobj = 0;
49918
49919 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49920 return pyobj;
49921 }
49922
49923
49924 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49925 PyObject *resultobj = 0;
49926 wxGBSizerItem *result = 0 ;
49927
49928 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49929 {
49930 PyThreadState* __tstate = wxPyBeginAllowThreads();
49931 result = (wxGBSizerItem *)new wxGBSizerItem();
49932 wxPyEndAllowThreads(__tstate);
49933 if (PyErr_Occurred()) SWIG_fail;
49934 }
49935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49936 return resultobj;
49937 fail:
49938 return NULL;
49939 }
49940
49941
49942 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49943 PyObject *resultobj = 0;
49944 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49945 void *argp1 = 0 ;
49946 int res1 = 0 ;
49947 PyObject *swig_obj[1] ;
49948
49949 if (!args) SWIG_fail;
49950 swig_obj[0] = args;
49951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49952 if (!SWIG_IsOK(res1)) {
49953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49954 }
49955 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49956 {
49957 PyThreadState* __tstate = wxPyBeginAllowThreads();
49958 delete arg1;
49959
49960 wxPyEndAllowThreads(__tstate);
49961 if (PyErr_Occurred()) SWIG_fail;
49962 }
49963 resultobj = SWIG_Py_Void();
49964 return resultobj;
49965 fail:
49966 return NULL;
49967 }
49968
49969
49970 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49971 PyObject *resultobj = 0;
49972 wxWindow *arg1 = (wxWindow *) 0 ;
49973 wxGBPosition *arg2 = 0 ;
49974 wxGBSpan *arg3 = 0 ;
49975 int arg4 ;
49976 int arg5 ;
49977 PyObject *arg6 = (PyObject *) NULL ;
49978 wxGBSizerItem *result = 0 ;
49979 void *argp1 = 0 ;
49980 int res1 = 0 ;
49981 wxGBPosition temp2 ;
49982 wxGBSpan temp3 ;
49983 int val4 ;
49984 int ecode4 = 0 ;
49985 int val5 ;
49986 int ecode5 = 0 ;
49987 PyObject * obj0 = 0 ;
49988 PyObject * obj1 = 0 ;
49989 PyObject * obj2 = 0 ;
49990 PyObject * obj3 = 0 ;
49991 PyObject * obj4 = 0 ;
49992 PyObject * obj5 = 0 ;
49993 char * kwnames[] = {
49994 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49995 };
49996
49997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49999 if (!SWIG_IsOK(res1)) {
50000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50001 }
50002 arg1 = reinterpret_cast< wxWindow * >(argp1);
50003 {
50004 arg2 = &temp2;
50005 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50006 }
50007 {
50008 arg3 = &temp3;
50009 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50010 }
50011 ecode4 = SWIG_AsVal_int(obj3, &val4);
50012 if (!SWIG_IsOK(ecode4)) {
50013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50014 }
50015 arg4 = static_cast< int >(val4);
50016 ecode5 = SWIG_AsVal_int(obj4, &val5);
50017 if (!SWIG_IsOK(ecode5)) {
50018 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50019 }
50020 arg5 = static_cast< int >(val5);
50021 if (obj5) {
50022 arg6 = obj5;
50023 }
50024 {
50025 PyThreadState* __tstate = wxPyBeginAllowThreads();
50026 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50027 wxPyEndAllowThreads(__tstate);
50028 if (PyErr_Occurred()) SWIG_fail;
50029 }
50030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50031 return resultobj;
50032 fail:
50033 return NULL;
50034 }
50035
50036
50037 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50038 PyObject *resultobj = 0;
50039 wxSizer *arg1 = (wxSizer *) 0 ;
50040 wxGBPosition *arg2 = 0 ;
50041 wxGBSpan *arg3 = 0 ;
50042 int arg4 ;
50043 int arg5 ;
50044 PyObject *arg6 = (PyObject *) NULL ;
50045 wxGBSizerItem *result = 0 ;
50046 int res1 = 0 ;
50047 wxGBPosition temp2 ;
50048 wxGBSpan temp3 ;
50049 int val4 ;
50050 int ecode4 = 0 ;
50051 int val5 ;
50052 int ecode5 = 0 ;
50053 PyObject * obj0 = 0 ;
50054 PyObject * obj1 = 0 ;
50055 PyObject * obj2 = 0 ;
50056 PyObject * obj3 = 0 ;
50057 PyObject * obj4 = 0 ;
50058 PyObject * obj5 = 0 ;
50059 char * kwnames[] = {
50060 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50061 };
50062
50063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50064 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50065 if (!SWIG_IsOK(res1)) {
50066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50067 }
50068 {
50069 arg2 = &temp2;
50070 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50071 }
50072 {
50073 arg3 = &temp3;
50074 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50075 }
50076 ecode4 = SWIG_AsVal_int(obj3, &val4);
50077 if (!SWIG_IsOK(ecode4)) {
50078 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50079 }
50080 arg4 = static_cast< int >(val4);
50081 ecode5 = SWIG_AsVal_int(obj4, &val5);
50082 if (!SWIG_IsOK(ecode5)) {
50083 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50084 }
50085 arg5 = static_cast< int >(val5);
50086 if (obj5) {
50087 arg6 = obj5;
50088 }
50089 {
50090 PyThreadState* __tstate = wxPyBeginAllowThreads();
50091 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50092 wxPyEndAllowThreads(__tstate);
50093 if (PyErr_Occurred()) SWIG_fail;
50094 }
50095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50096 return resultobj;
50097 fail:
50098 return NULL;
50099 }
50100
50101
50102 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50103 PyObject *resultobj = 0;
50104 int arg1 ;
50105 int arg2 ;
50106 wxGBPosition *arg3 = 0 ;
50107 wxGBSpan *arg4 = 0 ;
50108 int arg5 ;
50109 int arg6 ;
50110 PyObject *arg7 = (PyObject *) NULL ;
50111 wxGBSizerItem *result = 0 ;
50112 int val1 ;
50113 int ecode1 = 0 ;
50114 int val2 ;
50115 int ecode2 = 0 ;
50116 wxGBPosition temp3 ;
50117 wxGBSpan temp4 ;
50118 int val5 ;
50119 int ecode5 = 0 ;
50120 int val6 ;
50121 int ecode6 = 0 ;
50122 PyObject * obj0 = 0 ;
50123 PyObject * obj1 = 0 ;
50124 PyObject * obj2 = 0 ;
50125 PyObject * obj3 = 0 ;
50126 PyObject * obj4 = 0 ;
50127 PyObject * obj5 = 0 ;
50128 PyObject * obj6 = 0 ;
50129 char * kwnames[] = {
50130 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50131 };
50132
50133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50134 ecode1 = SWIG_AsVal_int(obj0, &val1);
50135 if (!SWIG_IsOK(ecode1)) {
50136 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50137 }
50138 arg1 = static_cast< int >(val1);
50139 ecode2 = SWIG_AsVal_int(obj1, &val2);
50140 if (!SWIG_IsOK(ecode2)) {
50141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50142 }
50143 arg2 = static_cast< int >(val2);
50144 {
50145 arg3 = &temp3;
50146 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50147 }
50148 {
50149 arg4 = &temp4;
50150 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50151 }
50152 ecode5 = SWIG_AsVal_int(obj4, &val5);
50153 if (!SWIG_IsOK(ecode5)) {
50154 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50155 }
50156 arg5 = static_cast< int >(val5);
50157 ecode6 = SWIG_AsVal_int(obj5, &val6);
50158 if (!SWIG_IsOK(ecode6)) {
50159 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50160 }
50161 arg6 = static_cast< int >(val6);
50162 if (obj6) {
50163 arg7 = obj6;
50164 }
50165 {
50166 PyThreadState* __tstate = wxPyBeginAllowThreads();
50167 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50168 wxPyEndAllowThreads(__tstate);
50169 if (PyErr_Occurred()) SWIG_fail;
50170 }
50171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50172 return resultobj;
50173 fail:
50174 return NULL;
50175 }
50176
50177
50178 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50179 PyObject *resultobj = 0;
50180 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50181 wxGBPosition result;
50182 void *argp1 = 0 ;
50183 int res1 = 0 ;
50184 PyObject *swig_obj[1] ;
50185
50186 if (!args) SWIG_fail;
50187 swig_obj[0] = args;
50188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50189 if (!SWIG_IsOK(res1)) {
50190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50191 }
50192 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50193 {
50194 PyThreadState* __tstate = wxPyBeginAllowThreads();
50195 result = ((wxGBSizerItem const *)arg1)->GetPos();
50196 wxPyEndAllowThreads(__tstate);
50197 if (PyErr_Occurred()) SWIG_fail;
50198 }
50199 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50200 return resultobj;
50201 fail:
50202 return NULL;
50203 }
50204
50205
50206 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50207 PyObject *resultobj = 0;
50208 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50209 wxGBSpan result;
50210 void *argp1 = 0 ;
50211 int res1 = 0 ;
50212 PyObject *swig_obj[1] ;
50213
50214 if (!args) SWIG_fail;
50215 swig_obj[0] = args;
50216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50217 if (!SWIG_IsOK(res1)) {
50218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50219 }
50220 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50221 {
50222 PyThreadState* __tstate = wxPyBeginAllowThreads();
50223 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50224 wxPyEndAllowThreads(__tstate);
50225 if (PyErr_Occurred()) SWIG_fail;
50226 }
50227 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50228 return resultobj;
50229 fail:
50230 return NULL;
50231 }
50232
50233
50234 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50235 PyObject *resultobj = 0;
50236 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50237 wxGBPosition *arg2 = 0 ;
50238 bool result;
50239 void *argp1 = 0 ;
50240 int res1 = 0 ;
50241 wxGBPosition temp2 ;
50242 PyObject * obj0 = 0 ;
50243 PyObject * obj1 = 0 ;
50244 char * kwnames[] = {
50245 (char *) "self",(char *) "pos", NULL
50246 };
50247
50248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50250 if (!SWIG_IsOK(res1)) {
50251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50252 }
50253 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50254 {
50255 arg2 = &temp2;
50256 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50257 }
50258 {
50259 PyThreadState* __tstate = wxPyBeginAllowThreads();
50260 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50261 wxPyEndAllowThreads(__tstate);
50262 if (PyErr_Occurred()) SWIG_fail;
50263 }
50264 {
50265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50266 }
50267 return resultobj;
50268 fail:
50269 return NULL;
50270 }
50271
50272
50273 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50274 PyObject *resultobj = 0;
50275 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50276 wxGBSpan *arg2 = 0 ;
50277 bool result;
50278 void *argp1 = 0 ;
50279 int res1 = 0 ;
50280 wxGBSpan temp2 ;
50281 PyObject * obj0 = 0 ;
50282 PyObject * obj1 = 0 ;
50283 char * kwnames[] = {
50284 (char *) "self",(char *) "span", NULL
50285 };
50286
50287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50289 if (!SWIG_IsOK(res1)) {
50290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50291 }
50292 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50293 {
50294 arg2 = &temp2;
50295 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50296 }
50297 {
50298 PyThreadState* __tstate = wxPyBeginAllowThreads();
50299 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50300 wxPyEndAllowThreads(__tstate);
50301 if (PyErr_Occurred()) SWIG_fail;
50302 }
50303 {
50304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50305 }
50306 return resultobj;
50307 fail:
50308 return NULL;
50309 }
50310
50311
50312 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50313 PyObject *resultobj = 0;
50314 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50315 wxGBSizerItem *arg2 = 0 ;
50316 bool result;
50317 void *argp1 = 0 ;
50318 int res1 = 0 ;
50319 void *argp2 = 0 ;
50320 int res2 = 0 ;
50321 PyObject * obj0 = 0 ;
50322 PyObject * obj1 = 0 ;
50323 char * kwnames[] = {
50324 (char *) "self",(char *) "other", NULL
50325 };
50326
50327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50329 if (!SWIG_IsOK(res1)) {
50330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50331 }
50332 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50333 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50334 if (!SWIG_IsOK(res2)) {
50335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50336 }
50337 if (!argp2) {
50338 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50339 }
50340 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50341 {
50342 PyThreadState* __tstate = wxPyBeginAllowThreads();
50343 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50344 wxPyEndAllowThreads(__tstate);
50345 if (PyErr_Occurred()) SWIG_fail;
50346 }
50347 {
50348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50349 }
50350 return resultobj;
50351 fail:
50352 return NULL;
50353 }
50354
50355
50356 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50357 PyObject *resultobj = 0;
50358 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50359 wxGBPosition *arg2 = 0 ;
50360 wxGBSpan *arg3 = 0 ;
50361 bool result;
50362 void *argp1 = 0 ;
50363 int res1 = 0 ;
50364 wxGBPosition temp2 ;
50365 wxGBSpan temp3 ;
50366 PyObject * obj0 = 0 ;
50367 PyObject * obj1 = 0 ;
50368 PyObject * obj2 = 0 ;
50369 char * kwnames[] = {
50370 (char *) "self",(char *) "pos",(char *) "span", NULL
50371 };
50372
50373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50375 if (!SWIG_IsOK(res1)) {
50376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50377 }
50378 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50379 {
50380 arg2 = &temp2;
50381 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50382 }
50383 {
50384 arg3 = &temp3;
50385 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50386 }
50387 {
50388 PyThreadState* __tstate = wxPyBeginAllowThreads();
50389 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50390 wxPyEndAllowThreads(__tstate);
50391 if (PyErr_Occurred()) SWIG_fail;
50392 }
50393 {
50394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50395 }
50396 return resultobj;
50397 fail:
50398 return NULL;
50399 }
50400
50401
50402 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50403 PyObject *resultobj = 0;
50404 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50405 wxGBPosition result;
50406 void *argp1 = 0 ;
50407 int res1 = 0 ;
50408 PyObject *swig_obj[1] ;
50409
50410 if (!args) SWIG_fail;
50411 swig_obj[0] = args;
50412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50413 if (!SWIG_IsOK(res1)) {
50414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50415 }
50416 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50417 {
50418 PyThreadState* __tstate = wxPyBeginAllowThreads();
50419 result = wxGBSizerItem_GetEndPos(arg1);
50420 wxPyEndAllowThreads(__tstate);
50421 if (PyErr_Occurred()) SWIG_fail;
50422 }
50423 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50424 return resultobj;
50425 fail:
50426 return NULL;
50427 }
50428
50429
50430 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50431 PyObject *resultobj = 0;
50432 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50433 wxGridBagSizer *result = 0 ;
50434 void *argp1 = 0 ;
50435 int res1 = 0 ;
50436 PyObject *swig_obj[1] ;
50437
50438 if (!args) SWIG_fail;
50439 swig_obj[0] = args;
50440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50441 if (!SWIG_IsOK(res1)) {
50442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50443 }
50444 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50445 {
50446 PyThreadState* __tstate = wxPyBeginAllowThreads();
50447 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50448 wxPyEndAllowThreads(__tstate);
50449 if (PyErr_Occurred()) SWIG_fail;
50450 }
50451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50452 return resultobj;
50453 fail:
50454 return NULL;
50455 }
50456
50457
50458 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50459 PyObject *resultobj = 0;
50460 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50461 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50462 void *argp1 = 0 ;
50463 int res1 = 0 ;
50464 void *argp2 = 0 ;
50465 int res2 = 0 ;
50466 PyObject * obj0 = 0 ;
50467 PyObject * obj1 = 0 ;
50468 char * kwnames[] = {
50469 (char *) "self",(char *) "sizer", NULL
50470 };
50471
50472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50474 if (!SWIG_IsOK(res1)) {
50475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50476 }
50477 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50478 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50479 if (!SWIG_IsOK(res2)) {
50480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50481 }
50482 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50483 {
50484 PyThreadState* __tstate = wxPyBeginAllowThreads();
50485 (arg1)->SetGBSizer(arg2);
50486 wxPyEndAllowThreads(__tstate);
50487 if (PyErr_Occurred()) SWIG_fail;
50488 }
50489 resultobj = SWIG_Py_Void();
50490 return resultobj;
50491 fail:
50492 return NULL;
50493 }
50494
50495
50496 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50497 PyObject *obj;
50498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50499 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50500 return SWIG_Py_Void();
50501 }
50502
50503 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50504 return SWIG_Python_InitShadowInstance(args);
50505 }
50506
50507 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50508 PyObject *resultobj = 0;
50509 int arg1 = (int) 0 ;
50510 int arg2 = (int) 0 ;
50511 wxGridBagSizer *result = 0 ;
50512 int val1 ;
50513 int ecode1 = 0 ;
50514 int val2 ;
50515 int ecode2 = 0 ;
50516 PyObject * obj0 = 0 ;
50517 PyObject * obj1 = 0 ;
50518 char * kwnames[] = {
50519 (char *) "vgap",(char *) "hgap", NULL
50520 };
50521
50522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50523 if (obj0) {
50524 ecode1 = SWIG_AsVal_int(obj0, &val1);
50525 if (!SWIG_IsOK(ecode1)) {
50526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50527 }
50528 arg1 = static_cast< int >(val1);
50529 }
50530 if (obj1) {
50531 ecode2 = SWIG_AsVal_int(obj1, &val2);
50532 if (!SWIG_IsOK(ecode2)) {
50533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50534 }
50535 arg2 = static_cast< int >(val2);
50536 }
50537 {
50538 PyThreadState* __tstate = wxPyBeginAllowThreads();
50539 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50540 wxPyEndAllowThreads(__tstate);
50541 if (PyErr_Occurred()) SWIG_fail;
50542 }
50543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50544 return resultobj;
50545 fail:
50546 return NULL;
50547 }
50548
50549
50550 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50551 PyObject *resultobj = 0;
50552 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50553 PyObject *arg2 = (PyObject *) 0 ;
50554 wxGBPosition *arg3 = 0 ;
50555 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50556 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50557 int arg5 = (int) 0 ;
50558 int arg6 = (int) 0 ;
50559 PyObject *arg7 = (PyObject *) NULL ;
50560 wxGBSizerItem *result = 0 ;
50561 void *argp1 = 0 ;
50562 int res1 = 0 ;
50563 wxGBPosition temp3 ;
50564 wxGBSpan temp4 ;
50565 int val5 ;
50566 int ecode5 = 0 ;
50567 int val6 ;
50568 int ecode6 = 0 ;
50569 PyObject * obj0 = 0 ;
50570 PyObject * obj1 = 0 ;
50571 PyObject * obj2 = 0 ;
50572 PyObject * obj3 = 0 ;
50573 PyObject * obj4 = 0 ;
50574 PyObject * obj5 = 0 ;
50575 PyObject * obj6 = 0 ;
50576 char * kwnames[] = {
50577 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50578 };
50579
50580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50582 if (!SWIG_IsOK(res1)) {
50583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50584 }
50585 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50586 arg2 = obj1;
50587 {
50588 arg3 = &temp3;
50589 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50590 }
50591 if (obj3) {
50592 {
50593 arg4 = &temp4;
50594 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50595 }
50596 }
50597 if (obj4) {
50598 ecode5 = SWIG_AsVal_int(obj4, &val5);
50599 if (!SWIG_IsOK(ecode5)) {
50600 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50601 }
50602 arg5 = static_cast< int >(val5);
50603 }
50604 if (obj5) {
50605 ecode6 = SWIG_AsVal_int(obj5, &val6);
50606 if (!SWIG_IsOK(ecode6)) {
50607 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50608 }
50609 arg6 = static_cast< int >(val6);
50610 }
50611 if (obj6) {
50612 arg7 = obj6;
50613 }
50614 {
50615 PyThreadState* __tstate = wxPyBeginAllowThreads();
50616 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50617 wxPyEndAllowThreads(__tstate);
50618 if (PyErr_Occurred()) SWIG_fail;
50619 }
50620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50621 return resultobj;
50622 fail:
50623 return NULL;
50624 }
50625
50626
50627 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50628 PyObject *resultobj = 0;
50629 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50630 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50631 wxGBSizerItem *result = 0 ;
50632 void *argp1 = 0 ;
50633 int res1 = 0 ;
50634 int res2 = 0 ;
50635 PyObject * obj0 = 0 ;
50636 PyObject * obj1 = 0 ;
50637 char * kwnames[] = {
50638 (char *) "self",(char *) "item", NULL
50639 };
50640
50641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50643 if (!SWIG_IsOK(res1)) {
50644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50645 }
50646 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50647 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50648 if (!SWIG_IsOK(res2)) {
50649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50650 }
50651 {
50652 PyThreadState* __tstate = wxPyBeginAllowThreads();
50653 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50654 wxPyEndAllowThreads(__tstate);
50655 if (PyErr_Occurred()) SWIG_fail;
50656 }
50657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50658 return resultobj;
50659 fail:
50660 return NULL;
50661 }
50662
50663
50664 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50665 PyObject *resultobj = 0;
50666 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50667 int arg2 ;
50668 int arg3 ;
50669 wxSize result;
50670 void *argp1 = 0 ;
50671 int res1 = 0 ;
50672 int val2 ;
50673 int ecode2 = 0 ;
50674 int val3 ;
50675 int ecode3 = 0 ;
50676 PyObject * obj0 = 0 ;
50677 PyObject * obj1 = 0 ;
50678 PyObject * obj2 = 0 ;
50679 char * kwnames[] = {
50680 (char *) "self",(char *) "row",(char *) "col", NULL
50681 };
50682
50683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50685 if (!SWIG_IsOK(res1)) {
50686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50687 }
50688 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50689 ecode2 = SWIG_AsVal_int(obj1, &val2);
50690 if (!SWIG_IsOK(ecode2)) {
50691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50692 }
50693 arg2 = static_cast< int >(val2);
50694 ecode3 = SWIG_AsVal_int(obj2, &val3);
50695 if (!SWIG_IsOK(ecode3)) {
50696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50697 }
50698 arg3 = static_cast< int >(val3);
50699 {
50700 PyThreadState* __tstate = wxPyBeginAllowThreads();
50701 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50702 wxPyEndAllowThreads(__tstate);
50703 if (PyErr_Occurred()) SWIG_fail;
50704 }
50705 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50706 return resultobj;
50707 fail:
50708 return NULL;
50709 }
50710
50711
50712 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50713 PyObject *resultobj = 0;
50714 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50715 wxSize result;
50716 void *argp1 = 0 ;
50717 int res1 = 0 ;
50718 PyObject *swig_obj[1] ;
50719
50720 if (!args) SWIG_fail;
50721 swig_obj[0] = args;
50722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50723 if (!SWIG_IsOK(res1)) {
50724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50725 }
50726 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50727 {
50728 PyThreadState* __tstate = wxPyBeginAllowThreads();
50729 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50730 wxPyEndAllowThreads(__tstate);
50731 if (PyErr_Occurred()) SWIG_fail;
50732 }
50733 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50734 return resultobj;
50735 fail:
50736 return NULL;
50737 }
50738
50739
50740 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50741 PyObject *resultobj = 0;
50742 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50743 wxSize *arg2 = 0 ;
50744 void *argp1 = 0 ;
50745 int res1 = 0 ;
50746 wxSize temp2 ;
50747 PyObject * obj0 = 0 ;
50748 PyObject * obj1 = 0 ;
50749 char * kwnames[] = {
50750 (char *) "self",(char *) "sz", NULL
50751 };
50752
50753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50755 if (!SWIG_IsOK(res1)) {
50756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50757 }
50758 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50759 {
50760 arg2 = &temp2;
50761 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50762 }
50763 {
50764 PyThreadState* __tstate = wxPyBeginAllowThreads();
50765 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50766 wxPyEndAllowThreads(__tstate);
50767 if (PyErr_Occurred()) SWIG_fail;
50768 }
50769 resultobj = SWIG_Py_Void();
50770 return resultobj;
50771 fail:
50772 return NULL;
50773 }
50774
50775
50776 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50777 PyObject *resultobj = 0;
50778 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50779 wxWindow *arg2 = (wxWindow *) 0 ;
50780 wxGBPosition result;
50781 void *argp1 = 0 ;
50782 int res1 = 0 ;
50783 void *argp2 = 0 ;
50784 int res2 = 0 ;
50785
50786 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50788 if (!SWIG_IsOK(res1)) {
50789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50790 }
50791 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50792 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50793 if (!SWIG_IsOK(res2)) {
50794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50795 }
50796 arg2 = reinterpret_cast< wxWindow * >(argp2);
50797 {
50798 PyThreadState* __tstate = wxPyBeginAllowThreads();
50799 result = (arg1)->GetItemPosition(arg2);
50800 wxPyEndAllowThreads(__tstate);
50801 if (PyErr_Occurred()) SWIG_fail;
50802 }
50803 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50804 return resultobj;
50805 fail:
50806 return NULL;
50807 }
50808
50809
50810 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50811 PyObject *resultobj = 0;
50812 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50813 wxSizer *arg2 = (wxSizer *) 0 ;
50814 wxGBPosition result;
50815 void *argp1 = 0 ;
50816 int res1 = 0 ;
50817 void *argp2 = 0 ;
50818 int res2 = 0 ;
50819
50820 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50822 if (!SWIG_IsOK(res1)) {
50823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50824 }
50825 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50826 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50827 if (!SWIG_IsOK(res2)) {
50828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50829 }
50830 arg2 = reinterpret_cast< wxSizer * >(argp2);
50831 {
50832 PyThreadState* __tstate = wxPyBeginAllowThreads();
50833 result = (arg1)->GetItemPosition(arg2);
50834 wxPyEndAllowThreads(__tstate);
50835 if (PyErr_Occurred()) SWIG_fail;
50836 }
50837 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50838 return resultobj;
50839 fail:
50840 return NULL;
50841 }
50842
50843
50844 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50845 PyObject *resultobj = 0;
50846 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50847 size_t arg2 ;
50848 wxGBPosition result;
50849 void *argp1 = 0 ;
50850 int res1 = 0 ;
50851 size_t val2 ;
50852 int ecode2 = 0 ;
50853
50854 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50856 if (!SWIG_IsOK(res1)) {
50857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50858 }
50859 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50860 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50861 if (!SWIG_IsOK(ecode2)) {
50862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50863 }
50864 arg2 = static_cast< size_t >(val2);
50865 {
50866 PyThreadState* __tstate = wxPyBeginAllowThreads();
50867 result = (arg1)->GetItemPosition(arg2);
50868 wxPyEndAllowThreads(__tstate);
50869 if (PyErr_Occurred()) SWIG_fail;
50870 }
50871 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50872 return resultobj;
50873 fail:
50874 return NULL;
50875 }
50876
50877
50878 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50879 int argc;
50880 PyObject *argv[3];
50881
50882 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50883 --argc;
50884 if (argc == 2) {
50885 int _v = 0;
50886 {
50887 void *vptr = 0;
50888 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50889 _v = SWIG_CheckState(res);
50890 }
50891 if (!_v) goto check_1;
50892 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50893 }
50894 check_1:
50895
50896 if (argc == 2) {
50897 int _v = 0;
50898 {
50899 void *vptr = 0;
50900 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50901 _v = SWIG_CheckState(res);
50902 }
50903 if (!_v) goto check_2;
50904 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50905 }
50906 check_2:
50907
50908 if (argc == 2) {
50909 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50910 }
50911
50912 fail:
50913 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50914 return NULL;
50915 }
50916
50917
50918 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50919 PyObject *resultobj = 0;
50920 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50921 wxWindow *arg2 = (wxWindow *) 0 ;
50922 wxGBPosition *arg3 = 0 ;
50923 bool result;
50924 void *argp1 = 0 ;
50925 int res1 = 0 ;
50926 void *argp2 = 0 ;
50927 int res2 = 0 ;
50928 wxGBPosition temp3 ;
50929
50930 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50932 if (!SWIG_IsOK(res1)) {
50933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50934 }
50935 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50936 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50937 if (!SWIG_IsOK(res2)) {
50938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50939 }
50940 arg2 = reinterpret_cast< wxWindow * >(argp2);
50941 {
50942 arg3 = &temp3;
50943 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50944 }
50945 {
50946 PyThreadState* __tstate = wxPyBeginAllowThreads();
50947 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50948 wxPyEndAllowThreads(__tstate);
50949 if (PyErr_Occurred()) SWIG_fail;
50950 }
50951 {
50952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50953 }
50954 return resultobj;
50955 fail:
50956 return NULL;
50957 }
50958
50959
50960 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50961 PyObject *resultobj = 0;
50962 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50963 wxSizer *arg2 = (wxSizer *) 0 ;
50964 wxGBPosition *arg3 = 0 ;
50965 bool result;
50966 void *argp1 = 0 ;
50967 int res1 = 0 ;
50968 void *argp2 = 0 ;
50969 int res2 = 0 ;
50970 wxGBPosition temp3 ;
50971
50972 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50974 if (!SWIG_IsOK(res1)) {
50975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50976 }
50977 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50978 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50979 if (!SWIG_IsOK(res2)) {
50980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50981 }
50982 arg2 = reinterpret_cast< wxSizer * >(argp2);
50983 {
50984 arg3 = &temp3;
50985 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50986 }
50987 {
50988 PyThreadState* __tstate = wxPyBeginAllowThreads();
50989 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50990 wxPyEndAllowThreads(__tstate);
50991 if (PyErr_Occurred()) SWIG_fail;
50992 }
50993 {
50994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50995 }
50996 return resultobj;
50997 fail:
50998 return NULL;
50999 }
51000
51001
51002 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51003 PyObject *resultobj = 0;
51004 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51005 size_t arg2 ;
51006 wxGBPosition *arg3 = 0 ;
51007 bool result;
51008 void *argp1 = 0 ;
51009 int res1 = 0 ;
51010 size_t val2 ;
51011 int ecode2 = 0 ;
51012 wxGBPosition temp3 ;
51013
51014 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51016 if (!SWIG_IsOK(res1)) {
51017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51018 }
51019 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51020 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51021 if (!SWIG_IsOK(ecode2)) {
51022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51023 }
51024 arg2 = static_cast< size_t >(val2);
51025 {
51026 arg3 = &temp3;
51027 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51028 }
51029 {
51030 PyThreadState* __tstate = wxPyBeginAllowThreads();
51031 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51032 wxPyEndAllowThreads(__tstate);
51033 if (PyErr_Occurred()) SWIG_fail;
51034 }
51035 {
51036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51037 }
51038 return resultobj;
51039 fail:
51040 return NULL;
51041 }
51042
51043
51044 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51045 int argc;
51046 PyObject *argv[4];
51047
51048 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51049 --argc;
51050 if (argc == 3) {
51051 int _v = 0;
51052 {
51053 void *vptr = 0;
51054 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51055 _v = SWIG_CheckState(res);
51056 }
51057 if (!_v) goto check_1;
51058 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51059 }
51060 check_1:
51061
51062 if (argc == 3) {
51063 int _v = 0;
51064 {
51065 void *vptr = 0;
51066 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51067 _v = SWIG_CheckState(res);
51068 }
51069 if (!_v) goto check_2;
51070 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51071 }
51072 check_2:
51073
51074 if (argc == 3) {
51075 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51076 }
51077
51078 fail:
51079 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51080 return NULL;
51081 }
51082
51083
51084 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51085 PyObject *resultobj = 0;
51086 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51087 wxWindow *arg2 = (wxWindow *) 0 ;
51088 wxGBSpan result;
51089 void *argp1 = 0 ;
51090 int res1 = 0 ;
51091 void *argp2 = 0 ;
51092 int res2 = 0 ;
51093
51094 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51096 if (!SWIG_IsOK(res1)) {
51097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51098 }
51099 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51100 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51101 if (!SWIG_IsOK(res2)) {
51102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51103 }
51104 arg2 = reinterpret_cast< wxWindow * >(argp2);
51105 {
51106 PyThreadState* __tstate = wxPyBeginAllowThreads();
51107 result = (arg1)->GetItemSpan(arg2);
51108 wxPyEndAllowThreads(__tstate);
51109 if (PyErr_Occurred()) SWIG_fail;
51110 }
51111 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51112 return resultobj;
51113 fail:
51114 return NULL;
51115 }
51116
51117
51118 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51119 PyObject *resultobj = 0;
51120 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51121 wxSizer *arg2 = (wxSizer *) 0 ;
51122 wxGBSpan result;
51123 void *argp1 = 0 ;
51124 int res1 = 0 ;
51125 void *argp2 = 0 ;
51126 int res2 = 0 ;
51127
51128 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51130 if (!SWIG_IsOK(res1)) {
51131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51132 }
51133 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51134 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51135 if (!SWIG_IsOK(res2)) {
51136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51137 }
51138 arg2 = reinterpret_cast< wxSizer * >(argp2);
51139 {
51140 PyThreadState* __tstate = wxPyBeginAllowThreads();
51141 result = (arg1)->GetItemSpan(arg2);
51142 wxPyEndAllowThreads(__tstate);
51143 if (PyErr_Occurred()) SWIG_fail;
51144 }
51145 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51146 return resultobj;
51147 fail:
51148 return NULL;
51149 }
51150
51151
51152 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51153 PyObject *resultobj = 0;
51154 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51155 size_t arg2 ;
51156 wxGBSpan result;
51157 void *argp1 = 0 ;
51158 int res1 = 0 ;
51159 size_t val2 ;
51160 int ecode2 = 0 ;
51161
51162 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51164 if (!SWIG_IsOK(res1)) {
51165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51166 }
51167 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51168 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51169 if (!SWIG_IsOK(ecode2)) {
51170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51171 }
51172 arg2 = static_cast< size_t >(val2);
51173 {
51174 PyThreadState* __tstate = wxPyBeginAllowThreads();
51175 result = (arg1)->GetItemSpan(arg2);
51176 wxPyEndAllowThreads(__tstate);
51177 if (PyErr_Occurred()) SWIG_fail;
51178 }
51179 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51180 return resultobj;
51181 fail:
51182 return NULL;
51183 }
51184
51185
51186 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51187 int argc;
51188 PyObject *argv[3];
51189
51190 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51191 --argc;
51192 if (argc == 2) {
51193 int _v = 0;
51194 {
51195 void *vptr = 0;
51196 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51197 _v = SWIG_CheckState(res);
51198 }
51199 if (!_v) goto check_1;
51200 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51201 }
51202 check_1:
51203
51204 if (argc == 2) {
51205 int _v = 0;
51206 {
51207 void *vptr = 0;
51208 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51209 _v = SWIG_CheckState(res);
51210 }
51211 if (!_v) goto check_2;
51212 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51213 }
51214 check_2:
51215
51216 if (argc == 2) {
51217 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51218 }
51219
51220 fail:
51221 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51222 return NULL;
51223 }
51224
51225
51226 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51227 PyObject *resultobj = 0;
51228 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51229 wxWindow *arg2 = (wxWindow *) 0 ;
51230 wxGBSpan *arg3 = 0 ;
51231 bool result;
51232 void *argp1 = 0 ;
51233 int res1 = 0 ;
51234 void *argp2 = 0 ;
51235 int res2 = 0 ;
51236 wxGBSpan temp3 ;
51237
51238 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51240 if (!SWIG_IsOK(res1)) {
51241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51242 }
51243 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51244 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51245 if (!SWIG_IsOK(res2)) {
51246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51247 }
51248 arg2 = reinterpret_cast< wxWindow * >(argp2);
51249 {
51250 arg3 = &temp3;
51251 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51252 }
51253 {
51254 PyThreadState* __tstate = wxPyBeginAllowThreads();
51255 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51256 wxPyEndAllowThreads(__tstate);
51257 if (PyErr_Occurred()) SWIG_fail;
51258 }
51259 {
51260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51261 }
51262 return resultobj;
51263 fail:
51264 return NULL;
51265 }
51266
51267
51268 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51269 PyObject *resultobj = 0;
51270 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51271 wxSizer *arg2 = (wxSizer *) 0 ;
51272 wxGBSpan *arg3 = 0 ;
51273 bool result;
51274 void *argp1 = 0 ;
51275 int res1 = 0 ;
51276 void *argp2 = 0 ;
51277 int res2 = 0 ;
51278 wxGBSpan temp3 ;
51279
51280 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51282 if (!SWIG_IsOK(res1)) {
51283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51284 }
51285 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51286 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51287 if (!SWIG_IsOK(res2)) {
51288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51289 }
51290 arg2 = reinterpret_cast< wxSizer * >(argp2);
51291 {
51292 arg3 = &temp3;
51293 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51294 }
51295 {
51296 PyThreadState* __tstate = wxPyBeginAllowThreads();
51297 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51298 wxPyEndAllowThreads(__tstate);
51299 if (PyErr_Occurred()) SWIG_fail;
51300 }
51301 {
51302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51303 }
51304 return resultobj;
51305 fail:
51306 return NULL;
51307 }
51308
51309
51310 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51311 PyObject *resultobj = 0;
51312 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51313 size_t arg2 ;
51314 wxGBSpan *arg3 = 0 ;
51315 bool result;
51316 void *argp1 = 0 ;
51317 int res1 = 0 ;
51318 size_t val2 ;
51319 int ecode2 = 0 ;
51320 wxGBSpan temp3 ;
51321
51322 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51324 if (!SWIG_IsOK(res1)) {
51325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51326 }
51327 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51328 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51329 if (!SWIG_IsOK(ecode2)) {
51330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51331 }
51332 arg2 = static_cast< size_t >(val2);
51333 {
51334 arg3 = &temp3;
51335 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51336 }
51337 {
51338 PyThreadState* __tstate = wxPyBeginAllowThreads();
51339 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51340 wxPyEndAllowThreads(__tstate);
51341 if (PyErr_Occurred()) SWIG_fail;
51342 }
51343 {
51344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51345 }
51346 return resultobj;
51347 fail:
51348 return NULL;
51349 }
51350
51351
51352 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51353 int argc;
51354 PyObject *argv[4];
51355
51356 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51357 --argc;
51358 if (argc == 3) {
51359 int _v = 0;
51360 {
51361 void *vptr = 0;
51362 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51363 _v = SWIG_CheckState(res);
51364 }
51365 if (!_v) goto check_1;
51366 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51367 }
51368 check_1:
51369
51370 if (argc == 3) {
51371 int _v = 0;
51372 {
51373 void *vptr = 0;
51374 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51375 _v = SWIG_CheckState(res);
51376 }
51377 if (!_v) goto check_2;
51378 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51379 }
51380 check_2:
51381
51382 if (argc == 3) {
51383 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51384 }
51385
51386 fail:
51387 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51388 return NULL;
51389 }
51390
51391
51392 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51393 PyObject *resultobj = 0;
51394 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51395 wxWindow *arg2 = (wxWindow *) 0 ;
51396 wxGBSizerItem *result = 0 ;
51397 void *argp1 = 0 ;
51398 int res1 = 0 ;
51399 void *argp2 = 0 ;
51400 int res2 = 0 ;
51401
51402 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51404 if (!SWIG_IsOK(res1)) {
51405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51406 }
51407 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51408 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51409 if (!SWIG_IsOK(res2)) {
51410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51411 }
51412 arg2 = reinterpret_cast< wxWindow * >(argp2);
51413 {
51414 PyThreadState* __tstate = wxPyBeginAllowThreads();
51415 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51416 wxPyEndAllowThreads(__tstate);
51417 if (PyErr_Occurred()) SWIG_fail;
51418 }
51419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51420 return resultobj;
51421 fail:
51422 return NULL;
51423 }
51424
51425
51426 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51427 PyObject *resultobj = 0;
51428 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51429 wxSizer *arg2 = (wxSizer *) 0 ;
51430 wxGBSizerItem *result = 0 ;
51431 void *argp1 = 0 ;
51432 int res1 = 0 ;
51433 void *argp2 = 0 ;
51434 int res2 = 0 ;
51435
51436 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51438 if (!SWIG_IsOK(res1)) {
51439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51440 }
51441 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51442 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51443 if (!SWIG_IsOK(res2)) {
51444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51445 }
51446 arg2 = reinterpret_cast< wxSizer * >(argp2);
51447 {
51448 PyThreadState* __tstate = wxPyBeginAllowThreads();
51449 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51450 wxPyEndAllowThreads(__tstate);
51451 if (PyErr_Occurred()) SWIG_fail;
51452 }
51453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51454 return resultobj;
51455 fail:
51456 return NULL;
51457 }
51458
51459
51460 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51461 int argc;
51462 PyObject *argv[3];
51463
51464 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51465 --argc;
51466 if (argc == 2) {
51467 int _v = 0;
51468 {
51469 void *vptr = 0;
51470 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51471 _v = SWIG_CheckState(res);
51472 }
51473 if (!_v) goto check_1;
51474 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51475 }
51476 check_1:
51477
51478 if (argc == 2) {
51479 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51480 }
51481
51482 fail:
51483 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51484 return NULL;
51485 }
51486
51487
51488 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51489 PyObject *resultobj = 0;
51490 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51491 wxGBPosition *arg2 = 0 ;
51492 wxGBSizerItem *result = 0 ;
51493 void *argp1 = 0 ;
51494 int res1 = 0 ;
51495 wxGBPosition temp2 ;
51496 PyObject * obj0 = 0 ;
51497 PyObject * obj1 = 0 ;
51498 char * kwnames[] = {
51499 (char *) "self",(char *) "pos", NULL
51500 };
51501
51502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51504 if (!SWIG_IsOK(res1)) {
51505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51506 }
51507 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51508 {
51509 arg2 = &temp2;
51510 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51511 }
51512 {
51513 PyThreadState* __tstate = wxPyBeginAllowThreads();
51514 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51515 wxPyEndAllowThreads(__tstate);
51516 if (PyErr_Occurred()) SWIG_fail;
51517 }
51518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51519 return resultobj;
51520 fail:
51521 return NULL;
51522 }
51523
51524
51525 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51526 PyObject *resultobj = 0;
51527 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51528 wxPoint *arg2 = 0 ;
51529 wxGBSizerItem *result = 0 ;
51530 void *argp1 = 0 ;
51531 int res1 = 0 ;
51532 wxPoint temp2 ;
51533 PyObject * obj0 = 0 ;
51534 PyObject * obj1 = 0 ;
51535 char * kwnames[] = {
51536 (char *) "self",(char *) "pt", NULL
51537 };
51538
51539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51541 if (!SWIG_IsOK(res1)) {
51542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51543 }
51544 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51545 {
51546 arg2 = &temp2;
51547 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51548 }
51549 {
51550 PyThreadState* __tstate = wxPyBeginAllowThreads();
51551 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51552 wxPyEndAllowThreads(__tstate);
51553 if (PyErr_Occurred()) SWIG_fail;
51554 }
51555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51556 return resultobj;
51557 fail:
51558 return NULL;
51559 }
51560
51561
51562 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51563 PyObject *resultobj = 0;
51564 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51565 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51566 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51567 bool result;
51568 void *argp1 = 0 ;
51569 int res1 = 0 ;
51570 void *argp2 = 0 ;
51571 int res2 = 0 ;
51572 void *argp3 = 0 ;
51573 int res3 = 0 ;
51574 PyObject * obj0 = 0 ;
51575 PyObject * obj1 = 0 ;
51576 PyObject * obj2 = 0 ;
51577 char * kwnames[] = {
51578 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51579 };
51580
51581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51583 if (!SWIG_IsOK(res1)) {
51584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51585 }
51586 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51588 if (!SWIG_IsOK(res2)) {
51589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51590 }
51591 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51592 if (obj2) {
51593 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51594 if (!SWIG_IsOK(res3)) {
51595 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51596 }
51597 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51598 }
51599 {
51600 PyThreadState* __tstate = wxPyBeginAllowThreads();
51601 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51602 wxPyEndAllowThreads(__tstate);
51603 if (PyErr_Occurred()) SWIG_fail;
51604 }
51605 {
51606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51607 }
51608 return resultobj;
51609 fail:
51610 return NULL;
51611 }
51612
51613
51614 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51615 PyObject *resultobj = 0;
51616 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51617 wxGBPosition *arg2 = 0 ;
51618 wxGBSpan *arg3 = 0 ;
51619 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51620 bool result;
51621 void *argp1 = 0 ;
51622 int res1 = 0 ;
51623 wxGBPosition temp2 ;
51624 wxGBSpan temp3 ;
51625 void *argp4 = 0 ;
51626 int res4 = 0 ;
51627 PyObject * obj0 = 0 ;
51628 PyObject * obj1 = 0 ;
51629 PyObject * obj2 = 0 ;
51630 PyObject * obj3 = 0 ;
51631 char * kwnames[] = {
51632 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51633 };
51634
51635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51637 if (!SWIG_IsOK(res1)) {
51638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51639 }
51640 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51641 {
51642 arg2 = &temp2;
51643 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51644 }
51645 {
51646 arg3 = &temp3;
51647 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51648 }
51649 if (obj3) {
51650 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51651 if (!SWIG_IsOK(res4)) {
51652 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51653 }
51654 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51655 }
51656 {
51657 PyThreadState* __tstate = wxPyBeginAllowThreads();
51658 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51659 wxPyEndAllowThreads(__tstate);
51660 if (PyErr_Occurred()) SWIG_fail;
51661 }
51662 {
51663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51664 }
51665 return resultobj;
51666 fail:
51667 return NULL;
51668 }
51669
51670
51671 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51672 PyObject *obj;
51673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51674 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51675 return SWIG_Py_Void();
51676 }
51677
51678 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51679 return SWIG_Python_InitShadowInstance(args);
51680 }
51681
51682 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51683 PyObject *resultobj = 0;
51684 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51685 wxRelationship arg2 ;
51686 wxWindow *arg3 = (wxWindow *) 0 ;
51687 wxEdge arg4 ;
51688 int arg5 = (int) 0 ;
51689 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51690 void *argp1 = 0 ;
51691 int res1 = 0 ;
51692 int val2 ;
51693 int ecode2 = 0 ;
51694 void *argp3 = 0 ;
51695 int res3 = 0 ;
51696 int val4 ;
51697 int ecode4 = 0 ;
51698 int val5 ;
51699 int ecode5 = 0 ;
51700 int val6 ;
51701 int ecode6 = 0 ;
51702 PyObject * obj0 = 0 ;
51703 PyObject * obj1 = 0 ;
51704 PyObject * obj2 = 0 ;
51705 PyObject * obj3 = 0 ;
51706 PyObject * obj4 = 0 ;
51707 PyObject * obj5 = 0 ;
51708 char * kwnames[] = {
51709 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51710 };
51711
51712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51714 if (!SWIG_IsOK(res1)) {
51715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51716 }
51717 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51718 ecode2 = SWIG_AsVal_int(obj1, &val2);
51719 if (!SWIG_IsOK(ecode2)) {
51720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51721 }
51722 arg2 = static_cast< wxRelationship >(val2);
51723 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51724 if (!SWIG_IsOK(res3)) {
51725 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51726 }
51727 arg3 = reinterpret_cast< wxWindow * >(argp3);
51728 ecode4 = SWIG_AsVal_int(obj3, &val4);
51729 if (!SWIG_IsOK(ecode4)) {
51730 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51731 }
51732 arg4 = static_cast< wxEdge >(val4);
51733 if (obj4) {
51734 ecode5 = SWIG_AsVal_int(obj4, &val5);
51735 if (!SWIG_IsOK(ecode5)) {
51736 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51737 }
51738 arg5 = static_cast< int >(val5);
51739 }
51740 if (obj5) {
51741 ecode6 = SWIG_AsVal_int(obj5, &val6);
51742 if (!SWIG_IsOK(ecode6)) {
51743 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51744 }
51745 arg6 = static_cast< int >(val6);
51746 }
51747 {
51748 PyThreadState* __tstate = wxPyBeginAllowThreads();
51749 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51750 wxPyEndAllowThreads(__tstate);
51751 if (PyErr_Occurred()) SWIG_fail;
51752 }
51753 resultobj = SWIG_Py_Void();
51754 return resultobj;
51755 fail:
51756 return NULL;
51757 }
51758
51759
51760 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51761 PyObject *resultobj = 0;
51762 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51763 wxWindow *arg2 = (wxWindow *) 0 ;
51764 int arg3 = (int) 0 ;
51765 void *argp1 = 0 ;
51766 int res1 = 0 ;
51767 void *argp2 = 0 ;
51768 int res2 = 0 ;
51769 int val3 ;
51770 int ecode3 = 0 ;
51771 PyObject * obj0 = 0 ;
51772 PyObject * obj1 = 0 ;
51773 PyObject * obj2 = 0 ;
51774 char * kwnames[] = {
51775 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51776 };
51777
51778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51780 if (!SWIG_IsOK(res1)) {
51781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51782 }
51783 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51784 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51785 if (!SWIG_IsOK(res2)) {
51786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51787 }
51788 arg2 = reinterpret_cast< wxWindow * >(argp2);
51789 if (obj2) {
51790 ecode3 = SWIG_AsVal_int(obj2, &val3);
51791 if (!SWIG_IsOK(ecode3)) {
51792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51793 }
51794 arg3 = static_cast< int >(val3);
51795 }
51796 {
51797 PyThreadState* __tstate = wxPyBeginAllowThreads();
51798 (arg1)->LeftOf(arg2,arg3);
51799 wxPyEndAllowThreads(__tstate);
51800 if (PyErr_Occurred()) SWIG_fail;
51801 }
51802 resultobj = SWIG_Py_Void();
51803 return resultobj;
51804 fail:
51805 return NULL;
51806 }
51807
51808
51809 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51810 PyObject *resultobj = 0;
51811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51812 wxWindow *arg2 = (wxWindow *) 0 ;
51813 int arg3 = (int) 0 ;
51814 void *argp1 = 0 ;
51815 int res1 = 0 ;
51816 void *argp2 = 0 ;
51817 int res2 = 0 ;
51818 int val3 ;
51819 int ecode3 = 0 ;
51820 PyObject * obj0 = 0 ;
51821 PyObject * obj1 = 0 ;
51822 PyObject * obj2 = 0 ;
51823 char * kwnames[] = {
51824 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51825 };
51826
51827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51829 if (!SWIG_IsOK(res1)) {
51830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51831 }
51832 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51834 if (!SWIG_IsOK(res2)) {
51835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51836 }
51837 arg2 = reinterpret_cast< wxWindow * >(argp2);
51838 if (obj2) {
51839 ecode3 = SWIG_AsVal_int(obj2, &val3);
51840 if (!SWIG_IsOK(ecode3)) {
51841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51842 }
51843 arg3 = static_cast< int >(val3);
51844 }
51845 {
51846 PyThreadState* __tstate = wxPyBeginAllowThreads();
51847 (arg1)->RightOf(arg2,arg3);
51848 wxPyEndAllowThreads(__tstate);
51849 if (PyErr_Occurred()) SWIG_fail;
51850 }
51851 resultobj = SWIG_Py_Void();
51852 return resultobj;
51853 fail:
51854 return NULL;
51855 }
51856
51857
51858 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51859 PyObject *resultobj = 0;
51860 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51861 wxWindow *arg2 = (wxWindow *) 0 ;
51862 int arg3 = (int) 0 ;
51863 void *argp1 = 0 ;
51864 int res1 = 0 ;
51865 void *argp2 = 0 ;
51866 int res2 = 0 ;
51867 int val3 ;
51868 int ecode3 = 0 ;
51869 PyObject * obj0 = 0 ;
51870 PyObject * obj1 = 0 ;
51871 PyObject * obj2 = 0 ;
51872 char * kwnames[] = {
51873 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51874 };
51875
51876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51878 if (!SWIG_IsOK(res1)) {
51879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51880 }
51881 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51882 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51883 if (!SWIG_IsOK(res2)) {
51884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51885 }
51886 arg2 = reinterpret_cast< wxWindow * >(argp2);
51887 if (obj2) {
51888 ecode3 = SWIG_AsVal_int(obj2, &val3);
51889 if (!SWIG_IsOK(ecode3)) {
51890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51891 }
51892 arg3 = static_cast< int >(val3);
51893 }
51894 {
51895 PyThreadState* __tstate = wxPyBeginAllowThreads();
51896 (arg1)->Above(arg2,arg3);
51897 wxPyEndAllowThreads(__tstate);
51898 if (PyErr_Occurred()) SWIG_fail;
51899 }
51900 resultobj = SWIG_Py_Void();
51901 return resultobj;
51902 fail:
51903 return NULL;
51904 }
51905
51906
51907 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51908 PyObject *resultobj = 0;
51909 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51910 wxWindow *arg2 = (wxWindow *) 0 ;
51911 int arg3 = (int) 0 ;
51912 void *argp1 = 0 ;
51913 int res1 = 0 ;
51914 void *argp2 = 0 ;
51915 int res2 = 0 ;
51916 int val3 ;
51917 int ecode3 = 0 ;
51918 PyObject * obj0 = 0 ;
51919 PyObject * obj1 = 0 ;
51920 PyObject * obj2 = 0 ;
51921 char * kwnames[] = {
51922 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51923 };
51924
51925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51927 if (!SWIG_IsOK(res1)) {
51928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51929 }
51930 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51931 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51932 if (!SWIG_IsOK(res2)) {
51933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51934 }
51935 arg2 = reinterpret_cast< wxWindow * >(argp2);
51936 if (obj2) {
51937 ecode3 = SWIG_AsVal_int(obj2, &val3);
51938 if (!SWIG_IsOK(ecode3)) {
51939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51940 }
51941 arg3 = static_cast< int >(val3);
51942 }
51943 {
51944 PyThreadState* __tstate = wxPyBeginAllowThreads();
51945 (arg1)->Below(arg2,arg3);
51946 wxPyEndAllowThreads(__tstate);
51947 if (PyErr_Occurred()) SWIG_fail;
51948 }
51949 resultobj = SWIG_Py_Void();
51950 return resultobj;
51951 fail:
51952 return NULL;
51953 }
51954
51955
51956 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51957 PyObject *resultobj = 0;
51958 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51959 wxWindow *arg2 = (wxWindow *) 0 ;
51960 wxEdge arg3 ;
51961 int arg4 = (int) 0 ;
51962 void *argp1 = 0 ;
51963 int res1 = 0 ;
51964 void *argp2 = 0 ;
51965 int res2 = 0 ;
51966 int val3 ;
51967 int ecode3 = 0 ;
51968 int val4 ;
51969 int ecode4 = 0 ;
51970 PyObject * obj0 = 0 ;
51971 PyObject * obj1 = 0 ;
51972 PyObject * obj2 = 0 ;
51973 PyObject * obj3 = 0 ;
51974 char * kwnames[] = {
51975 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51976 };
51977
51978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51980 if (!SWIG_IsOK(res1)) {
51981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51982 }
51983 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51985 if (!SWIG_IsOK(res2)) {
51986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51987 }
51988 arg2 = reinterpret_cast< wxWindow * >(argp2);
51989 ecode3 = SWIG_AsVal_int(obj2, &val3);
51990 if (!SWIG_IsOK(ecode3)) {
51991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51992 }
51993 arg3 = static_cast< wxEdge >(val3);
51994 if (obj3) {
51995 ecode4 = SWIG_AsVal_int(obj3, &val4);
51996 if (!SWIG_IsOK(ecode4)) {
51997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51998 }
51999 arg4 = static_cast< int >(val4);
52000 }
52001 {
52002 PyThreadState* __tstate = wxPyBeginAllowThreads();
52003 (arg1)->SameAs(arg2,arg3,arg4);
52004 wxPyEndAllowThreads(__tstate);
52005 if (PyErr_Occurred()) SWIG_fail;
52006 }
52007 resultobj = SWIG_Py_Void();
52008 return resultobj;
52009 fail:
52010 return NULL;
52011 }
52012
52013
52014 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52015 PyObject *resultobj = 0;
52016 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52017 wxWindow *arg2 = (wxWindow *) 0 ;
52018 wxEdge arg3 ;
52019 int arg4 ;
52020 void *argp1 = 0 ;
52021 int res1 = 0 ;
52022 void *argp2 = 0 ;
52023 int res2 = 0 ;
52024 int val3 ;
52025 int ecode3 = 0 ;
52026 int val4 ;
52027 int ecode4 = 0 ;
52028 PyObject * obj0 = 0 ;
52029 PyObject * obj1 = 0 ;
52030 PyObject * obj2 = 0 ;
52031 PyObject * obj3 = 0 ;
52032 char * kwnames[] = {
52033 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52034 };
52035
52036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52038 if (!SWIG_IsOK(res1)) {
52039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52040 }
52041 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52043 if (!SWIG_IsOK(res2)) {
52044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52045 }
52046 arg2 = reinterpret_cast< wxWindow * >(argp2);
52047 ecode3 = SWIG_AsVal_int(obj2, &val3);
52048 if (!SWIG_IsOK(ecode3)) {
52049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52050 }
52051 arg3 = static_cast< wxEdge >(val3);
52052 ecode4 = SWIG_AsVal_int(obj3, &val4);
52053 if (!SWIG_IsOK(ecode4)) {
52054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52055 }
52056 arg4 = static_cast< int >(val4);
52057 {
52058 PyThreadState* __tstate = wxPyBeginAllowThreads();
52059 (arg1)->PercentOf(arg2,arg3,arg4);
52060 wxPyEndAllowThreads(__tstate);
52061 if (PyErr_Occurred()) SWIG_fail;
52062 }
52063 resultobj = SWIG_Py_Void();
52064 return resultobj;
52065 fail:
52066 return NULL;
52067 }
52068
52069
52070 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52071 PyObject *resultobj = 0;
52072 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52073 int arg2 ;
52074 void *argp1 = 0 ;
52075 int res1 = 0 ;
52076 int val2 ;
52077 int ecode2 = 0 ;
52078 PyObject * obj0 = 0 ;
52079 PyObject * obj1 = 0 ;
52080 char * kwnames[] = {
52081 (char *) "self",(char *) "val", NULL
52082 };
52083
52084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52086 if (!SWIG_IsOK(res1)) {
52087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52088 }
52089 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52090 ecode2 = SWIG_AsVal_int(obj1, &val2);
52091 if (!SWIG_IsOK(ecode2)) {
52092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52093 }
52094 arg2 = static_cast< int >(val2);
52095 {
52096 PyThreadState* __tstate = wxPyBeginAllowThreads();
52097 (arg1)->Absolute(arg2);
52098 wxPyEndAllowThreads(__tstate);
52099 if (PyErr_Occurred()) SWIG_fail;
52100 }
52101 resultobj = SWIG_Py_Void();
52102 return resultobj;
52103 fail:
52104 return NULL;
52105 }
52106
52107
52108 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52109 PyObject *resultobj = 0;
52110 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52111 void *argp1 = 0 ;
52112 int res1 = 0 ;
52113 PyObject *swig_obj[1] ;
52114
52115 if (!args) SWIG_fail;
52116 swig_obj[0] = args;
52117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52118 if (!SWIG_IsOK(res1)) {
52119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52120 }
52121 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52122 {
52123 PyThreadState* __tstate = wxPyBeginAllowThreads();
52124 (arg1)->Unconstrained();
52125 wxPyEndAllowThreads(__tstate);
52126 if (PyErr_Occurred()) SWIG_fail;
52127 }
52128 resultobj = SWIG_Py_Void();
52129 return resultobj;
52130 fail:
52131 return NULL;
52132 }
52133
52134
52135 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52136 PyObject *resultobj = 0;
52137 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52138 void *argp1 = 0 ;
52139 int res1 = 0 ;
52140 PyObject *swig_obj[1] ;
52141
52142 if (!args) SWIG_fail;
52143 swig_obj[0] = args;
52144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52145 if (!SWIG_IsOK(res1)) {
52146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52147 }
52148 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52149 {
52150 PyThreadState* __tstate = wxPyBeginAllowThreads();
52151 (arg1)->AsIs();
52152 wxPyEndAllowThreads(__tstate);
52153 if (PyErr_Occurred()) SWIG_fail;
52154 }
52155 resultobj = SWIG_Py_Void();
52156 return resultobj;
52157 fail:
52158 return NULL;
52159 }
52160
52161
52162 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52163 PyObject *resultobj = 0;
52164 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52165 wxWindow *result = 0 ;
52166 void *argp1 = 0 ;
52167 int res1 = 0 ;
52168 PyObject *swig_obj[1] ;
52169
52170 if (!args) SWIG_fail;
52171 swig_obj[0] = args;
52172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52173 if (!SWIG_IsOK(res1)) {
52174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52175 }
52176 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52177 {
52178 PyThreadState* __tstate = wxPyBeginAllowThreads();
52179 result = (wxWindow *)(arg1)->GetOtherWindow();
52180 wxPyEndAllowThreads(__tstate);
52181 if (PyErr_Occurred()) SWIG_fail;
52182 }
52183 {
52184 resultobj = wxPyMake_wxObject(result, 0);
52185 }
52186 return resultobj;
52187 fail:
52188 return NULL;
52189 }
52190
52191
52192 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52193 PyObject *resultobj = 0;
52194 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52195 wxEdge result;
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_wxIndividualLayoutConstraint, 0 | 0 );
52203 if (!SWIG_IsOK(res1)) {
52204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52205 }
52206 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52207 {
52208 PyThreadState* __tstate = wxPyBeginAllowThreads();
52209 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52210 wxPyEndAllowThreads(__tstate);
52211 if (PyErr_Occurred()) SWIG_fail;
52212 }
52213 resultobj = SWIG_From_int(static_cast< int >(result));
52214 return resultobj;
52215 fail:
52216 return NULL;
52217 }
52218
52219
52220 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52221 PyObject *resultobj = 0;
52222 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52223 wxEdge arg2 ;
52224 void *argp1 = 0 ;
52225 int res1 = 0 ;
52226 int val2 ;
52227 int ecode2 = 0 ;
52228 PyObject * obj0 = 0 ;
52229 PyObject * obj1 = 0 ;
52230 char * kwnames[] = {
52231 (char *) "self",(char *) "which", NULL
52232 };
52233
52234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52236 if (!SWIG_IsOK(res1)) {
52237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52238 }
52239 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52240 ecode2 = SWIG_AsVal_int(obj1, &val2);
52241 if (!SWIG_IsOK(ecode2)) {
52242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52243 }
52244 arg2 = static_cast< wxEdge >(val2);
52245 {
52246 PyThreadState* __tstate = wxPyBeginAllowThreads();
52247 (arg1)->SetEdge(arg2);
52248 wxPyEndAllowThreads(__tstate);
52249 if (PyErr_Occurred()) SWIG_fail;
52250 }
52251 resultobj = SWIG_Py_Void();
52252 return resultobj;
52253 fail:
52254 return NULL;
52255 }
52256
52257
52258 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52259 PyObject *resultobj = 0;
52260 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52261 int arg2 ;
52262 void *argp1 = 0 ;
52263 int res1 = 0 ;
52264 int val2 ;
52265 int ecode2 = 0 ;
52266 PyObject * obj0 = 0 ;
52267 PyObject * obj1 = 0 ;
52268 char * kwnames[] = {
52269 (char *) "self",(char *) "v", NULL
52270 };
52271
52272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52274 if (!SWIG_IsOK(res1)) {
52275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52276 }
52277 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52278 ecode2 = SWIG_AsVal_int(obj1, &val2);
52279 if (!SWIG_IsOK(ecode2)) {
52280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52281 }
52282 arg2 = static_cast< int >(val2);
52283 {
52284 PyThreadState* __tstate = wxPyBeginAllowThreads();
52285 (arg1)->SetValue(arg2);
52286 wxPyEndAllowThreads(__tstate);
52287 if (PyErr_Occurred()) SWIG_fail;
52288 }
52289 resultobj = SWIG_Py_Void();
52290 return resultobj;
52291 fail:
52292 return NULL;
52293 }
52294
52295
52296 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52297 PyObject *resultobj = 0;
52298 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52299 int result;
52300 void *argp1 = 0 ;
52301 int res1 = 0 ;
52302 PyObject *swig_obj[1] ;
52303
52304 if (!args) SWIG_fail;
52305 swig_obj[0] = args;
52306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52307 if (!SWIG_IsOK(res1)) {
52308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52309 }
52310 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52311 {
52312 PyThreadState* __tstate = wxPyBeginAllowThreads();
52313 result = (int)(arg1)->GetMargin();
52314 wxPyEndAllowThreads(__tstate);
52315 if (PyErr_Occurred()) SWIG_fail;
52316 }
52317 resultobj = SWIG_From_int(static_cast< int >(result));
52318 return resultobj;
52319 fail:
52320 return NULL;
52321 }
52322
52323
52324 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52325 PyObject *resultobj = 0;
52326 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52327 int arg2 ;
52328 void *argp1 = 0 ;
52329 int res1 = 0 ;
52330 int val2 ;
52331 int ecode2 = 0 ;
52332 PyObject * obj0 = 0 ;
52333 PyObject * obj1 = 0 ;
52334 char * kwnames[] = {
52335 (char *) "self",(char *) "m", NULL
52336 };
52337
52338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52340 if (!SWIG_IsOK(res1)) {
52341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52342 }
52343 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52344 ecode2 = SWIG_AsVal_int(obj1, &val2);
52345 if (!SWIG_IsOK(ecode2)) {
52346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52347 }
52348 arg2 = static_cast< int >(val2);
52349 {
52350 PyThreadState* __tstate = wxPyBeginAllowThreads();
52351 (arg1)->SetMargin(arg2);
52352 wxPyEndAllowThreads(__tstate);
52353 if (PyErr_Occurred()) SWIG_fail;
52354 }
52355 resultobj = SWIG_Py_Void();
52356 return resultobj;
52357 fail:
52358 return NULL;
52359 }
52360
52361
52362 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52363 PyObject *resultobj = 0;
52364 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52365 int result;
52366 void *argp1 = 0 ;
52367 int res1 = 0 ;
52368 PyObject *swig_obj[1] ;
52369
52370 if (!args) SWIG_fail;
52371 swig_obj[0] = args;
52372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52373 if (!SWIG_IsOK(res1)) {
52374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52375 }
52376 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52377 {
52378 PyThreadState* __tstate = wxPyBeginAllowThreads();
52379 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52380 wxPyEndAllowThreads(__tstate);
52381 if (PyErr_Occurred()) SWIG_fail;
52382 }
52383 resultobj = SWIG_From_int(static_cast< int >(result));
52384 return resultobj;
52385 fail:
52386 return NULL;
52387 }
52388
52389
52390 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52391 PyObject *resultobj = 0;
52392 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52393 int result;
52394 void *argp1 = 0 ;
52395 int res1 = 0 ;
52396 PyObject *swig_obj[1] ;
52397
52398 if (!args) SWIG_fail;
52399 swig_obj[0] = args;
52400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52401 if (!SWIG_IsOK(res1)) {
52402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52403 }
52404 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52405 {
52406 PyThreadState* __tstate = wxPyBeginAllowThreads();
52407 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52408 wxPyEndAllowThreads(__tstate);
52409 if (PyErr_Occurred()) SWIG_fail;
52410 }
52411 resultobj = SWIG_From_int(static_cast< int >(result));
52412 return resultobj;
52413 fail:
52414 return NULL;
52415 }
52416
52417
52418 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52419 PyObject *resultobj = 0;
52420 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52421 int result;
52422 void *argp1 = 0 ;
52423 int res1 = 0 ;
52424 PyObject *swig_obj[1] ;
52425
52426 if (!args) SWIG_fail;
52427 swig_obj[0] = args;
52428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52429 if (!SWIG_IsOK(res1)) {
52430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52431 }
52432 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52433 {
52434 PyThreadState* __tstate = wxPyBeginAllowThreads();
52435 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52436 wxPyEndAllowThreads(__tstate);
52437 if (PyErr_Occurred()) SWIG_fail;
52438 }
52439 resultobj = SWIG_From_int(static_cast< int >(result));
52440 return resultobj;
52441 fail:
52442 return NULL;
52443 }
52444
52445
52446 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52447 PyObject *resultobj = 0;
52448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52449 bool result;
52450 void *argp1 = 0 ;
52451 int res1 = 0 ;
52452 PyObject *swig_obj[1] ;
52453
52454 if (!args) SWIG_fail;
52455 swig_obj[0] = args;
52456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52457 if (!SWIG_IsOK(res1)) {
52458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52459 }
52460 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52461 {
52462 PyThreadState* __tstate = wxPyBeginAllowThreads();
52463 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52464 wxPyEndAllowThreads(__tstate);
52465 if (PyErr_Occurred()) SWIG_fail;
52466 }
52467 {
52468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52469 }
52470 return resultobj;
52471 fail:
52472 return NULL;
52473 }
52474
52475
52476 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52477 PyObject *resultobj = 0;
52478 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52479 bool arg2 ;
52480 void *argp1 = 0 ;
52481 int res1 = 0 ;
52482 bool val2 ;
52483 int ecode2 = 0 ;
52484 PyObject * obj0 = 0 ;
52485 PyObject * obj1 = 0 ;
52486 char * kwnames[] = {
52487 (char *) "self",(char *) "d", NULL
52488 };
52489
52490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52492 if (!SWIG_IsOK(res1)) {
52493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52494 }
52495 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52496 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52497 if (!SWIG_IsOK(ecode2)) {
52498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52499 }
52500 arg2 = static_cast< bool >(val2);
52501 {
52502 PyThreadState* __tstate = wxPyBeginAllowThreads();
52503 (arg1)->SetDone(arg2);
52504 wxPyEndAllowThreads(__tstate);
52505 if (PyErr_Occurred()) SWIG_fail;
52506 }
52507 resultobj = SWIG_Py_Void();
52508 return resultobj;
52509 fail:
52510 return NULL;
52511 }
52512
52513
52514 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52515 PyObject *resultobj = 0;
52516 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52517 wxRelationship result;
52518 void *argp1 = 0 ;
52519 int res1 = 0 ;
52520 PyObject *swig_obj[1] ;
52521
52522 if (!args) SWIG_fail;
52523 swig_obj[0] = args;
52524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52525 if (!SWIG_IsOK(res1)) {
52526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52527 }
52528 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52529 {
52530 PyThreadState* __tstate = wxPyBeginAllowThreads();
52531 result = (wxRelationship)(arg1)->GetRelationship();
52532 wxPyEndAllowThreads(__tstate);
52533 if (PyErr_Occurred()) SWIG_fail;
52534 }
52535 resultobj = SWIG_From_int(static_cast< int >(result));
52536 return resultobj;
52537 fail:
52538 return NULL;
52539 }
52540
52541
52542 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52543 PyObject *resultobj = 0;
52544 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52545 wxRelationship arg2 ;
52546 void *argp1 = 0 ;
52547 int res1 = 0 ;
52548 int val2 ;
52549 int ecode2 = 0 ;
52550 PyObject * obj0 = 0 ;
52551 PyObject * obj1 = 0 ;
52552 char * kwnames[] = {
52553 (char *) "self",(char *) "r", NULL
52554 };
52555
52556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52558 if (!SWIG_IsOK(res1)) {
52559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52560 }
52561 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52562 ecode2 = SWIG_AsVal_int(obj1, &val2);
52563 if (!SWIG_IsOK(ecode2)) {
52564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52565 }
52566 arg2 = static_cast< wxRelationship >(val2);
52567 {
52568 PyThreadState* __tstate = wxPyBeginAllowThreads();
52569 (arg1)->SetRelationship(arg2);
52570 wxPyEndAllowThreads(__tstate);
52571 if (PyErr_Occurred()) SWIG_fail;
52572 }
52573 resultobj = SWIG_Py_Void();
52574 return resultobj;
52575 fail:
52576 return NULL;
52577 }
52578
52579
52580 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52581 PyObject *resultobj = 0;
52582 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52583 wxWindow *arg2 = (wxWindow *) 0 ;
52584 bool result;
52585 void *argp1 = 0 ;
52586 int res1 = 0 ;
52587 void *argp2 = 0 ;
52588 int res2 = 0 ;
52589 PyObject * obj0 = 0 ;
52590 PyObject * obj1 = 0 ;
52591 char * kwnames[] = {
52592 (char *) "self",(char *) "otherW", NULL
52593 };
52594
52595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52597 if (!SWIG_IsOK(res1)) {
52598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52599 }
52600 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52601 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52602 if (!SWIG_IsOK(res2)) {
52603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52604 }
52605 arg2 = reinterpret_cast< wxWindow * >(argp2);
52606 {
52607 PyThreadState* __tstate = wxPyBeginAllowThreads();
52608 result = (bool)(arg1)->ResetIfWin(arg2);
52609 wxPyEndAllowThreads(__tstate);
52610 if (PyErr_Occurred()) SWIG_fail;
52611 }
52612 {
52613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52614 }
52615 return resultobj;
52616 fail:
52617 return NULL;
52618 }
52619
52620
52621 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52622 PyObject *resultobj = 0;
52623 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52624 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52625 wxWindow *arg3 = (wxWindow *) 0 ;
52626 bool result;
52627 void *argp1 = 0 ;
52628 int res1 = 0 ;
52629 void *argp2 = 0 ;
52630 int res2 = 0 ;
52631 void *argp3 = 0 ;
52632 int res3 = 0 ;
52633 PyObject * obj0 = 0 ;
52634 PyObject * obj1 = 0 ;
52635 PyObject * obj2 = 0 ;
52636 char * kwnames[] = {
52637 (char *) "self",(char *) "constraints",(char *) "win", NULL
52638 };
52639
52640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52642 if (!SWIG_IsOK(res1)) {
52643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52644 }
52645 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52646 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52647 if (!SWIG_IsOK(res2)) {
52648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52649 }
52650 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52651 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52652 if (!SWIG_IsOK(res3)) {
52653 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52654 }
52655 arg3 = reinterpret_cast< wxWindow * >(argp3);
52656 {
52657 PyThreadState* __tstate = wxPyBeginAllowThreads();
52658 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52659 wxPyEndAllowThreads(__tstate);
52660 if (PyErr_Occurred()) SWIG_fail;
52661 }
52662 {
52663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52664 }
52665 return resultobj;
52666 fail:
52667 return NULL;
52668 }
52669
52670
52671 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52672 PyObject *resultobj = 0;
52673 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52674 wxEdge arg2 ;
52675 wxWindow *arg3 = (wxWindow *) 0 ;
52676 wxWindow *arg4 = (wxWindow *) 0 ;
52677 int result;
52678 void *argp1 = 0 ;
52679 int res1 = 0 ;
52680 int val2 ;
52681 int ecode2 = 0 ;
52682 void *argp3 = 0 ;
52683 int res3 = 0 ;
52684 void *argp4 = 0 ;
52685 int res4 = 0 ;
52686 PyObject * obj0 = 0 ;
52687 PyObject * obj1 = 0 ;
52688 PyObject * obj2 = 0 ;
52689 PyObject * obj3 = 0 ;
52690 char * kwnames[] = {
52691 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52692 };
52693
52694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52696 if (!SWIG_IsOK(res1)) {
52697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52698 }
52699 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52700 ecode2 = SWIG_AsVal_int(obj1, &val2);
52701 if (!SWIG_IsOK(ecode2)) {
52702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52703 }
52704 arg2 = static_cast< wxEdge >(val2);
52705 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52706 if (!SWIG_IsOK(res3)) {
52707 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52708 }
52709 arg3 = reinterpret_cast< wxWindow * >(argp3);
52710 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52711 if (!SWIG_IsOK(res4)) {
52712 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52713 }
52714 arg4 = reinterpret_cast< wxWindow * >(argp4);
52715 {
52716 PyThreadState* __tstate = wxPyBeginAllowThreads();
52717 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52718 wxPyEndAllowThreads(__tstate);
52719 if (PyErr_Occurred()) SWIG_fail;
52720 }
52721 resultobj = SWIG_From_int(static_cast< int >(result));
52722 return resultobj;
52723 fail:
52724 return NULL;
52725 }
52726
52727
52728 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52729 PyObject *obj;
52730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52731 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52732 return SWIG_Py_Void();
52733 }
52734
52735 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52736 PyObject *resultobj = 0;
52737 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52738 wxIndividualLayoutConstraint *result = 0 ;
52739 void *argp1 = 0 ;
52740 int res1 = 0 ;
52741 PyObject *swig_obj[1] ;
52742
52743 if (!args) SWIG_fail;
52744 swig_obj[0] = args;
52745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52746 if (!SWIG_IsOK(res1)) {
52747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52748 }
52749 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52750 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52752 return resultobj;
52753 fail:
52754 return NULL;
52755 }
52756
52757
52758 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52759 PyObject *resultobj = 0;
52760 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52761 wxIndividualLayoutConstraint *result = 0 ;
52762 void *argp1 = 0 ;
52763 int res1 = 0 ;
52764 PyObject *swig_obj[1] ;
52765
52766 if (!args) SWIG_fail;
52767 swig_obj[0] = args;
52768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52769 if (!SWIG_IsOK(res1)) {
52770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52771 }
52772 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52773 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52775 return resultobj;
52776 fail:
52777 return NULL;
52778 }
52779
52780
52781 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52782 PyObject *resultobj = 0;
52783 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52784 wxIndividualLayoutConstraint *result = 0 ;
52785 void *argp1 = 0 ;
52786 int res1 = 0 ;
52787 PyObject *swig_obj[1] ;
52788
52789 if (!args) SWIG_fail;
52790 swig_obj[0] = args;
52791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52792 if (!SWIG_IsOK(res1)) {
52793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52794 }
52795 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52796 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52798 return resultobj;
52799 fail:
52800 return NULL;
52801 }
52802
52803
52804 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52805 PyObject *resultobj = 0;
52806 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52807 wxIndividualLayoutConstraint *result = 0 ;
52808 void *argp1 = 0 ;
52809 int res1 = 0 ;
52810 PyObject *swig_obj[1] ;
52811
52812 if (!args) SWIG_fail;
52813 swig_obj[0] = args;
52814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52815 if (!SWIG_IsOK(res1)) {
52816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52817 }
52818 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52819 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52821 return resultobj;
52822 fail:
52823 return NULL;
52824 }
52825
52826
52827 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52828 PyObject *resultobj = 0;
52829 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52830 wxIndividualLayoutConstraint *result = 0 ;
52831 void *argp1 = 0 ;
52832 int res1 = 0 ;
52833 PyObject *swig_obj[1] ;
52834
52835 if (!args) SWIG_fail;
52836 swig_obj[0] = args;
52837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52838 if (!SWIG_IsOK(res1)) {
52839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52840 }
52841 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52842 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52844 return resultobj;
52845 fail:
52846 return NULL;
52847 }
52848
52849
52850 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52851 PyObject *resultobj = 0;
52852 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52853 wxIndividualLayoutConstraint *result = 0 ;
52854 void *argp1 = 0 ;
52855 int res1 = 0 ;
52856 PyObject *swig_obj[1] ;
52857
52858 if (!args) SWIG_fail;
52859 swig_obj[0] = args;
52860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52861 if (!SWIG_IsOK(res1)) {
52862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52863 }
52864 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52865 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52867 return resultobj;
52868 fail:
52869 return NULL;
52870 }
52871
52872
52873 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52874 PyObject *resultobj = 0;
52875 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52876 wxIndividualLayoutConstraint *result = 0 ;
52877 void *argp1 = 0 ;
52878 int res1 = 0 ;
52879 PyObject *swig_obj[1] ;
52880
52881 if (!args) SWIG_fail;
52882 swig_obj[0] = args;
52883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52884 if (!SWIG_IsOK(res1)) {
52885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52886 }
52887 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52888 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52890 return resultobj;
52891 fail:
52892 return NULL;
52893 }
52894
52895
52896 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52897 PyObject *resultobj = 0;
52898 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52899 wxIndividualLayoutConstraint *result = 0 ;
52900 void *argp1 = 0 ;
52901 int res1 = 0 ;
52902 PyObject *swig_obj[1] ;
52903
52904 if (!args) SWIG_fail;
52905 swig_obj[0] = args;
52906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52907 if (!SWIG_IsOK(res1)) {
52908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52909 }
52910 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52911 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52913 return resultobj;
52914 fail:
52915 return NULL;
52916 }
52917
52918
52919 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52920 PyObject *resultobj = 0;
52921 wxLayoutConstraints *result = 0 ;
52922
52923 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52924 {
52925 PyThreadState* __tstate = wxPyBeginAllowThreads();
52926 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52927 wxPyEndAllowThreads(__tstate);
52928 if (PyErr_Occurred()) SWIG_fail;
52929 }
52930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52931 return resultobj;
52932 fail:
52933 return NULL;
52934 }
52935
52936
52937 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52938 PyObject *resultobj = 0;
52939 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52940 void *argp1 = 0 ;
52941 int res1 = 0 ;
52942 PyObject *swig_obj[1] ;
52943
52944 if (!args) SWIG_fail;
52945 swig_obj[0] = args;
52946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52947 if (!SWIG_IsOK(res1)) {
52948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52949 }
52950 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52951 {
52952 PyThreadState* __tstate = wxPyBeginAllowThreads();
52953 delete arg1;
52954
52955 wxPyEndAllowThreads(__tstate);
52956 if (PyErr_Occurred()) SWIG_fail;
52957 }
52958 resultobj = SWIG_Py_Void();
52959 return resultobj;
52960 fail:
52961 return NULL;
52962 }
52963
52964
52965 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52966 PyObject *resultobj = 0;
52967 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52968 wxWindow *arg2 = (wxWindow *) 0 ;
52969 int *arg3 = (int *) 0 ;
52970 bool result;
52971 void *argp1 = 0 ;
52972 int res1 = 0 ;
52973 void *argp2 = 0 ;
52974 int res2 = 0 ;
52975 int temp3 ;
52976 int res3 = SWIG_TMPOBJ ;
52977 PyObject * obj0 = 0 ;
52978 PyObject * obj1 = 0 ;
52979 char * kwnames[] = {
52980 (char *) "self",(char *) "win", NULL
52981 };
52982
52983 arg3 = &temp3;
52984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52986 if (!SWIG_IsOK(res1)) {
52987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52988 }
52989 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52990 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52991 if (!SWIG_IsOK(res2)) {
52992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52993 }
52994 arg2 = reinterpret_cast< wxWindow * >(argp2);
52995 {
52996 PyThreadState* __tstate = wxPyBeginAllowThreads();
52997 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52998 wxPyEndAllowThreads(__tstate);
52999 if (PyErr_Occurred()) SWIG_fail;
53000 }
53001 {
53002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53003 }
53004 if (SWIG_IsTmpObj(res3)) {
53005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53006 } else {
53007 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53009 }
53010 return resultobj;
53011 fail:
53012 return NULL;
53013 }
53014
53015
53016 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53017 PyObject *resultobj = 0;
53018 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53019 bool result;
53020 void *argp1 = 0 ;
53021 int res1 = 0 ;
53022 PyObject *swig_obj[1] ;
53023
53024 if (!args) SWIG_fail;
53025 swig_obj[0] = args;
53026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53027 if (!SWIG_IsOK(res1)) {
53028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53029 }
53030 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53031 {
53032 PyThreadState* __tstate = wxPyBeginAllowThreads();
53033 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53034 wxPyEndAllowThreads(__tstate);
53035 if (PyErr_Occurred()) SWIG_fail;
53036 }
53037 {
53038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53039 }
53040 return resultobj;
53041 fail:
53042 return NULL;
53043 }
53044
53045
53046 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53047 PyObject *obj;
53048 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53049 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53050 return SWIG_Py_Void();
53051 }
53052
53053 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53054 return SWIG_Python_InitShadowInstance(args);
53055 }
53056
53057 static PyMethodDef SwigMethods[] = {
53058 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53059 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53060 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53061 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53062 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53063 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53064 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53065 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53066 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53068 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53079 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53080 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53081 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53083 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53084 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53085 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53086 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53087 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53088 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53089 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53091 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53097 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53098 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53099 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53100 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53101 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53102 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53103 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53105 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53113 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53114 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53115 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53120 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53121 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53123 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53125 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53127 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53129 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53131 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53133 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53134 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53136 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53138 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53139 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53140 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53141 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53161 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53162 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53163 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53164 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53165 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53166 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53167 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53168 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53170 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53171 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53172 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53177 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53178 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53179 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53180 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53186 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53187 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53194 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53195 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53196 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53197 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53199 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53200 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53201 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53203 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53204 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53205 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53206 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53211 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53212 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53213 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53214 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53215 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53216 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53219 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53220 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53221 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53223 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53224 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53226 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53227 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53228 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53229 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53230 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53231 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53232 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53233 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53234 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53235 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53236 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53241 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53247 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53248 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53249 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53250 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53252 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53255 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53257 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53260 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53261 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53262 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53265 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53266 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53267 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53271 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53272 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53273 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53277 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53282 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53283 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53284 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53285 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53286 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53287 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53288 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53295 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53296 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53298 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53299 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53300 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53306 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53307 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53309 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53310 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53311 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53312 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53313 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53314 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53315 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53316 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53318 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53319 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53320 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53321 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53322 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53323 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53324 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53325 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53327 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53336 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53348 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53349 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53364 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53365 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53366 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53367 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53370 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53372 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53374 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53376 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53378 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53381 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53382 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53383 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53384 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53386 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53403 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53404 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53410 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53411 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53413 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53414 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53415 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53416 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53417 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53418 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53419 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53420 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53421 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53422 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53423 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53424 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53425 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53426 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53427 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53428 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53429 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53430 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53431 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53432 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53433 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53434 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53435 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53436 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53437 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53438 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53439 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53440 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53441 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53442 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53443 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53444 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53445 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53447 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53448 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53449 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53450 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53453 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53457 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53461 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53462 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53463 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53464 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53466 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53467 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53469 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53471 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53473 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53475 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53476 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53477 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53479 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53480 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53482 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53483 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53484 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53486 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53487 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53488 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53490 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53492 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53493 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53494 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53496 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53498 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53499 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53501 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53502 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53503 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53505 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53506 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53507 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53508 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53509 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53511 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53512 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53515 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53516 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53518 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53519 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53522 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53523 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53525 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53531 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53532 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53533 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53534 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53535 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53536 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53537 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53538 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53539 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53540 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53541 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53542 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53543 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53544 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53545 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53546 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53547 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53548 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53549 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53550 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53551 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53552 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53553 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53554 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53556 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53557 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53558 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53559 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53560 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53561 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53562 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53563 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53564 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53565 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53566 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53567 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53568 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53569 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53570 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53571 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53572 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53573 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53574 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53575 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53576 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53577 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53578 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53579 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53580 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53581 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53582 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53583 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53584 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53585 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53586 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53587 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53589 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53590 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53592 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53593 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53594 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53595 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53597 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53598 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53599 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53600 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53601 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53602 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53603 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53604 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53605 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53607 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53608 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53609 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53610 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53611 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53612 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53613 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53614 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53615 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53616 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53617 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53618 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53619 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53620 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53621 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53622 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53623 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53624 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53625 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53626 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53627 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53628 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53629 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53630 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53631 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53632 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53633 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53634 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53636 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53637 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53640 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53641 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53642 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53643 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53644 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53645 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53647 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53648 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53651 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53652 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53654 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53655 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53657 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53658 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53660 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53661 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53662 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53664 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53666 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53667 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53669 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53670 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53671 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53673 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53674 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53675 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53677 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53678 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53680 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53681 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53682 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53683 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53684 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53687 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53689 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53691 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53692 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53693 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53696 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53697 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53698 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53700 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53701 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53702 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53704 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53705 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53706 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53707 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53708 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53709 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53711 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53712 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53713 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53714 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53715 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53716 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53717 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53718 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53724 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53726 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53728 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53729 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53730 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53731 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53732 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53733 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53735 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53736 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53737 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53739 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53740 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53741 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53742 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53743 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53746 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53747 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53748 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53751 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53752 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53753 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53754 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53755 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53757 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53759 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53762 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53764 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53765 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53767 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53768 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53769 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53771 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53772 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53773 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53775 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53777 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53778 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53779 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53781 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53783 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53785 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53786 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53788 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53789 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53791 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53793 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53794 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53795 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53797 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53799 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53800 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53801 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53803 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53805 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53806 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53807 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53808 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53810 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53812 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53814 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53816 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53817 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53819 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53820 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53821 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53822 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53823 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53824 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53825 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53826 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53828 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53830 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53832 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53834 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53836 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53838 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53839 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53840 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53841 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53842 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53843 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53849 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53850 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
53851 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53852 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53853 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53854 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53855 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53856 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53858 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53860 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53861 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53863 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53864 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53865 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53866 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53868 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53869 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53870 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53871 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53873 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53874 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53876 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53877 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53878 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53880 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53882 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53883 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53884 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53885 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53886 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53888 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53889 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53890 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53891 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53893 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53894 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53895 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53896 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53897 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53898 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53899 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53900 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53901 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53902 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53904 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53907 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53908 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53909 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53911 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53913 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53915 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53917 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53918 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53928 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53929 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53933 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53934 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53935 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53936 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53937 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53938 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53939 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53940 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53941 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53942 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53943 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53944 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53945 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53946 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53947 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53949 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53950 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53953 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53954 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53959 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53960 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53963 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53964 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53965 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53966 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53969 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53970 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53971 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53973 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53975 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53976 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53977 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53979 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53981 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53983 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53986 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53987 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53988 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53989 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53990 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53991 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53995 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53996 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53997 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53998 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54005 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54011 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54012 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54013 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54014 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54015 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54017 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54027 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54028 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54029 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54030 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54033 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54034 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54035 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54036 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54038 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54039 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54043 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54049 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54050 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54051 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54052 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54054 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54055 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54057 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54060 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54062 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54063 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54064 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54073 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54077 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54078 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54080 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54090 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54091 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54092 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54093 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54097 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54100 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54102 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54105 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54107 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54108 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54111 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54113 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54114 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54115 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54116 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54118 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54119 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54124 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54125 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54126 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54128 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54129 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54130 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54132 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54134 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54135 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54136 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54138 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54139 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54142 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54150 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54151 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54157 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54165 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54168 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54169 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54182 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54184 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54186 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54187 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54189 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54191 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54192 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54194 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54195 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54196 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54200 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54219 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54220 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54222 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54223 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54225 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54226 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54227 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54228 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54229 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54230 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54233 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54234 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54236 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54237 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54239 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54242 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54243 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54245 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54246 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54247 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54249 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54250 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54252 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54253 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54256 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54258 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54260 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54261 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54262 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54263 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54264 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54265 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54267 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54268 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54269 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54271 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54272 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54273 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54275 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54276 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54277 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54278 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54280 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54282 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54283 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54284 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54287 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54288 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54291 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54292 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54293 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54294 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54295 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54298 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54300 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54302 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54303 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54304 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54305 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54309 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54310 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54311 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54312 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54314 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54315 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54316 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54319 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54320 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54321 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54322 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54323 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54324 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54325 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54326 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54328 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54330 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54331 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54333 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54335 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54338 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54339 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54340 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54342 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54343 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54344 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54351 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54358 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54359 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54360 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54361 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54362 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54363 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54369 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54370 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54374 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54375 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54377 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54378 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54380 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54382 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54383 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54385 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54386 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54387 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54393 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54394 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54395 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54396 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54397 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54398 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54405 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54407 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54408 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54409 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54410 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54411 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54412 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54414 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54418 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54419 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54420 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54421 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54422 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54423 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54424 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54426 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54427 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54428 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54434 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54435 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54436 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54437 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54438 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54439 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54440 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54446 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54447 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54448 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54449 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54450 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54454 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54455 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54460 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54461 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54463 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54464 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54469 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54471 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54472 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54473 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54474 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54475 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54480 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54481 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54490 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54491 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54492 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54493 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54496 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54498 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54499 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54500 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54501 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54503 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54504 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54508 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54509 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54510 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54511 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54512 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54513 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54514 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54515 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54516 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54517 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54518 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54519 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54520 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54521 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54522 { NULL, NULL, 0, NULL }
54523 };
54524
54525
54526 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54527
54528 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54529 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54530 }
54531 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54532 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54533 }
54534 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54535 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54536 }
54537 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54538 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54539 }
54540 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54541 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54542 }
54543 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54544 return (void *)((wxSizer *) ((wxGridSizer *) x));
54545 }
54546 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54547 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54548 }
54549 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54550 return (void *)((wxSizer *) ((wxPySizer *) x));
54551 }
54552 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54553 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54554 }
54555 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54556 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54557 }
54558 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54559 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54560 }
54561 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54562 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54563 }
54564 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54565 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54566 }
54567 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54568 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54569 }
54570 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54571 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54572 }
54573 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54574 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54575 }
54576 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54577 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54578 }
54579 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54580 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54581 }
54582 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54583 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54584 }
54585 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54586 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54587 }
54588 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54589 return (void *)((wxEvent *) ((wxPyEvent *) x));
54590 }
54591 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54592 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54593 }
54594 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54595 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54596 }
54597 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54598 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54599 }
54600 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54601 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54602 }
54603 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54604 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54605 }
54606 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54607 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54608 }
54609 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54610 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54611 }
54612 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54613 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54614 }
54615 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54616 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54617 }
54618 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54619 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54620 }
54621 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54622 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54623 }
54624 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54625 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54626 }
54627 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54628 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54629 }
54630 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54631 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54632 }
54633 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54634 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54635 }
54636 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54637 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54638 }
54639 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54640 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54641 }
54642 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54643 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54644 }
54645 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54646 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54647 }
54648 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54649 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54650 }
54651 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54652 return (void *)((wxEvent *) ((wxShowEvent *) x));
54653 }
54654 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54655 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54656 }
54657 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54658 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54659 }
54660 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54661 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54662 }
54663 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54664 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54665 }
54666 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54667 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54668 }
54669 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54670 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54671 }
54672 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54673 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54674 }
54675 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54676 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54677 }
54678 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54679 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54680 }
54681 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54682 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54683 }
54684 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54685 return (void *)((wxControl *) ((wxControlWithItems *) x));
54686 }
54687 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54688 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54689 }
54690 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54691 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54692 }
54693 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54694 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54695 }
54696 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54697 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54698 }
54699 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54700 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54701 }
54702 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54703 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54704 }
54705 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54706 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54707 }
54708 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54709 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54710 }
54711 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54712 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54713 }
54714 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54715 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54716 }
54717 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54718 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54719 }
54720 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54721 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54722 }
54723 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54724 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54725 }
54726 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54727 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54728 }
54729 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54730 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54731 }
54732 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54733 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54734 }
54735 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54736 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54737 }
54738 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54739 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54740 }
54741 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54742 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54743 }
54744 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54745 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54746 }
54747 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54748 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54749 }
54750 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54751 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54752 }
54753 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54754 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54755 }
54756 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54757 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54758 }
54759 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54760 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54761 }
54762 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54763 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54764 }
54765 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54766 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54767 }
54768 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54769 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54770 }
54771 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54772 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54773 }
54774 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54775 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54776 }
54777 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54778 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54779 }
54780 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54781 return (void *)((wxObject *) ((wxSizerItem *) x));
54782 }
54783 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54784 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54785 }
54786 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54787 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54788 }
54789 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54790 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54791 }
54792 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54793 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54794 }
54795 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54796 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54797 }
54798 static void *_p_wxSizerTo_p_wxObject(void *x) {
54799 return (void *)((wxObject *) ((wxSizer *) x));
54800 }
54801 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54802 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54803 }
54804 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54805 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54806 }
54807 static void *_p_wxEventTo_p_wxObject(void *x) {
54808 return (void *)((wxObject *) ((wxEvent *) x));
54809 }
54810 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54811 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54812 }
54813 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54814 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54815 }
54816 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54817 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54818 }
54819 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54820 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54821 }
54822 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54823 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54824 }
54825 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54826 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54827 }
54828 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54829 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54830 }
54831 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54832 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54833 }
54834 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54835 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54836 }
54837 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54838 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54839 }
54840 static void *_p_wxControlTo_p_wxObject(void *x) {
54841 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54842 }
54843 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54844 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54845 }
54846 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54847 return (void *)((wxObject *) ((wxFSFile *) x));
54848 }
54849 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54850 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54851 }
54852 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54853 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54854 }
54855 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54856 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54857 }
54858 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54859 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54860 }
54861 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54862 return (void *)((wxObject *) ((wxMenuItem *) x));
54863 }
54864 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54865 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54866 }
54867 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54868 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54869 }
54870 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54871 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54872 }
54873 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54874 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54875 }
54876 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54877 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54878 }
54879 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54880 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54881 }
54882 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54883 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54884 }
54885 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54886 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54887 }
54888 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54889 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54890 }
54891 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54892 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54893 }
54894 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54895 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54896 }
54897 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54898 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54899 }
54900 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54901 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54902 }
54903 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54904 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54905 }
54906 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54907 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54908 }
54909 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54910 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54911 }
54912 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54913 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54914 }
54915 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54916 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54917 }
54918 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54919 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54920 }
54921 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54922 return (void *)((wxObject *) ((wxImageHandler *) x));
54923 }
54924 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54925 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54926 }
54927 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54928 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54929 }
54930 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54931 return (void *)((wxObject *) ((wxEvtHandler *) x));
54932 }
54933 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54934 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54935 }
54936 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54937 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54938 }
54939 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54940 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54941 }
54942 static void *_p_wxImageTo_p_wxObject(void *x) {
54943 return (void *)((wxObject *) ((wxImage *) x));
54944 }
54945 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54946 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54947 }
54948 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54949 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54950 }
54951 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54952 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54953 }
54954 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54955 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54956 }
54957 static void *_p_wxWindowTo_p_wxObject(void *x) {
54958 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54959 }
54960 static void *_p_wxMenuTo_p_wxObject(void *x) {
54961 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54962 }
54963 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54964 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54965 }
54966 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54967 return (void *)((wxObject *) ((wxFileSystem *) x));
54968 }
54969 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54970 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54971 }
54972 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54973 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54974 }
54975 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54976 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54977 }
54978 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54979 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54980 }
54981 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54982 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54983 }
54984 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54985 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54986 }
54987 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54988 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54989 }
54990 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54991 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54992 }
54993 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54994 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54995 }
54996 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54997 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54998 }
54999 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55000 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55001 }
55002 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55003 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55004 }
55005 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55006 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55007 }
55008 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55009 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55010 }
55011 static void *_p_wxControlTo_p_wxWindow(void *x) {
55012 return (void *)((wxWindow *) ((wxControl *) x));
55013 }
55014 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55015 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55016 }
55017 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55018 return (void *)((wxWindow *) ((wxMenuBar *) x));
55019 }
55020 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55021 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55022 }
55023 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55024 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55025 }
55026 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55027 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55028 }
55029 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55030 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55031 }
55032 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55033 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55034 }
55035 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55036 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55037 }
55038 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55039 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55040 }
55041 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55042 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55043 }
55044 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55045 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55046 }
55047 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55048 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55049 }
55050 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55051 return (void *)((wxValidator *) ((wxPyValidator *) x));
55052 }
55053 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55054 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55055 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};
55056 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55057 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55058 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55059 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55060 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55061 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55062 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55063 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55064 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55065 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55066 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55067 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55068 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55069 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55070 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55071 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55072 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55073 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55074 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55075 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55076 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55077 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55078 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55079 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55080 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55081 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55082 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55083 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55084 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55085 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55086 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55087 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55088 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55089 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55090 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55091 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55092 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55093 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55094 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55095 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55096 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55097 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55098 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55099 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55100 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55101 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55102 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55103 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55104 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55105 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55106 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55107 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55108 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55109 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55110 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55111 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55112 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55113 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55114 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55115 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55116 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55117 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55118 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55119 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55120 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55121 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55122 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55123 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55124 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55125 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55126 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55127 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55128 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55129 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55130 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55131 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55132 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55133 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55134 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55135 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55136 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55137 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55138 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55139 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55140 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55141 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55142 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55143 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55144 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55145 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55146 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55147 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55148 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55149 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55150 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55151 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55152 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55153 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55154 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55155 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55156 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55157 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55158 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55159 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55160 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55161 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55162 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55163 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55164 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55165 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55166 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55167 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55168 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55169 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55170 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55171 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55172 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55173 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55174 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55175 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55176 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55177 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55178 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55179 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55180 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55181 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55182 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55183 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55184 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55185
55186 static swig_type_info *swig_type_initial[] = {
55187 &_swigt__p_buffer,
55188 &_swigt__p_char,
55189 &_swigt__p_form_ops_t,
55190 &_swigt__p_int,
55191 &_swigt__p_long,
55192 &_swigt__p_unsigned_char,
55193 &_swigt__p_unsigned_int,
55194 &_swigt__p_unsigned_long,
55195 &_swigt__p_wxANIHandler,
55196 &_swigt__p_wxAcceleratorEntry,
55197 &_swigt__p_wxAcceleratorTable,
55198 &_swigt__p_wxActivateEvent,
55199 &_swigt__p_wxAppTraits,
55200 &_swigt__p_wxArrayString,
55201 &_swigt__p_wxBMPHandler,
55202 &_swigt__p_wxBitmap,
55203 &_swigt__p_wxBoxSizer,
55204 &_swigt__p_wxButton,
55205 &_swigt__p_wxCURHandler,
55206 &_swigt__p_wxCaret,
55207 &_swigt__p_wxChildFocusEvent,
55208 &_swigt__p_wxClipboardTextEvent,
55209 &_swigt__p_wxCloseEvent,
55210 &_swigt__p_wxColour,
55211 &_swigt__p_wxCommandEvent,
55212 &_swigt__p_wxContextMenuEvent,
55213 &_swigt__p_wxControl,
55214 &_swigt__p_wxControlWithItems,
55215 &_swigt__p_wxCursor,
55216 &_swigt__p_wxDC,
55217 &_swigt__p_wxDateEvent,
55218 &_swigt__p_wxDateTime,
55219 &_swigt__p_wxDisplayChangedEvent,
55220 &_swigt__p_wxDropFilesEvent,
55221 &_swigt__p_wxDuplexMode,
55222 &_swigt__p_wxEraseEvent,
55223 &_swigt__p_wxEvent,
55224 &_swigt__p_wxEventLoop,
55225 &_swigt__p_wxEventLoopActivator,
55226 &_swigt__p_wxEvtHandler,
55227 &_swigt__p_wxFSFile,
55228 &_swigt__p_wxFileSystem,
55229 &_swigt__p_wxFileSystemHandler,
55230 &_swigt__p_wxFlexGridSizer,
55231 &_swigt__p_wxFocusEvent,
55232 &_swigt__p_wxFont,
55233 &_swigt__p_wxFrame,
55234 &_swigt__p_wxGBPosition,
55235 &_swigt__p_wxGBSizerItem,
55236 &_swigt__p_wxGBSpan,
55237 &_swigt__p_wxGIFHandler,
55238 &_swigt__p_wxGridBagSizer,
55239 &_swigt__p_wxGridSizer,
55240 &_swigt__p_wxHelpEvent__Origin,
55241 &_swigt__p_wxICOHandler,
55242 &_swigt__p_wxIconizeEvent,
55243 &_swigt__p_wxIdleEvent,
55244 &_swigt__p_wxImage,
55245 &_swigt__p_wxImageHandler,
55246 &_swigt__p_wxImageHistogram,
55247 &_swigt__p_wxImage_HSVValue,
55248 &_swigt__p_wxImage_RGBValue,
55249 &_swigt__p_wxIndividualLayoutConstraint,
55250 &_swigt__p_wxInitDialogEvent,
55251 &_swigt__p_wxInputStream,
55252 &_swigt__p_wxInternetFSHandler,
55253 &_swigt__p_wxItemContainer,
55254 &_swigt__p_wxJPEGHandler,
55255 &_swigt__p_wxKeyEvent,
55256 &_swigt__p_wxLayoutConstraints,
55257 &_swigt__p_wxMaximizeEvent,
55258 &_swigt__p_wxMemoryFSHandler,
55259 &_swigt__p_wxMenu,
55260 &_swigt__p_wxMenuBar,
55261 &_swigt__p_wxMenuBarBase,
55262 &_swigt__p_wxMenuEvent,
55263 &_swigt__p_wxMenuItem,
55264 &_swigt__p_wxMouseCaptureChangedEvent,
55265 &_swigt__p_wxMouseCaptureLostEvent,
55266 &_swigt__p_wxMouseEvent,
55267 &_swigt__p_wxMoveEvent,
55268 &_swigt__p_wxNavigationKeyEvent,
55269 &_swigt__p_wxNcPaintEvent,
55270 &_swigt__p_wxNotifyEvent,
55271 &_swigt__p_wxObject,
55272 &_swigt__p_wxOutputStream,
55273 &_swigt__p_wxPCXHandler,
55274 &_swigt__p_wxPNGHandler,
55275 &_swigt__p_wxPNMHandler,
55276 &_swigt__p_wxPaintEvent,
55277 &_swigt__p_wxPaletteChangedEvent,
55278 &_swigt__p_wxPaperSize,
55279 &_swigt__p_wxPoint,
55280 &_swigt__p_wxPoint2D,
55281 &_swigt__p_wxPropagateOnce,
55282 &_swigt__p_wxPropagationDisabler,
55283 &_swigt__p_wxPyApp,
55284 &_swigt__p_wxPyCommandEvent,
55285 &_swigt__p_wxPyDropTarget,
55286 &_swigt__p_wxPyEvent,
55287 &_swigt__p_wxPyFileSystemHandler,
55288 &_swigt__p_wxPyImageHandler,
55289 &_swigt__p_wxPyInputStream,
55290 &_swigt__p_wxPySizer,
55291 &_swigt__p_wxPyValidator,
55292 &_swigt__p_wxQuantize,
55293 &_swigt__p_wxQueryNewPaletteEvent,
55294 &_swigt__p_wxRealPoint,
55295 &_swigt__p_wxRect,
55296 &_swigt__p_wxRegion,
55297 &_swigt__p_wxScrollEvent,
55298 &_swigt__p_wxScrollWinEvent,
55299 &_swigt__p_wxSetCursorEvent,
55300 &_swigt__p_wxShowEvent,
55301 &_swigt__p_wxSize,
55302 &_swigt__p_wxSizeEvent,
55303 &_swigt__p_wxSizer,
55304 &_swigt__p_wxSizerItem,
55305 &_swigt__p_wxStaticBox,
55306 &_swigt__p_wxStaticBoxSizer,
55307 &_swigt__p_wxStdDialogButtonSizer,
55308 &_swigt__p_wxSysColourChangedEvent,
55309 &_swigt__p_wxTIFFHandler,
55310 &_swigt__p_wxToolTip,
55311 &_swigt__p_wxUpdateUIEvent,
55312 &_swigt__p_wxValidator,
55313 &_swigt__p_wxVisualAttributes,
55314 &_swigt__p_wxWindow,
55315 &_swigt__p_wxWindowCreateEvent,
55316 &_swigt__p_wxWindowDestroyEvent,
55317 &_swigt__p_wxXPMHandler,
55318 &_swigt__p_wxZipFSHandler,
55319 };
55320
55321 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55322 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55323 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55324 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55325 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55326 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55327 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55328 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55329 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55330 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55331 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55332 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55333 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55334 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55335 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}};
55336 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55337 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}};
55338 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55339 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}};
55340 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55341 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55342 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55343 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55344 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55345 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
55346 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55347 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}};
55348 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55349 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55350 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55351 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55352 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55353 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55354 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55355 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55356 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55357 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55358 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55359 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55360 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}};
55361 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55362 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55363 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}};
55364 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}};
55365 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55366 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55367 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55368 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55369 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55370 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55371 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55372 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55373 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}};
55374 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55375 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}};
55376 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55377 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55378 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55379 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}};
55380 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55381 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55382 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55383 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55384 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55385 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55386 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55387 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}};
55388 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55389 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55390 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55391 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55392 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55393 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55394 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55395 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55396 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55397 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55398 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55399 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55400 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55401 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55402 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55403 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55404 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55405 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55406 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55407 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55408 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55409 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55410 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55411 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55412 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55413 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55414 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55415 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55416 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55417 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55418 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55419 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55420 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55421 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55422 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55423 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55424 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55425 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55426 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55427 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55428 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55429 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55430 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55431 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55432 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55433 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55434 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55435 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55436 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55437 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}};
55438 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}};
55439 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55440 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55441 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55442 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55443 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55444 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55445 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55446 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}};
55447 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55448 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}};
55449 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55450 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55451 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55452 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55453
55454 static swig_cast_info *swig_cast_initial[] = {
55455 _swigc__p_buffer,
55456 _swigc__p_char,
55457 _swigc__p_form_ops_t,
55458 _swigc__p_int,
55459 _swigc__p_long,
55460 _swigc__p_unsigned_char,
55461 _swigc__p_unsigned_int,
55462 _swigc__p_unsigned_long,
55463 _swigc__p_wxANIHandler,
55464 _swigc__p_wxAcceleratorEntry,
55465 _swigc__p_wxAcceleratorTable,
55466 _swigc__p_wxActivateEvent,
55467 _swigc__p_wxAppTraits,
55468 _swigc__p_wxArrayString,
55469 _swigc__p_wxBMPHandler,
55470 _swigc__p_wxBitmap,
55471 _swigc__p_wxBoxSizer,
55472 _swigc__p_wxButton,
55473 _swigc__p_wxCURHandler,
55474 _swigc__p_wxCaret,
55475 _swigc__p_wxChildFocusEvent,
55476 _swigc__p_wxClipboardTextEvent,
55477 _swigc__p_wxCloseEvent,
55478 _swigc__p_wxColour,
55479 _swigc__p_wxCommandEvent,
55480 _swigc__p_wxContextMenuEvent,
55481 _swigc__p_wxControl,
55482 _swigc__p_wxControlWithItems,
55483 _swigc__p_wxCursor,
55484 _swigc__p_wxDC,
55485 _swigc__p_wxDateEvent,
55486 _swigc__p_wxDateTime,
55487 _swigc__p_wxDisplayChangedEvent,
55488 _swigc__p_wxDropFilesEvent,
55489 _swigc__p_wxDuplexMode,
55490 _swigc__p_wxEraseEvent,
55491 _swigc__p_wxEvent,
55492 _swigc__p_wxEventLoop,
55493 _swigc__p_wxEventLoopActivator,
55494 _swigc__p_wxEvtHandler,
55495 _swigc__p_wxFSFile,
55496 _swigc__p_wxFileSystem,
55497 _swigc__p_wxFileSystemHandler,
55498 _swigc__p_wxFlexGridSizer,
55499 _swigc__p_wxFocusEvent,
55500 _swigc__p_wxFont,
55501 _swigc__p_wxFrame,
55502 _swigc__p_wxGBPosition,
55503 _swigc__p_wxGBSizerItem,
55504 _swigc__p_wxGBSpan,
55505 _swigc__p_wxGIFHandler,
55506 _swigc__p_wxGridBagSizer,
55507 _swigc__p_wxGridSizer,
55508 _swigc__p_wxHelpEvent__Origin,
55509 _swigc__p_wxICOHandler,
55510 _swigc__p_wxIconizeEvent,
55511 _swigc__p_wxIdleEvent,
55512 _swigc__p_wxImage,
55513 _swigc__p_wxImageHandler,
55514 _swigc__p_wxImageHistogram,
55515 _swigc__p_wxImage_HSVValue,
55516 _swigc__p_wxImage_RGBValue,
55517 _swigc__p_wxIndividualLayoutConstraint,
55518 _swigc__p_wxInitDialogEvent,
55519 _swigc__p_wxInputStream,
55520 _swigc__p_wxInternetFSHandler,
55521 _swigc__p_wxItemContainer,
55522 _swigc__p_wxJPEGHandler,
55523 _swigc__p_wxKeyEvent,
55524 _swigc__p_wxLayoutConstraints,
55525 _swigc__p_wxMaximizeEvent,
55526 _swigc__p_wxMemoryFSHandler,
55527 _swigc__p_wxMenu,
55528 _swigc__p_wxMenuBar,
55529 _swigc__p_wxMenuBarBase,
55530 _swigc__p_wxMenuEvent,
55531 _swigc__p_wxMenuItem,
55532 _swigc__p_wxMouseCaptureChangedEvent,
55533 _swigc__p_wxMouseCaptureLostEvent,
55534 _swigc__p_wxMouseEvent,
55535 _swigc__p_wxMoveEvent,
55536 _swigc__p_wxNavigationKeyEvent,
55537 _swigc__p_wxNcPaintEvent,
55538 _swigc__p_wxNotifyEvent,
55539 _swigc__p_wxObject,
55540 _swigc__p_wxOutputStream,
55541 _swigc__p_wxPCXHandler,
55542 _swigc__p_wxPNGHandler,
55543 _swigc__p_wxPNMHandler,
55544 _swigc__p_wxPaintEvent,
55545 _swigc__p_wxPaletteChangedEvent,
55546 _swigc__p_wxPaperSize,
55547 _swigc__p_wxPoint,
55548 _swigc__p_wxPoint2D,
55549 _swigc__p_wxPropagateOnce,
55550 _swigc__p_wxPropagationDisabler,
55551 _swigc__p_wxPyApp,
55552 _swigc__p_wxPyCommandEvent,
55553 _swigc__p_wxPyDropTarget,
55554 _swigc__p_wxPyEvent,
55555 _swigc__p_wxPyFileSystemHandler,
55556 _swigc__p_wxPyImageHandler,
55557 _swigc__p_wxPyInputStream,
55558 _swigc__p_wxPySizer,
55559 _swigc__p_wxPyValidator,
55560 _swigc__p_wxQuantize,
55561 _swigc__p_wxQueryNewPaletteEvent,
55562 _swigc__p_wxRealPoint,
55563 _swigc__p_wxRect,
55564 _swigc__p_wxRegion,
55565 _swigc__p_wxScrollEvent,
55566 _swigc__p_wxScrollWinEvent,
55567 _swigc__p_wxSetCursorEvent,
55568 _swigc__p_wxShowEvent,
55569 _swigc__p_wxSize,
55570 _swigc__p_wxSizeEvent,
55571 _swigc__p_wxSizer,
55572 _swigc__p_wxSizerItem,
55573 _swigc__p_wxStaticBox,
55574 _swigc__p_wxStaticBoxSizer,
55575 _swigc__p_wxStdDialogButtonSizer,
55576 _swigc__p_wxSysColourChangedEvent,
55577 _swigc__p_wxTIFFHandler,
55578 _swigc__p_wxToolTip,
55579 _swigc__p_wxUpdateUIEvent,
55580 _swigc__p_wxValidator,
55581 _swigc__p_wxVisualAttributes,
55582 _swigc__p_wxWindow,
55583 _swigc__p_wxWindowCreateEvent,
55584 _swigc__p_wxWindowDestroyEvent,
55585 _swigc__p_wxXPMHandler,
55586 _swigc__p_wxZipFSHandler,
55587 };
55588
55589
55590 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55591
55592 static swig_const_info swig_const_table[] = {
55593 {0, 0, 0, 0.0, 0, 0}};
55594
55595 #ifdef __cplusplus
55596 }
55597 #endif
55598 /* -----------------------------------------------------------------------------
55599 * Type initialization:
55600 * This problem is tough by the requirement that no dynamic
55601 * memory is used. Also, since swig_type_info structures store pointers to
55602 * swig_cast_info structures and swig_cast_info structures store pointers back
55603 * to swig_type_info structures, we need some lookup code at initialization.
55604 * The idea is that swig generates all the structures that are needed.
55605 * The runtime then collects these partially filled structures.
55606 * The SWIG_InitializeModule function takes these initial arrays out of
55607 * swig_module, and does all the lookup, filling in the swig_module.types
55608 * array with the correct data and linking the correct swig_cast_info
55609 * structures together.
55610 *
55611 * The generated swig_type_info structures are assigned staticly to an initial
55612 * array. We just loop though that array, and handle each type individually.
55613 * First we lookup if this type has been already loaded, and if so, use the
55614 * loaded structure instead of the generated one. Then we have to fill in the
55615 * cast linked list. The cast data is initially stored in something like a
55616 * two-dimensional array. Each row corresponds to a type (there are the same
55617 * number of rows as there are in the swig_type_initial array). Each entry in
55618 * a column is one of the swig_cast_info structures for that type.
55619 * The cast_initial array is actually an array of arrays, because each row has
55620 * a variable number of columns. So to actually build the cast linked list,
55621 * we find the array of casts associated with the type, and loop through it
55622 * adding the casts to the list. The one last trick we need to do is making
55623 * sure the type pointer in the swig_cast_info struct is correct.
55624 *
55625 * First off, we lookup the cast->type name to see if it is already loaded.
55626 * There are three cases to handle:
55627 * 1) If the cast->type has already been loaded AND the type we are adding
55628 * casting info to has not been loaded (it is in this module), THEN we
55629 * replace the cast->type pointer with the type pointer that has already
55630 * been loaded.
55631 * 2) If BOTH types (the one we are adding casting info to, and the
55632 * cast->type) are loaded, THEN the cast info has already been loaded by
55633 * the previous module so we just ignore it.
55634 * 3) Finally, if cast->type has not already been loaded, then we add that
55635 * swig_cast_info to the linked list (because the cast->type) pointer will
55636 * be correct.
55637 * ----------------------------------------------------------------------------- */
55638
55639 #ifdef __cplusplus
55640 extern "C" {
55641 #if 0
55642 } /* c-mode */
55643 #endif
55644 #endif
55645
55646 #if 0
55647 #define SWIGRUNTIME_DEBUG
55648 #endif
55649
55650 SWIGRUNTIME void
55651 SWIG_InitializeModule(void *clientdata) {
55652 size_t i;
55653 swig_module_info *module_head;
55654 static int init_run = 0;
55655
55656 clientdata = clientdata;
55657
55658 if (init_run) return;
55659 init_run = 1;
55660
55661 /* Initialize the swig_module */
55662 swig_module.type_initial = swig_type_initial;
55663 swig_module.cast_initial = swig_cast_initial;
55664
55665 /* Try and load any already created modules */
55666 module_head = SWIG_GetModule(clientdata);
55667 if (module_head) {
55668 swig_module.next = module_head->next;
55669 module_head->next = &swig_module;
55670 } else {
55671 /* This is the first module loaded */
55672 swig_module.next = &swig_module;
55673 SWIG_SetModule(clientdata, &swig_module);
55674 }
55675
55676 /* Now work on filling in swig_module.types */
55677 #ifdef SWIGRUNTIME_DEBUG
55678 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55679 #endif
55680 for (i = 0; i < swig_module.size; ++i) {
55681 swig_type_info *type = 0;
55682 swig_type_info *ret;
55683 swig_cast_info *cast;
55684
55685 #ifdef SWIGRUNTIME_DEBUG
55686 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55687 #endif
55688
55689 /* if there is another module already loaded */
55690 if (swig_module.next != &swig_module) {
55691 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55692 }
55693 if (type) {
55694 /* Overwrite clientdata field */
55695 #ifdef SWIGRUNTIME_DEBUG
55696 printf("SWIG_InitializeModule: found type %s\n", type->name);
55697 #endif
55698 if (swig_module.type_initial[i]->clientdata) {
55699 type->clientdata = swig_module.type_initial[i]->clientdata;
55700 #ifdef SWIGRUNTIME_DEBUG
55701 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55702 #endif
55703 }
55704 } else {
55705 type = swig_module.type_initial[i];
55706 }
55707
55708 /* Insert casting types */
55709 cast = swig_module.cast_initial[i];
55710 while (cast->type) {
55711 /* Don't need to add information already in the list */
55712 ret = 0;
55713 #ifdef SWIGRUNTIME_DEBUG
55714 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55715 #endif
55716 if (swig_module.next != &swig_module) {
55717 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55718 #ifdef SWIGRUNTIME_DEBUG
55719 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55720 #endif
55721 }
55722 if (ret) {
55723 if (type == swig_module.type_initial[i]) {
55724 #ifdef SWIGRUNTIME_DEBUG
55725 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55726 #endif
55727 cast->type = ret;
55728 ret = 0;
55729 } else {
55730 /* Check for casting already in the list */
55731 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55732 #ifdef SWIGRUNTIME_DEBUG
55733 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55734 #endif
55735 if (!ocast) ret = 0;
55736 }
55737 }
55738
55739 if (!ret) {
55740 #ifdef SWIGRUNTIME_DEBUG
55741 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55742 #endif
55743 if (type->cast) {
55744 type->cast->prev = cast;
55745 cast->next = type->cast;
55746 }
55747 type->cast = cast;
55748 }
55749 cast++;
55750 }
55751 /* Set entry in modules->types array equal to the type */
55752 swig_module.types[i] = type;
55753 }
55754 swig_module.types[i] = 0;
55755
55756 #ifdef SWIGRUNTIME_DEBUG
55757 printf("**** SWIG_InitializeModule: Cast List ******\n");
55758 for (i = 0; i < swig_module.size; ++i) {
55759 int j = 0;
55760 swig_cast_info *cast = swig_module.cast_initial[i];
55761 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55762 while (cast->type) {
55763 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55764 cast++;
55765 ++j;
55766 }
55767 printf("---- Total casts: %d\n",j);
55768 }
55769 printf("**** SWIG_InitializeModule: Cast List ******\n");
55770 #endif
55771 }
55772
55773 /* This function will propagate the clientdata field of type to
55774 * any new swig_type_info structures that have been added into the list
55775 * of equivalent types. It is like calling
55776 * SWIG_TypeClientData(type, clientdata) a second time.
55777 */
55778 SWIGRUNTIME void
55779 SWIG_PropagateClientData(void) {
55780 size_t i;
55781 swig_cast_info *equiv;
55782 static int init_run = 0;
55783
55784 if (init_run) return;
55785 init_run = 1;
55786
55787 for (i = 0; i < swig_module.size; i++) {
55788 if (swig_module.types[i]->clientdata) {
55789 equiv = swig_module.types[i]->cast;
55790 while (equiv) {
55791 if (!equiv->converter) {
55792 if (equiv->type && !equiv->type->clientdata)
55793 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55794 }
55795 equiv = equiv->next;
55796 }
55797 }
55798 }
55799 }
55800
55801 #ifdef __cplusplus
55802 #if 0
55803 {
55804 /* c-mode */
55805 #endif
55806 }
55807 #endif
55808
55809
55810
55811 #ifdef __cplusplus
55812 extern "C" {
55813 #endif
55814
55815 /* Python-specific SWIG API */
55816 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55817 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55818 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55819
55820 /* -----------------------------------------------------------------------------
55821 * global variable support code.
55822 * ----------------------------------------------------------------------------- */
55823
55824 typedef struct swig_globalvar {
55825 char *name; /* Name of global variable */
55826 PyObject *(*get_attr)(void); /* Return the current value */
55827 int (*set_attr)(PyObject *); /* Set the value */
55828 struct swig_globalvar *next;
55829 } swig_globalvar;
55830
55831 typedef struct swig_varlinkobject {
55832 PyObject_HEAD
55833 swig_globalvar *vars;
55834 } swig_varlinkobject;
55835
55836 SWIGINTERN PyObject *
55837 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55838 return PyString_FromString("<Swig global variables>");
55839 }
55840
55841 SWIGINTERN PyObject *
55842 swig_varlink_str(swig_varlinkobject *v) {
55843 PyObject *str = PyString_FromString("(");
55844 swig_globalvar *var;
55845 for (var = v->vars; var; var=var->next) {
55846 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55847 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55848 }
55849 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55850 return str;
55851 }
55852
55853 SWIGINTERN int
55854 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55855 PyObject *str = swig_varlink_str(v);
55856 fprintf(fp,"Swig global variables ");
55857 fprintf(fp,"%s\n", PyString_AsString(str));
55858 Py_DECREF(str);
55859 return 0;
55860 }
55861
55862 SWIGINTERN void
55863 swig_varlink_dealloc(swig_varlinkobject *v) {
55864 swig_globalvar *var = v->vars;
55865 while (var) {
55866 swig_globalvar *n = var->next;
55867 free(var->name);
55868 free(var);
55869 var = n;
55870 }
55871 }
55872
55873 SWIGINTERN PyObject *
55874 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55875 PyObject *res = NULL;
55876 swig_globalvar *var = v->vars;
55877 while (var) {
55878 if (strcmp(var->name,n) == 0) {
55879 res = (*var->get_attr)();
55880 break;
55881 }
55882 var = var->next;
55883 }
55884 if (res == NULL && !PyErr_Occurred()) {
55885 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55886 }
55887 return res;
55888 }
55889
55890 SWIGINTERN int
55891 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55892 int res = 1;
55893 swig_globalvar *var = v->vars;
55894 while (var) {
55895 if (strcmp(var->name,n) == 0) {
55896 res = (*var->set_attr)(p);
55897 break;
55898 }
55899 var = var->next;
55900 }
55901 if (res == 1 && !PyErr_Occurred()) {
55902 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55903 }
55904 return res;
55905 }
55906
55907 SWIGINTERN PyTypeObject*
55908 swig_varlink_type(void) {
55909 static char varlink__doc__[] = "Swig var link object";
55910 static PyTypeObject varlink_type;
55911 static int type_init = 0;
55912 if (!type_init) {
55913 const PyTypeObject tmp
55914 = {
55915 PyObject_HEAD_INIT(NULL)
55916 0, /* Number of items in variable part (ob_size) */
55917 (char *)"swigvarlink", /* Type name (tp_name) */
55918 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55919 0, /* Itemsize (tp_itemsize) */
55920 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55921 (printfunc) swig_varlink_print, /* Print (tp_print) */
55922 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55923 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55924 0, /* tp_compare */
55925 (reprfunc) swig_varlink_repr, /* tp_repr */
55926 0, /* tp_as_number */
55927 0, /* tp_as_sequence */
55928 0, /* tp_as_mapping */
55929 0, /* tp_hash */
55930 0, /* tp_call */
55931 (reprfunc)swig_varlink_str, /* tp_str */
55932 0, /* tp_getattro */
55933 0, /* tp_setattro */
55934 0, /* tp_as_buffer */
55935 0, /* tp_flags */
55936 varlink__doc__, /* tp_doc */
55937 0, /* tp_traverse */
55938 0, /* tp_clear */
55939 0, /* tp_richcompare */
55940 0, /* tp_weaklistoffset */
55941 #if PY_VERSION_HEX >= 0x02020000
55942 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55943 #endif
55944 #if PY_VERSION_HEX >= 0x02030000
55945 0, /* tp_del */
55946 #endif
55947 #ifdef COUNT_ALLOCS
55948 0,0,0,0 /* tp_alloc -> tp_next */
55949 #endif
55950 };
55951 varlink_type = tmp;
55952 varlink_type.ob_type = &PyType_Type;
55953 type_init = 1;
55954 }
55955 return &varlink_type;
55956 }
55957
55958 /* Create a variable linking object for use later */
55959 SWIGINTERN PyObject *
55960 SWIG_Python_newvarlink(void) {
55961 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55962 if (result) {
55963 result->vars = 0;
55964 }
55965 return ((PyObject*) result);
55966 }
55967
55968 SWIGINTERN void
55969 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55970 swig_varlinkobject *v = (swig_varlinkobject *) p;
55971 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55972 if (gv) {
55973 size_t size = strlen(name)+1;
55974 gv->name = (char *)malloc(size);
55975 if (gv->name) {
55976 strncpy(gv->name,name,size);
55977 gv->get_attr = get_attr;
55978 gv->set_attr = set_attr;
55979 gv->next = v->vars;
55980 }
55981 }
55982 v->vars = gv;
55983 }
55984
55985 SWIGINTERN PyObject *
55986 SWIG_globals() {
55987 static PyObject *_SWIG_globals = 0;
55988 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55989 return _SWIG_globals;
55990 }
55991
55992 /* -----------------------------------------------------------------------------
55993 * constants/methods manipulation
55994 * ----------------------------------------------------------------------------- */
55995
55996 /* Install Constants */
55997 SWIGINTERN void
55998 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55999 PyObject *obj = 0;
56000 size_t i;
56001 for (i = 0; constants[i].type; ++i) {
56002 switch(constants[i].type) {
56003 case SWIG_PY_POINTER:
56004 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56005 break;
56006 case SWIG_PY_BINARY:
56007 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56008 break;
56009 default:
56010 obj = 0;
56011 break;
56012 }
56013 if (obj) {
56014 PyDict_SetItemString(d, constants[i].name, obj);
56015 Py_DECREF(obj);
56016 }
56017 }
56018 }
56019
56020 /* -----------------------------------------------------------------------------*/
56021 /* Fix SwigMethods to carry the callback ptrs when needed */
56022 /* -----------------------------------------------------------------------------*/
56023
56024 SWIGINTERN void
56025 SWIG_Python_FixMethods(PyMethodDef *methods,
56026 swig_const_info *const_table,
56027 swig_type_info **types,
56028 swig_type_info **types_initial) {
56029 size_t i;
56030 for (i = 0; methods[i].ml_name; ++i) {
56031 const char *c = methods[i].ml_doc;
56032 if (c && (c = strstr(c, "swig_ptr: "))) {
56033 int j;
56034 swig_const_info *ci = 0;
56035 const char *name = c + 10;
56036 for (j = 0; const_table[j].type; ++j) {
56037 if (strncmp(const_table[j].name, name,
56038 strlen(const_table[j].name)) == 0) {
56039 ci = &(const_table[j]);
56040 break;
56041 }
56042 }
56043 if (ci) {
56044 size_t shift = (ci->ptype) - types;
56045 swig_type_info *ty = types_initial[shift];
56046 size_t ldoc = (c - methods[i].ml_doc);
56047 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56048 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56049 if (ndoc) {
56050 char *buff = ndoc;
56051 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56052 if (ptr) {
56053 strncpy(buff, methods[i].ml_doc, ldoc);
56054 buff += ldoc;
56055 strncpy(buff, "swig_ptr: ", 10);
56056 buff += 10;
56057 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56058 methods[i].ml_doc = ndoc;
56059 }
56060 }
56061 }
56062 }
56063 }
56064 }
56065
56066 #ifdef __cplusplus
56067 }
56068 #endif
56069
56070 /* -----------------------------------------------------------------------------*
56071 * Partial Init method
56072 * -----------------------------------------------------------------------------*/
56073
56074 #ifdef __cplusplus
56075 extern "C"
56076 #endif
56077 SWIGEXPORT void SWIG_init(void) {
56078 PyObject *m, *d;
56079
56080 /* Fix SwigMethods to carry the callback ptrs when needed */
56081 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56082
56083 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56084 d = PyModule_GetDict(m);
56085
56086 SWIG_InitializeModule(0);
56087 SWIG_InstallConstants(d,swig_const_table);
56088
56089
56090
56091 #ifndef wxPyUSE_EXPORT
56092 // Make our API structure a CObject so other modules can import it
56093 // from this module.
56094 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56095 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56096 Py_XDECREF(cobj);
56097 #endif
56098
56099 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56100 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56101 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56102 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56103 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56104 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56105 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56106 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56107 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56108 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56109 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56110 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56111 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56112 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56113 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56114 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56115 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56116 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56117 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56118 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56119 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56120 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56121 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56122 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56123 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56124 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56125 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56126 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56127 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56128 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56129 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56130 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56131 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56132 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56133 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56134 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56135 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56136 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56137 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56138 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56139 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56140 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56141 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56142 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56143 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56144 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56145 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56146 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56147 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56148 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56149 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56150 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56151 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56152 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56153 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56154 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56155 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56156 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56157 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56158 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56159 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56160 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56161 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56162 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56163 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56164 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56165 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56166 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56167 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56168 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56169 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56170 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56171 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56172 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56173 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56174 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56175 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56176 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56177 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56178 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56179 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56180 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56181 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56182 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56183 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56184 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56185 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56186 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56187 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56188 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56189 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56190 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56191 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56192 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56193 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56194 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56195 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56196 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56197 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56198 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56199 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56200 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56201 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56202 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56203 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56204 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56205 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56206 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56207 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56208 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56209 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56210 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56211 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56212 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56213 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56214 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56215 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56216 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56217 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56218 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56219 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56220 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56221 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56222 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56223 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56224 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56225 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56226 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56227 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56228 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56229 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56230 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56231 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56232 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56233 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56234 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56235 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56236 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56237 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56238 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56239 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56240 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56241 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56242 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56243 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56244 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56245 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56246 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56247 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56248 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56249 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56250 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56251 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56252 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56253 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56254 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56255 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56256 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56257 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56258 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56259 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56260 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56261 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56262 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56263 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56264 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56265 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56266 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56267 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56268 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56269 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56270 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56271 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56272 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56273 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56274 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56275 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56276 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56277 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56278 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56279 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56280 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56281 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56282 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56283 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56284 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56285 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56286 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56287 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56288 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56289 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56290 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56291 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56292 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56293 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56294 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56295 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56296 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56297 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56298 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56299 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56300 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56301 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56302 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56303 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56304 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56305 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56306 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56307 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56308 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56309 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56310 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56311 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56312 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56313 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56314 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56315 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56316 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56317 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56318 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56319 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56320 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56321 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56322 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56323 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56324 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56325 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56326 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56327 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56328 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56329 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56330 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56331 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56332 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56333 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56334 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56335 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56336 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56337 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56338 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56339 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56340 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56341 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56342 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56343 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56344 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56345 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56346 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56347 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56348 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56349 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56350 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56351 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56352 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56353 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56354 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56355 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56356 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56357 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56358 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56359 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56360 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56361 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56362 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56363 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56364 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56365 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56366 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56367 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56368 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56369 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56370 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56371 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56372 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56373 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56374 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56375 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56376 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56377 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56378 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56379 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56380 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56381 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56382 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56383 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56384 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56385 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56386 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56387 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56388 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56389 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56390 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56391 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56392 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56393 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56394 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56395 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56396 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56397 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56398 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56399 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56400 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56401 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56402 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56403 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56404 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56405 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56406 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56407 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56408 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56409 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56410 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56411 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56412 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56413 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56414 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56415 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56416 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56417 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56418 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56419 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56420 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56421 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56422 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56423 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56424 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56425 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56426 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56427 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56428 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56429 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56430 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56431 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56432 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56433 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56434 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56435 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56436 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56437 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56438 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56439 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56440 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56441 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56442 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56443 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56444 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56445 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56446 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56447 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56448 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56449 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56450 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56451 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56452 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56453 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56454 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56455 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56456 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56457 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56458 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56459 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56460 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56461 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56462 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56463 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56464 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56465 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56466 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56467 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56468 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56469 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56470 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56471 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56472 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56473 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56474 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56475 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56476 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56477 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56478 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56479 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56480 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56481 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56482 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56483 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56484 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56485 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56486 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56487 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56488 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56489 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56490 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56491 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56492 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56493 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56494 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56495 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56496 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56497 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56498 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56499 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56500 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56501 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56502 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56503 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56504 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56505 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56506 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56507 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56508 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56509 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56510 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56511 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56512 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56513 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56514 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56515 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56516 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56517 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56518 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56519 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56520 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56521 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56522 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56523 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56524 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56525 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56526 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56527 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56528 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56529 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56530 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56531 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56532 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56533 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56534 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56535 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56536 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56537 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56538 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56539 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56540 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56541 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56542 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56543 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56544 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56545 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56546 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56547 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56548 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56549 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56550 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56551 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56552 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56553 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56554 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56555 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56556 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56557 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56558 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56559 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56560 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56561 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56562 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56563 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56564 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56565 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56566 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56567 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56568 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56569 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56570 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56571 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56572 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56573 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56574 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56575 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56576 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56577 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56578 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56579 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56580 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56581 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56582 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56583 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56584 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56585 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56586 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56587 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56588 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56589 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56590 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56591 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56592 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56593 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56594 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56595 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56596 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56597 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56598 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56599 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56600 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56601 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56602 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56603 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56604 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56605 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56606 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56607 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56608 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56609 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56610 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56611 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56612 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56613 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56614 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56615 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56616 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56617 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56618 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56619 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56620 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56621 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56622 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56623 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56624 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56625 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56626 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56627 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56628 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56629 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56630 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56631 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56632 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56633 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56634 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56635 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56636 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56637 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56638 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56639 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56640 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56641 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56642 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56643 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56644 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56645 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56646 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56647 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56648 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56649 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56650 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56651 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56652 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56653 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56654 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56655 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56656 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56657 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56658 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56659 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56660 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56661 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56662 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56663 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56664 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56665 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56666 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56667 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56668 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56669 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56670 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56671 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56672 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56673 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56674 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56675 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56676 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56677 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56678 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56679 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56680 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56681 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56682 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56683 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56684 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56685 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56686 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56687 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56688 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56689 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56690 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56691 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56692 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56693 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56694 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56695 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56696 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56697 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56698 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56699 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56700 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56701 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56702 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56703 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56704 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56705 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56706 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56707 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56708 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56709 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56710 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56711 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56712 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56713 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56714 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56715 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56716 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56717 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56718 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56719 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56720 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56721 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56722 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56723 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56724 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56725 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56726 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56727 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56728 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56729 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56730 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56731 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56732 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56733 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56734 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56735 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56736 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56737 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56738 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56739 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56740 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56741 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56742 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56743 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56744 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56745 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56746 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56747 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56748 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56749 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56750 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56751 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56752 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56753 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56754 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56755 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56756 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56757 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56758 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56759 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56760 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56761
56762 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56763
56764
56765 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56766
56767 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56768 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56769 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56770 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56771 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56772 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56773 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56774 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56775 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56776 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56777 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56778 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56779 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56780 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56781 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56782 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56783 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56784 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56785 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56786 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56787 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56788 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56789 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56790 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56791 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56792 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56793 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56794 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56795 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56796 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56797 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56798 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56799 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56800 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56801 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56802 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56803 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56804 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56805 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56806 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56807 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56808 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56809 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56810 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56811 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56812 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56813 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56814 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56815 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56816 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56817 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56818 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56819 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56820 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56821 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56822 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56823 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56824 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56825 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56826 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56827 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56828 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56829 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56830 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56831 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56832 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56833 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56834 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56835 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56836 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56837 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56838 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56839 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56840 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56841 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56842 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56843 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56844 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56845 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56846 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56847 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56848 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56849 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56850 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56851 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56852 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56853 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56854 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56855 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56856 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56857 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56858 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56859 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56860 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56861 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56862 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56863 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56864 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56865 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56866 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56867 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56868 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56869 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56870 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56871 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56872 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56873 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56874 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56875 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56876 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56877 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56878 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56879 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56880 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56881 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56882 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56883 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56884 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56885 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56886 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56887 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56888 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56889 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56890 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56891 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56892 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56893 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56894 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56895 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56896 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56897 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56898 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56899 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56900 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56901 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56902 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56903 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56904 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56905 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56906 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56907 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56908 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56909 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56910 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56911 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56912 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56913 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56914 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56915 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56916 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56917 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56918 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56919 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56920 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56921 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56922 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56923 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56924 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56925 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56926 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56927 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56928 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56929 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56930 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56931 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56932 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56933 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56934 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56935 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56936 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56937 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56938 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56939 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56940 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56941 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56942 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56943 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56944 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56945 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56946 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
56947 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56948 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56949 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56950 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56951 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56952 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56953 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56954 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56955 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56956 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56957 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56958 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56959 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56960 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56961 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56962 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56963 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56964 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56965 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56966 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56967 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56968 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56969 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56970 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56971 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56972 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56973 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56974 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56975 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56976 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56977 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56978 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56979
56980 // Initialize threading, some globals and such
56981 __wxPyPreStart(d);
56982
56983
56984 // Although these are defined in __version__ they need to be here too so
56985 // that an assert can be done to ensure that the wxPython and the wxWindows
56986 // versions match.
56987 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56988 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56989 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56990
56991 }
56992
wxWidgets (Impactor)