]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:


bbc5d9ab951c10386c955baa6bcd5556a1c864fe
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 typedef unsigned char* buffer;
3487
3488
3489 // Pull the nested class out to the top level for SWIG's sake
3490 #define wxImage_RGBValue wxImage::RGBValue
3491 #define wxImage_HSVValue wxImage::HSVValue
3492
3493 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3494 if (width > 0 && height > 0)
3495 return new wxImage(width, height, clear);
3496 else
3497 return new wxImage;
3498 }
3499 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3500 return new wxImage(bitmap.ConvertToImage());
3501 }
3502 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3503 if (DATASIZE != width*height*3) {
3504 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3505 return NULL;
3506 }
3507
3508 // Copy the source data so the wxImage can clean it up later
3509 buffer copy = (buffer)malloc(DATASIZE);
3510 if (copy == NULL) {
3511 wxPyBLOCK_THREADS(PyErr_NoMemory());
3512 return NULL;
3513 }
3514 memcpy(copy, data, DATASIZE);
3515 return new wxImage(width, height, copy, false);
3516 }
3517 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3518 if (DATASIZE != width*height*3) {
3519 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3520 return NULL;
3521 }
3522 if (ALPHASIZE != width*height) {
3523 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3524 return NULL;
3525 }
3526
3527 // Copy the source data so the wxImage can clean it up later
3528 buffer dcopy = (buffer)malloc(DATASIZE);
3529 if (dcopy == NULL) {
3530 wxPyBLOCK_THREADS(PyErr_NoMemory());
3531 return NULL;
3532 }
3533 memcpy(dcopy, data, DATASIZE);
3534
3535 buffer acopy = (buffer)malloc(ALPHASIZE);
3536 if (acopy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return NULL;
3539 }
3540 memcpy(acopy, alpha, ALPHASIZE);
3541
3542 return new wxImage(width, height, dcopy, acopy, false);
3543 }
3544 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3545 wxSize size(self->GetWidth(), self->GetHeight());
3546 return size;
3547 }
3548 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3549 buffer data = self->GetData();
3550 int len = self->GetWidth() * self->GetHeight() * 3;
3551 PyObject* rv;
3552 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3553 return rv;
3554 }
3555 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3556 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return;
3559 }
3560 buffer copy = (buffer)malloc(DATASIZE);
3561 if (copy == NULL) {
3562 wxPyBLOCK_THREADS(PyErr_NoMemory());
3563 return;
3564 }
3565 memcpy(copy, data, DATASIZE);
3566 self->SetData(copy, false);
3567 // wxImage takes ownership of copy...
3568 }
3569 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3570 buffer data = self->GetData();
3571 int len = self->GetWidth() * self->GetHeight() * 3;
3572 PyObject* rv;
3573 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3574 return rv;
3575 }
3576 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3577 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3578 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3579 return;
3580 }
3581 self->SetData(data, true);
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 if (! data) {
3586 RETURN_NONE();
3587 } else {
3588 int len = self->GetWidth() * self->GetHeight();
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3591 return rv;
3592 }
3593 }
3594 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3595 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3596 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3597 return;
3598 }
3599 buffer acopy = (buffer)malloc(ALPHASIZE);
3600 if (acopy == NULL) {
3601 wxPyBLOCK_THREADS(PyErr_NoMemory());
3602 return;
3603 }
3604 memcpy(acopy, alpha, ALPHASIZE);
3605 self->SetAlpha(acopy, false);
3606 // wxImage takes ownership of acopy...
3607 }
3608 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3609 buffer data = self->GetAlpha();
3610 int len = self->GetWidth() * self->GetHeight();
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3616 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3618 return;
3619 }
3620 self->SetAlpha(alpha, true);
3621 }
3622 SWIGINTERN PyObject *wxImage_GetHandlers(){
3623 wxList& list = wxImage::GetHandlers();
3624 return wxPy_ConvertList(&list);
3625 }
3626 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3627 wxBitmap bitmap(*self, depth);
3628 return bitmap;
3629 }
3630 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3631 wxImage mono = self->ConvertToMono( red, green, blue );
3632 wxBitmap bitmap( mono, 1 );
3633 return bitmap;
3634 }
3635 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3636 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3637 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3638 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3639 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3640 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3641 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3642 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3643 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3644 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3645 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3646 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3647 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3648 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3649 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3650
3651 #include <wx/quantize.h>
3652
3653 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3654 return wxQuantize::Quantize(src, dest,
3655 //NULL, // palette
3656 desiredNoColours,
3657 NULL, // eightBitData
3658 flags);
3659 }
3660 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3661 if (PyCallable_Check(func)) {
3662 self->Connect(id, lastId, eventType,
3663 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3664 new wxPyCallback(func));
3665 }
3666 else if (func == Py_None) {
3667 self->Disconnect(id, lastId, eventType,
3668 (wxObjectEventFunction)
3669 &wxPyCallback::EventThunker);
3670 }
3671 else {
3672 wxPyBLOCK_THREADS(
3673 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3674 }
3675 }
3676 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3677 return self->Disconnect(id, lastId, eventType,
3678 (wxObjectEventFunction)
3679 &wxPyCallback::EventThunker);
3680 }
3681 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3682 if (_self && _self != Py_None) {
3683 self->SetClientObject(new wxPyOORClientData(_self, incref));
3684 }
3685 else {
3686 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3687 if (data) {
3688 self->SetClientObject(NULL); // This will delete it too
3689 }
3690 }
3691 }
3692
3693 #if ! wxUSE_HOTKEY
3694 #define wxEVT_HOTKEY -9999
3695 #endif
3696
3697 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3698 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3699 if (data) {
3700 Py_INCREF(data->m_obj);
3701 return data->m_obj;
3702 } else {
3703 Py_INCREF(Py_None);
3704 return Py_None;
3705 }
3706 }
3707 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3708 wxPyClientData* data = new wxPyClientData(clientData);
3709 self->SetClientObject(data);
3710 }
3711 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3712 #if wxUSE_UNICODE
3713 return self->GetUnicodeKey();
3714 #else
3715 return 0;
3716 #endif
3717 }
3718 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3719 #if wxUSE_UNICODE
3720 self->m_uniChar = uniChar;
3721 #endif
3722 }
3723
3724 SWIGINTERNINLINE PyObject *
3725 SWIG_From_unsigned_SS_int (unsigned int value)
3726 {
3727 return SWIG_From_unsigned_SS_long (value);
3728 }
3729
3730
3731 SWIGINTERN int
3732 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3733 {
3734 unsigned long v;
3735 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3736 if (SWIG_IsOK(res)) {
3737 if ((v > UINT_MAX)) {
3738 return SWIG_OverflowError;
3739 } else {
3740 if (val) *val = static_cast< unsigned int >(v);
3741 }
3742 }
3743 return res;
3744 }
3745
3746 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3747 self->m_size = size;
3748 }
3749 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3750 int count = self->GetNumberOfFiles();
3751 wxString* files = self->GetFiles();
3752 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3753 PyObject* list = PyList_New(count);
3754
3755 if (!list) {
3756 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3757 wxPyEndBlockThreads(blocked);
3758 return NULL;
3759 }
3760
3761 for (int i=0; i<count; i++) {
3762 PyList_SetItem(list, i, wx2PyString(files[i]));
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return list;
3766 }
3767
3768
3769 SWIGINTERN wxPyApp *new_wxPyApp(){
3770 wxPythonApp = new wxPyApp();
3771 return wxPythonApp;
3772 }
3773 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3774
3775 void wxApp_CleanUp() {
3776 __wxPyCleanup();
3777 }
3778
3779
3780 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3781
3782
3783
3784
3785
3786 SWIGINTERNINLINE PyObject *
3787 SWIG_FromCharPtr(const char *cptr)
3788 {
3789 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3790 }
3791
3792
3793 #if 0 // #ifdef __WXMAC__
3794
3795 // A dummy class that raises an exception if used...
3796 class wxEventLoop
3797 {
3798 public:
3799 wxEventLoop() { wxPyRaiseNotImplemented(); }
3800 int Run() { return 0; }
3801 void Exit(int rc = 0) {}
3802 bool Pending() const { return false; }
3803 bool Dispatch() { return false; }
3804 bool IsRunning() const { return false; }
3805 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3806 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3807 };
3808
3809 #else
3810
3811 #include <wx/evtloop.h>
3812
3813 #endif
3814
3815
3816
3817 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3818 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3819 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3820 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3821 wxWindowList& list = self->GetChildren();
3822 return wxPy_ConvertList(&list);
3823 }
3824 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3825 #if wxUSE_HOTKEY
3826 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3827 #else
3828 return false;
3829 #endif
3830 }
3831 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3832
3833
3834
3835 return false;
3836
3837 }
3838 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3839 return wxPyGetWinHandle(self);
3840 }
3841 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3842 self->AssociateHandle((WXWidget)handle);
3843 }
3844 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3845
3846 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3847 return wxWindow::FindWindowById(id, parent);
3848 }
3849
3850 wxWindow* wxFindWindowByName( const wxString& name,
3851 const wxWindow *parent = NULL ) {
3852 return wxWindow::FindWindowByName(name, parent);
3853 }
3854
3855 wxWindow* wxFindWindowByLabel( const wxString& label,
3856 const wxWindow *parent = NULL ) {
3857 return wxWindow::FindWindowByLabel(label, parent);
3858 }
3859
3860
3861 #ifdef __WXMSW__
3862 #include <wx/msw/private.h> // to get wxGetWindowId
3863 #endif
3864
3865
3866 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3867 #ifdef __WXMSW__
3868 WXHWND hWnd = (WXHWND)_hWnd;
3869 long id = wxGetWindowId(hWnd);
3870 wxWindow* win = new wxWindow;
3871 if (parent)
3872 parent->AddChild(win);
3873 win->SetEventHandler(win);
3874 win->SetHWND(hWnd);
3875 win->SetId(id);
3876 win->SubclassWin(hWnd);
3877 win->AdoptAttributesFromHWND();
3878 win->SetupColours();
3879 return win;
3880 #else
3881 wxPyRaiseNotImplemented();
3882 return NULL;
3883 #endif
3884 }
3885
3886
3887 PyObject* GetTopLevelWindows() {
3888 return wxPy_ConvertList(&wxTopLevelWindows);
3889 }
3890
3891
3892 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3893 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3894 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3895
3896 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3897
3898
3899 SWIGINTERNINLINE int
3900 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3901 {
3902 unsigned long v;
3903 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3904 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3905 return res;
3906 }
3907
3908 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3909 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3910 wxMenuItemList& list = self->GetMenuItems();
3911 return wxPy_ConvertList(&list);
3912 }
3913 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3914 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3915 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3916 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3917 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3918 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3919 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3920 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3921 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3922 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3923 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3924 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3925 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3926 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3927 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3928 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3929 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3930 static const wxString wxPyControlNameStr(wxControlNameStr);
3931 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3932 if (clientData) {
3933 wxPyClientData* data = new wxPyClientData(clientData);
3934 return self->Append(item, data);
3935 } else
3936 return self->Append(item);
3937 }
3938 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3939 if (clientData) {
3940 wxPyClientData* data = new wxPyClientData(clientData);
3941 return self->Insert(item, pos, data);
3942 } else
3943 return self->Insert(item, pos);
3944 }
3945 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3946 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3947 if (data) {
3948 Py_INCREF(data->m_obj);
3949 return data->m_obj;
3950 } else {
3951 Py_INCREF(Py_None);
3952 return Py_None;
3953 }
3954 }
3955 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3956 wxPyClientData* data = new wxPyClientData(clientData);
3957 self->SetClientObject(n, data);
3958 }
3959
3960
3961 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3962 wxPyUserData* data = NULL;
3963 if ( userData ) {
3964 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3965 data = new wxPyUserData(userData);
3966 wxPyEndBlockThreads(blocked);
3967 }
3968 return new wxSizerItem(window, proportion, flag, border, data);
3969 }
3970 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3971 wxPyUserData* data = NULL;
3972 if ( userData ) {
3973 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3974 data = new wxPyUserData(userData);
3975 wxPyEndBlockThreads(blocked);
3976 }
3977 return new wxSizerItem(width, height, proportion, flag, border, data);
3978 }
3979 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,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(sizer, proportion, flag, border, data);
3987 }
3988
3989 SWIGINTERNINLINE PyObject *
3990 SWIG_From_float (float value)
3991 {
3992 return SWIG_From_double (value);
3993 }
3994
3995 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3996 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3997 if (data) {
3998 Py_INCREF(data->m_obj);
3999 return data->m_obj;
4000 } else {
4001 Py_INCREF(Py_None);
4002 return Py_None;
4003 }
4004 }
4005 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4006 wxPyUserData* data = NULL;
4007 if ( userData ) {
4008 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4009 data = new wxPyUserData(userData);
4010 wxPyEndBlockThreads(blocked);
4011 }
4012 self->SetUserData(data);
4013 }
4014
4015 // Figure out the type of the sizer item
4016
4017 struct wxPySizerItemInfo {
4018 wxPySizerItemInfo()
4019 : window(NULL), sizer(NULL), gotSize(false),
4020 size(wxDefaultSize), gotPos(false), pos(-1)
4021 {}
4022
4023 wxWindow* window;
4024 wxSizer* sizer;
4025 bool gotSize;
4026 wxSize size;
4027 bool gotPos;
4028 int pos;
4029 };
4030
4031 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4032
4033 wxPySizerItemInfo info;
4034 wxSize size;
4035 wxSize* sizePtr = &size;
4036
4037 // Find out what the type of the item is
4038 // try wxWindow
4039 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4040 PyErr_Clear();
4041 info.window = NULL;
4042
4043 // try wxSizer
4044 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4045 PyErr_Clear();
4046 info.sizer = NULL;
4047
4048 // try wxSize or (w,h)
4049 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4050 info.size = *sizePtr;
4051 info.gotSize = true;
4052 }
4053
4054 // or a single int
4055 if (checkIdx && PyInt_Check(item)) {
4056 info.pos = PyInt_AsLong(item);
4057 info.gotPos = true;
4058 }
4059 }
4060 }
4061
4062 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4063 // no expected type, figure out what kind of error message to generate
4064 if ( !checkSize && !checkIdx )
4065 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4066 else if ( checkSize && !checkIdx )
4067 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4068 else if ( !checkSize && checkIdx)
4069 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4070 else
4071 // can this one happen?
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4073 }
4074
4075 return info;
4076 }
4077
4078 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4079 if (!self->GetClientObject())
4080 self->SetClientObject(new wxPyOORClientData(_self));
4081 }
4082 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4083
4084 wxPyUserData* data = NULL;
4085 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4087 if ( userData && (info.window || info.sizer || info.gotSize) )
4088 data = new wxPyUserData(userData);
4089 if ( info.sizer )
4090 PyObject_SetAttrString(item,"thisown",Py_False);
4091 wxPyEndBlockThreads(blocked);
4092
4093 // Now call the real Add method if a valid item type was found
4094 if ( info.window )
4095 return self->Add(info.window, proportion, flag, border, data);
4096 else if ( info.sizer )
4097 return self->Add(info.sizer, proportion, flag, border, data);
4098 else if (info.gotSize)
4099 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4100 proportion, flag, border, data);
4101 else
4102 return NULL;
4103 }
4104 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4105
4106 wxPyUserData* data = NULL;
4107 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4108 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4109 if ( userData && (info.window || info.sizer || info.gotSize) )
4110 data = new wxPyUserData(userData);
4111 if ( info.sizer )
4112 PyObject_SetAttrString(item,"thisown",Py_False);
4113 wxPyEndBlockThreads(blocked);
4114
4115 // Now call the real Insert method if a valid item type was found
4116 if ( info.window )
4117 return self->Insert(before, info.window, proportion, flag, border, data);
4118 else if ( info.sizer )
4119 return self->Insert(before, info.sizer, proportion, flag, border, data);
4120 else if (info.gotSize)
4121 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4122 proportion, flag, border, data);
4123 else
4124 return NULL;
4125 }
4126 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4127
4128 wxPyUserData* data = NULL;
4129 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4130 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4131 if ( userData && (info.window || info.sizer || info.gotSize) )
4132 data = new wxPyUserData(userData);
4133 if ( info.sizer )
4134 PyObject_SetAttrString(item,"thisown",Py_False);
4135 wxPyEndBlockThreads(blocked);
4136
4137 // Now call the real Prepend method if a valid item type was found
4138 if ( info.window )
4139 return self->Prepend(info.window, proportion, flag, border, data);
4140 else if ( info.sizer )
4141 return self->Prepend(info.sizer, proportion, flag, border, data);
4142 else if (info.gotSize)
4143 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4144 proportion, flag, border, data);
4145 else
4146 return NULL;
4147 }
4148 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4150 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4151 wxPyEndBlockThreads(blocked);
4152 if ( info.window )
4153 return self->Remove(info.window);
4154 else if ( info.sizer )
4155 return self->Remove(info.sizer);
4156 else if ( info.gotPos )
4157 return self->Remove(info.pos);
4158 else
4159 return false;
4160 }
4161 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4162 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4163 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4164 wxPyEndBlockThreads(blocked);
4165 if ( info.window )
4166 return self->Detach(info.window);
4167 else if ( info.sizer )
4168 return self->Detach(info.sizer);
4169 else if ( info.gotPos )
4170 return self->Detach(info.pos);
4171 else
4172 return false;
4173 }
4174 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4175 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4176 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4177 wxPyEndBlockThreads(blocked);
4178 if ( info.window )
4179 return self->GetItem(info.window);
4180 else if ( info.sizer )
4181 return self->GetItem(info.sizer);
4182 else if ( info.gotPos )
4183 return self->GetItem(info.pos);
4184 else
4185 return NULL;
4186 }
4187 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4189 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4190 wxPyEndBlockThreads(blocked);
4191 if ( info.window )
4192 self->SetItemMinSize(info.window, size);
4193 else if ( info.sizer )
4194 self->SetItemMinSize(info.sizer, size);
4195 else if ( info.gotPos )
4196 self->SetItemMinSize(info.pos, size);
4197 }
4198 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4199 wxSizerItemList& list = self->GetChildren();
4200 return wxPy_ConvertList(&list);
4201 }
4202 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4204 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4205 wxPyEndBlockThreads(blocked);
4206 if ( info.window )
4207 return self->Show(info.window, show, recursive);
4208 else if ( info.sizer )
4209 return self->Show(info.sizer, show, recursive);
4210 else if ( info.gotPos )
4211 return self->Show(info.pos, show);
4212 else
4213 return false;
4214 }
4215 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4217 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4218 wxPyEndBlockThreads(blocked);
4219 if ( info.window )
4220 return self->IsShown(info.window);
4221 else if ( info.sizer )
4222 return self->IsShown(info.sizer);
4223 else if ( info.gotPos )
4224 return self->IsShown(info.pos);
4225 else
4226 return false;
4227 }
4228
4229 // See pyclasses.h
4230 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4231 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4232 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4233
4234
4235
4236
4237 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4238 {
4239 if (source == Py_None) {
4240 **obj = wxGBPosition(-1,-1);
4241 return true;
4242 }
4243 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4244 }
4245
4246 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4247 {
4248 if (source == Py_None) {
4249 **obj = wxGBSpan(-1,-1);
4250 return true;
4251 }
4252 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4253 }
4254
4255
4256 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4257 wxGBPosition temp, *obj = &temp;
4258 if ( other == Py_None ) return false;
4259 if ( ! wxGBPosition_helper(other, &obj) ) {
4260 PyErr_Clear();
4261 return false;
4262 }
4263 return self->operator==(*obj);
4264 }
4265 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4266 wxGBPosition temp, *obj = &temp;
4267 if ( other == Py_None ) return true;
4268 if ( ! wxGBPosition_helper(other, &obj)) {
4269 PyErr_Clear();
4270 return true;
4271 }
4272 return self->operator!=(*obj);
4273 }
4274 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4275 self->SetRow(row);
4276 self->SetCol(col);
4277 }
4278 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4280 PyObject* tup = PyTuple_New(2);
4281 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4282 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4283 wxPyEndBlockThreads(blocked);
4284 return tup;
4285 }
4286 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4287 wxGBSpan temp, *obj = &temp;
4288 if ( other == Py_None ) return false;
4289 if ( ! wxGBSpan_helper(other, &obj) ) {
4290 PyErr_Clear();
4291 return false;
4292 }
4293 return self->operator==(*obj);
4294 }
4295 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4296 wxGBSpan temp, *obj = &temp;
4297 if ( other == Py_None ) return true;
4298 if ( ! wxGBSpan_helper(other, &obj)) {
4299 PyErr_Clear();
4300 return true;
4301 }
4302 return self->operator!=(*obj);
4303 }
4304 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4305 self->SetRowspan(rowspan);
4306 self->SetColspan(colspan);
4307 }
4308 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4309 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4310 PyObject* tup = PyTuple_New(2);
4311 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4312 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4313 wxPyEndBlockThreads(blocked);
4314 return tup;
4315 }
4316 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4317 wxPyUserData* data = NULL;
4318 if ( userData ) {
4319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4320 data = new wxPyUserData(userData);
4321 wxPyEndBlockThreads(blocked);
4322 }
4323 return new wxGBSizerItem(window, pos, span, flag, border, data);
4324 }
4325 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4326 wxPyUserData* data = NULL;
4327 if ( userData ) {
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 data = new wxPyUserData(userData);
4330 wxPyEndBlockThreads(blocked);
4331 }
4332 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4333 }
4334 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,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(width, height, pos, span, flag, border, data);
4342 }
4343 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4344 int row, col;
4345 self->GetEndPos(row, col);
4346 return wxGBPosition(row, col);
4347 }
4348 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4349
4350 wxPyUserData* data = NULL;
4351 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4352 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4353 if ( userData && (info.window || info.sizer || info.gotSize) )
4354 data = new wxPyUserData(userData);
4355 if ( info.sizer )
4356 PyObject_SetAttrString(item,"thisown",Py_False);
4357 wxPyEndBlockThreads(blocked);
4358
4359 // Now call the real Add method if a valid item type was found
4360 if ( info.window )
4361 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4362 else if ( info.sizer )
4363 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4364 else if (info.gotSize)
4365 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4366 pos, span, flag, border, data);
4367 return NULL;
4368 }
4369
4370
4371 #ifdef __cplusplus
4372 extern "C" {
4373 #endif
4374 SWIGINTERN int EmptyString_set(PyObject *) {
4375 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4376 return 1;
4377 }
4378
4379
4380 SWIGINTERN PyObject *EmptyString_get(void) {
4381 PyObject *pyobj = 0;
4382
4383 {
4384 #if wxUSE_UNICODE
4385 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4386 #else
4387 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4388 #endif
4389 }
4390 return pyobj;
4391 }
4392
4393
4394 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4395 PyObject *resultobj = 0;
4396 wxObject *arg1 = (wxObject *) 0 ;
4397 wxString result;
4398 void *argp1 = 0 ;
4399 int res1 = 0 ;
4400 PyObject *swig_obj[1] ;
4401
4402 if (!args) SWIG_fail;
4403 swig_obj[0] = args;
4404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4405 if (!SWIG_IsOK(res1)) {
4406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4407 }
4408 arg1 = reinterpret_cast< wxObject * >(argp1);
4409 {
4410 PyThreadState* __tstate = wxPyBeginAllowThreads();
4411 result = wxObject_GetClassName(arg1);
4412 wxPyEndAllowThreads(__tstate);
4413 if (PyErr_Occurred()) SWIG_fail;
4414 }
4415 {
4416 #if wxUSE_UNICODE
4417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4418 #else
4419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4420 #endif
4421 }
4422 return resultobj;
4423 fail:
4424 return NULL;
4425 }
4426
4427
4428 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4429 PyObject *resultobj = 0;
4430 wxObject *arg1 = (wxObject *) 0 ;
4431 void *argp1 = 0 ;
4432 int res1 = 0 ;
4433 PyObject *swig_obj[1] ;
4434
4435 if (!args) SWIG_fail;
4436 swig_obj[0] = args;
4437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4438 if (!SWIG_IsOK(res1)) {
4439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4440 }
4441 arg1 = reinterpret_cast< wxObject * >(argp1);
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 wxObject_Destroy(arg1);
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 resultobj = SWIG_Py_Void();
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4456 PyObject *obj;
4457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4458 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4459 return SWIG_Py_Void();
4460 }
4461
4462 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4463 PyObject *resultobj = 0;
4464 wxSize *arg1 = (wxSize *) 0 ;
4465 int arg2 ;
4466 void *argp1 = 0 ;
4467 int res1 = 0 ;
4468 int val2 ;
4469 int ecode2 = 0 ;
4470 PyObject *swig_obj[2] ;
4471
4472 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4474 if (!SWIG_IsOK(res1)) {
4475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4476 }
4477 arg1 = reinterpret_cast< wxSize * >(argp1);
4478 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4479 if (!SWIG_IsOK(ecode2)) {
4480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4481 }
4482 arg2 = static_cast< int >(val2);
4483 if (arg1) (arg1)->x = arg2;
4484
4485 resultobj = SWIG_Py_Void();
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4493 PyObject *resultobj = 0;
4494 wxSize *arg1 = (wxSize *) 0 ;
4495 int result;
4496 void *argp1 = 0 ;
4497 int res1 = 0 ;
4498 PyObject *swig_obj[1] ;
4499
4500 if (!args) SWIG_fail;
4501 swig_obj[0] = args;
4502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4503 if (!SWIG_IsOK(res1)) {
4504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4505 }
4506 arg1 = reinterpret_cast< wxSize * >(argp1);
4507 result = (int) ((arg1)->x);
4508 resultobj = SWIG_From_int(static_cast< int >(result));
4509 return resultobj;
4510 fail:
4511 return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4516 PyObject *resultobj = 0;
4517 wxSize *arg1 = (wxSize *) 0 ;
4518 int arg2 ;
4519 void *argp1 = 0 ;
4520 int res1 = 0 ;
4521 int val2 ;
4522 int ecode2 = 0 ;
4523 PyObject *swig_obj[2] ;
4524
4525 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4527 if (!SWIG_IsOK(res1)) {
4528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4529 }
4530 arg1 = reinterpret_cast< wxSize * >(argp1);
4531 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4532 if (!SWIG_IsOK(ecode2)) {
4533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4534 }
4535 arg2 = static_cast< int >(val2);
4536 if (arg1) (arg1)->y = arg2;
4537
4538 resultobj = SWIG_Py_Void();
4539 return resultobj;
4540 fail:
4541 return NULL;
4542 }
4543
4544
4545 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4546 PyObject *resultobj = 0;
4547 wxSize *arg1 = (wxSize *) 0 ;
4548 int result;
4549 void *argp1 = 0 ;
4550 int res1 = 0 ;
4551 PyObject *swig_obj[1] ;
4552
4553 if (!args) SWIG_fail;
4554 swig_obj[0] = args;
4555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4556 if (!SWIG_IsOK(res1)) {
4557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4558 }
4559 arg1 = reinterpret_cast< wxSize * >(argp1);
4560 result = (int) ((arg1)->y);
4561 resultobj = SWIG_From_int(static_cast< int >(result));
4562 return resultobj;
4563 fail:
4564 return NULL;
4565 }
4566
4567
4568 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4569 PyObject *resultobj = 0;
4570 int arg1 = (int) 0 ;
4571 int arg2 = (int) 0 ;
4572 wxSize *result = 0 ;
4573 int val1 ;
4574 int ecode1 = 0 ;
4575 int val2 ;
4576 int ecode2 = 0 ;
4577 PyObject * obj0 = 0 ;
4578 PyObject * obj1 = 0 ;
4579 char * kwnames[] = {
4580 (char *) "w",(char *) "h", NULL
4581 };
4582
4583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4584 if (obj0) {
4585 ecode1 = SWIG_AsVal_int(obj0, &val1);
4586 if (!SWIG_IsOK(ecode1)) {
4587 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4588 }
4589 arg1 = static_cast< int >(val1);
4590 }
4591 if (obj1) {
4592 ecode2 = SWIG_AsVal_int(obj1, &val2);
4593 if (!SWIG_IsOK(ecode2)) {
4594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4595 }
4596 arg2 = static_cast< int >(val2);
4597 }
4598 {
4599 PyThreadState* __tstate = wxPyBeginAllowThreads();
4600 result = (wxSize *)new wxSize(arg1,arg2);
4601 wxPyEndAllowThreads(__tstate);
4602 if (PyErr_Occurred()) SWIG_fail;
4603 }
4604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4605 return resultobj;
4606 fail:
4607 return NULL;
4608 }
4609
4610
4611 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4612 PyObject *resultobj = 0;
4613 wxSize *arg1 = (wxSize *) 0 ;
4614 void *argp1 = 0 ;
4615 int res1 = 0 ;
4616 PyObject *swig_obj[1] ;
4617
4618 if (!args) SWIG_fail;
4619 swig_obj[0] = args;
4620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4621 if (!SWIG_IsOK(res1)) {
4622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4623 }
4624 arg1 = reinterpret_cast< wxSize * >(argp1);
4625 {
4626 PyThreadState* __tstate = wxPyBeginAllowThreads();
4627 delete arg1;
4628
4629 wxPyEndAllowThreads(__tstate);
4630 if (PyErr_Occurred()) SWIG_fail;
4631 }
4632 resultobj = SWIG_Py_Void();
4633 return resultobj;
4634 fail:
4635 return NULL;
4636 }
4637
4638
4639 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4640 PyObject *resultobj = 0;
4641 wxSize *arg1 = (wxSize *) 0 ;
4642 PyObject *arg2 = (PyObject *) 0 ;
4643 bool result;
4644 void *argp1 = 0 ;
4645 int res1 = 0 ;
4646 PyObject * obj0 = 0 ;
4647 PyObject * obj1 = 0 ;
4648 char * kwnames[] = {
4649 (char *) "self",(char *) "other", NULL
4650 };
4651
4652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4654 if (!SWIG_IsOK(res1)) {
4655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4656 }
4657 arg1 = reinterpret_cast< wxSize * >(argp1);
4658 arg2 = obj1;
4659 {
4660 result = (bool)wxSize___eq__(arg1,arg2);
4661 if (PyErr_Occurred()) SWIG_fail;
4662 }
4663 {
4664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4665 }
4666 return resultobj;
4667 fail:
4668 return NULL;
4669 }
4670
4671
4672 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4673 PyObject *resultobj = 0;
4674 wxSize *arg1 = (wxSize *) 0 ;
4675 PyObject *arg2 = (PyObject *) 0 ;
4676 bool result;
4677 void *argp1 = 0 ;
4678 int res1 = 0 ;
4679 PyObject * obj0 = 0 ;
4680 PyObject * obj1 = 0 ;
4681 char * kwnames[] = {
4682 (char *) "self",(char *) "other", NULL
4683 };
4684
4685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4687 if (!SWIG_IsOK(res1)) {
4688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4689 }
4690 arg1 = reinterpret_cast< wxSize * >(argp1);
4691 arg2 = obj1;
4692 {
4693 result = (bool)wxSize___ne__(arg1,arg2);
4694 if (PyErr_Occurred()) SWIG_fail;
4695 }
4696 {
4697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4698 }
4699 return resultobj;
4700 fail:
4701 return NULL;
4702 }
4703
4704
4705 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4706 PyObject *resultobj = 0;
4707 wxSize *arg1 = (wxSize *) 0 ;
4708 wxSize *arg2 = 0 ;
4709 wxSize result;
4710 void *argp1 = 0 ;
4711 int res1 = 0 ;
4712 wxSize temp2 ;
4713 PyObject * obj0 = 0 ;
4714 PyObject * obj1 = 0 ;
4715 char * kwnames[] = {
4716 (char *) "self",(char *) "sz", NULL
4717 };
4718
4719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4721 if (!SWIG_IsOK(res1)) {
4722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4723 }
4724 arg1 = reinterpret_cast< wxSize * >(argp1);
4725 {
4726 arg2 = &temp2;
4727 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4728 }
4729 {
4730 PyThreadState* __tstate = wxPyBeginAllowThreads();
4731 result = (arg1)->operator +((wxSize const &)*arg2);
4732 wxPyEndAllowThreads(__tstate);
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4736 return resultobj;
4737 fail:
4738 return NULL;
4739 }
4740
4741
4742 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj = 0;
4744 wxSize *arg1 = (wxSize *) 0 ;
4745 wxSize *arg2 = 0 ;
4746 wxSize result;
4747 void *argp1 = 0 ;
4748 int res1 = 0 ;
4749 wxSize temp2 ;
4750 PyObject * obj0 = 0 ;
4751 PyObject * obj1 = 0 ;
4752 char * kwnames[] = {
4753 (char *) "self",(char *) "sz", NULL
4754 };
4755
4756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4758 if (!SWIG_IsOK(res1)) {
4759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4760 }
4761 arg1 = reinterpret_cast< wxSize * >(argp1);
4762 {
4763 arg2 = &temp2;
4764 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4765 }
4766 {
4767 PyThreadState* __tstate = wxPyBeginAllowThreads();
4768 result = (arg1)->operator -((wxSize const &)*arg2);
4769 wxPyEndAllowThreads(__tstate);
4770 if (PyErr_Occurred()) SWIG_fail;
4771 }
4772 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4773 return resultobj;
4774 fail:
4775 return NULL;
4776 }
4777
4778
4779 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4780 PyObject *resultobj = 0;
4781 wxSize *arg1 = (wxSize *) 0 ;
4782 wxSize *arg2 = 0 ;
4783 void *argp1 = 0 ;
4784 int res1 = 0 ;
4785 wxSize temp2 ;
4786 PyObject * obj0 = 0 ;
4787 PyObject * obj1 = 0 ;
4788 char * kwnames[] = {
4789 (char *) "self",(char *) "sz", NULL
4790 };
4791
4792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4794 if (!SWIG_IsOK(res1)) {
4795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4796 }
4797 arg1 = reinterpret_cast< wxSize * >(argp1);
4798 {
4799 arg2 = &temp2;
4800 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4801 }
4802 {
4803 PyThreadState* __tstate = wxPyBeginAllowThreads();
4804 (arg1)->IncTo((wxSize const &)*arg2);
4805 wxPyEndAllowThreads(__tstate);
4806 if (PyErr_Occurred()) SWIG_fail;
4807 }
4808 resultobj = SWIG_Py_Void();
4809 return resultobj;
4810 fail:
4811 return NULL;
4812 }
4813
4814
4815 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4816 PyObject *resultobj = 0;
4817 wxSize *arg1 = (wxSize *) 0 ;
4818 wxSize *arg2 = 0 ;
4819 void *argp1 = 0 ;
4820 int res1 = 0 ;
4821 wxSize temp2 ;
4822 PyObject * obj0 = 0 ;
4823 PyObject * obj1 = 0 ;
4824 char * kwnames[] = {
4825 (char *) "self",(char *) "sz", NULL
4826 };
4827
4828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4830 if (!SWIG_IsOK(res1)) {
4831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4832 }
4833 arg1 = reinterpret_cast< wxSize * >(argp1);
4834 {
4835 arg2 = &temp2;
4836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4837 }
4838 {
4839 PyThreadState* __tstate = wxPyBeginAllowThreads();
4840 (arg1)->DecTo((wxSize const &)*arg2);
4841 wxPyEndAllowThreads(__tstate);
4842 if (PyErr_Occurred()) SWIG_fail;
4843 }
4844 resultobj = SWIG_Py_Void();
4845 return resultobj;
4846 fail:
4847 return NULL;
4848 }
4849
4850
4851 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4852 PyObject *resultobj = 0;
4853 wxSize *arg1 = (wxSize *) 0 ;
4854 float arg2 ;
4855 float arg3 ;
4856 void *argp1 = 0 ;
4857 int res1 = 0 ;
4858 float val2 ;
4859 int ecode2 = 0 ;
4860 float val3 ;
4861 int ecode3 = 0 ;
4862 PyObject * obj0 = 0 ;
4863 PyObject * obj1 = 0 ;
4864 PyObject * obj2 = 0 ;
4865 char * kwnames[] = {
4866 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4867 };
4868
4869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4871 if (!SWIG_IsOK(res1)) {
4872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4873 }
4874 arg1 = reinterpret_cast< wxSize * >(argp1);
4875 ecode2 = SWIG_AsVal_float(obj1, &val2);
4876 if (!SWIG_IsOK(ecode2)) {
4877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4878 }
4879 arg2 = static_cast< float >(val2);
4880 ecode3 = SWIG_AsVal_float(obj2, &val3);
4881 if (!SWIG_IsOK(ecode3)) {
4882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4883 }
4884 arg3 = static_cast< float >(val3);
4885 {
4886 PyThreadState* __tstate = wxPyBeginAllowThreads();
4887 (arg1)->Scale(arg2,arg3);
4888 wxPyEndAllowThreads(__tstate);
4889 if (PyErr_Occurred()) SWIG_fail;
4890 }
4891 resultobj = SWIG_Py_Void();
4892 return resultobj;
4893 fail:
4894 return NULL;
4895 }
4896
4897
4898 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4899 PyObject *resultobj = 0;
4900 wxSize *arg1 = (wxSize *) 0 ;
4901 int arg2 ;
4902 int arg3 ;
4903 void *argp1 = 0 ;
4904 int res1 = 0 ;
4905 int val2 ;
4906 int ecode2 = 0 ;
4907 int val3 ;
4908 int ecode3 = 0 ;
4909 PyObject * obj0 = 0 ;
4910 PyObject * obj1 = 0 ;
4911 PyObject * obj2 = 0 ;
4912 char * kwnames[] = {
4913 (char *) "self",(char *) "w",(char *) "h", NULL
4914 };
4915
4916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4918 if (!SWIG_IsOK(res1)) {
4919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4920 }
4921 arg1 = reinterpret_cast< wxSize * >(argp1);
4922 ecode2 = SWIG_AsVal_int(obj1, &val2);
4923 if (!SWIG_IsOK(ecode2)) {
4924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4925 }
4926 arg2 = static_cast< int >(val2);
4927 ecode3 = SWIG_AsVal_int(obj2, &val3);
4928 if (!SWIG_IsOK(ecode3)) {
4929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4930 }
4931 arg3 = static_cast< int >(val3);
4932 {
4933 PyThreadState* __tstate = wxPyBeginAllowThreads();
4934 (arg1)->Set(arg2,arg3);
4935 wxPyEndAllowThreads(__tstate);
4936 if (PyErr_Occurred()) SWIG_fail;
4937 }
4938 resultobj = SWIG_Py_Void();
4939 return resultobj;
4940 fail:
4941 return NULL;
4942 }
4943
4944
4945 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4946 PyObject *resultobj = 0;
4947 wxSize *arg1 = (wxSize *) 0 ;
4948 int arg2 ;
4949 void *argp1 = 0 ;
4950 int res1 = 0 ;
4951 int val2 ;
4952 int ecode2 = 0 ;
4953 PyObject * obj0 = 0 ;
4954 PyObject * obj1 = 0 ;
4955 char * kwnames[] = {
4956 (char *) "self",(char *) "w", NULL
4957 };
4958
4959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4961 if (!SWIG_IsOK(res1)) {
4962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4963 }
4964 arg1 = reinterpret_cast< wxSize * >(argp1);
4965 ecode2 = SWIG_AsVal_int(obj1, &val2);
4966 if (!SWIG_IsOK(ecode2)) {
4967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4968 }
4969 arg2 = static_cast< int >(val2);
4970 {
4971 PyThreadState* __tstate = wxPyBeginAllowThreads();
4972 (arg1)->SetWidth(arg2);
4973 wxPyEndAllowThreads(__tstate);
4974 if (PyErr_Occurred()) SWIG_fail;
4975 }
4976 resultobj = SWIG_Py_Void();
4977 return resultobj;
4978 fail:
4979 return NULL;
4980 }
4981
4982
4983 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4984 PyObject *resultobj = 0;
4985 wxSize *arg1 = (wxSize *) 0 ;
4986 int arg2 ;
4987 void *argp1 = 0 ;
4988 int res1 = 0 ;
4989 int val2 ;
4990 int ecode2 = 0 ;
4991 PyObject * obj0 = 0 ;
4992 PyObject * obj1 = 0 ;
4993 char * kwnames[] = {
4994 (char *) "self",(char *) "h", NULL
4995 };
4996
4997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4999 if (!SWIG_IsOK(res1)) {
5000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5001 }
5002 arg1 = reinterpret_cast< wxSize * >(argp1);
5003 ecode2 = SWIG_AsVal_int(obj1, &val2);
5004 if (!SWIG_IsOK(ecode2)) {
5005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5006 }
5007 arg2 = static_cast< int >(val2);
5008 {
5009 PyThreadState* __tstate = wxPyBeginAllowThreads();
5010 (arg1)->SetHeight(arg2);
5011 wxPyEndAllowThreads(__tstate);
5012 if (PyErr_Occurred()) SWIG_fail;
5013 }
5014 resultobj = SWIG_Py_Void();
5015 return resultobj;
5016 fail:
5017 return NULL;
5018 }
5019
5020
5021 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5022 PyObject *resultobj = 0;
5023 wxSize *arg1 = (wxSize *) 0 ;
5024 int result;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 PyObject *swig_obj[1] ;
5028
5029 if (!args) SWIG_fail;
5030 swig_obj[0] = args;
5031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5032 if (!SWIG_IsOK(res1)) {
5033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5034 }
5035 arg1 = reinterpret_cast< wxSize * >(argp1);
5036 {
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = (int)((wxSize const *)arg1)->GetWidth();
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 resultobj = SWIG_From_int(static_cast< int >(result));
5043 return resultobj;
5044 fail:
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5050 PyObject *resultobj = 0;
5051 wxSize *arg1 = (wxSize *) 0 ;
5052 int result;
5053 void *argp1 = 0 ;
5054 int res1 = 0 ;
5055 PyObject *swig_obj[1] ;
5056
5057 if (!args) SWIG_fail;
5058 swig_obj[0] = args;
5059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5060 if (!SWIG_IsOK(res1)) {
5061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5062 }
5063 arg1 = reinterpret_cast< wxSize * >(argp1);
5064 {
5065 PyThreadState* __tstate = wxPyBeginAllowThreads();
5066 result = (int)((wxSize const *)arg1)->GetHeight();
5067 wxPyEndAllowThreads(__tstate);
5068 if (PyErr_Occurred()) SWIG_fail;
5069 }
5070 resultobj = SWIG_From_int(static_cast< int >(result));
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5078 PyObject *resultobj = 0;
5079 wxSize *arg1 = (wxSize *) 0 ;
5080 bool result;
5081 void *argp1 = 0 ;
5082 int res1 = 0 ;
5083 PyObject *swig_obj[1] ;
5084
5085 if (!args) SWIG_fail;
5086 swig_obj[0] = args;
5087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5088 if (!SWIG_IsOK(res1)) {
5089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5090 }
5091 arg1 = reinterpret_cast< wxSize * >(argp1);
5092 {
5093 PyThreadState* __tstate = wxPyBeginAllowThreads();
5094 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5095 wxPyEndAllowThreads(__tstate);
5096 if (PyErr_Occurred()) SWIG_fail;
5097 }
5098 {
5099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5100 }
5101 return resultobj;
5102 fail:
5103 return NULL;
5104 }
5105
5106
5107 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5108 PyObject *resultobj = 0;
5109 wxSize *arg1 = (wxSize *) 0 ;
5110 wxSize *arg2 = 0 ;
5111 void *argp1 = 0 ;
5112 int res1 = 0 ;
5113 wxSize temp2 ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 char * kwnames[] = {
5117 (char *) "self",(char *) "size", NULL
5118 };
5119
5120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5122 if (!SWIG_IsOK(res1)) {
5123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5124 }
5125 arg1 = reinterpret_cast< wxSize * >(argp1);
5126 {
5127 arg2 = &temp2;
5128 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5129 }
5130 {
5131 PyThreadState* __tstate = wxPyBeginAllowThreads();
5132 (arg1)->SetDefaults((wxSize const &)*arg2);
5133 wxPyEndAllowThreads(__tstate);
5134 if (PyErr_Occurred()) SWIG_fail;
5135 }
5136 resultobj = SWIG_Py_Void();
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5144 PyObject *resultobj = 0;
5145 wxSize *arg1 = (wxSize *) 0 ;
5146 PyObject *result = 0 ;
5147 void *argp1 = 0 ;
5148 int res1 = 0 ;
5149 PyObject *swig_obj[1] ;
5150
5151 if (!args) SWIG_fail;
5152 swig_obj[0] = args;
5153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5154 if (!SWIG_IsOK(res1)) {
5155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5156 }
5157 arg1 = reinterpret_cast< wxSize * >(argp1);
5158 {
5159 PyThreadState* __tstate = wxPyBeginAllowThreads();
5160 result = (PyObject *)wxSize_Get(arg1);
5161 wxPyEndAllowThreads(__tstate);
5162 if (PyErr_Occurred()) SWIG_fail;
5163 }
5164 resultobj = result;
5165 return resultobj;
5166 fail:
5167 return NULL;
5168 }
5169
5170
5171 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5172 PyObject *obj;
5173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5174 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5175 return SWIG_Py_Void();
5176 }
5177
5178 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5179 return SWIG_Python_InitShadowInstance(args);
5180 }
5181
5182 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183 PyObject *resultobj = 0;
5184 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5185 double arg2 ;
5186 void *argp1 = 0 ;
5187 int res1 = 0 ;
5188 double val2 ;
5189 int ecode2 = 0 ;
5190 PyObject *swig_obj[2] ;
5191
5192 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5194 if (!SWIG_IsOK(res1)) {
5195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5196 }
5197 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5198 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5199 if (!SWIG_IsOK(ecode2)) {
5200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5201 }
5202 arg2 = static_cast< double >(val2);
5203 if (arg1) (arg1)->x = arg2;
5204
5205 resultobj = SWIG_Py_Void();
5206 return resultobj;
5207 fail:
5208 return NULL;
5209 }
5210
5211
5212 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5213 PyObject *resultobj = 0;
5214 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5215 double result;
5216 void *argp1 = 0 ;
5217 int res1 = 0 ;
5218 PyObject *swig_obj[1] ;
5219
5220 if (!args) SWIG_fail;
5221 swig_obj[0] = args;
5222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5223 if (!SWIG_IsOK(res1)) {
5224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5225 }
5226 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5227 result = (double) ((arg1)->x);
5228 resultobj = SWIG_From_double(static_cast< double >(result));
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5236 PyObject *resultobj = 0;
5237 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5238 double arg2 ;
5239 void *argp1 = 0 ;
5240 int res1 = 0 ;
5241 double val2 ;
5242 int ecode2 = 0 ;
5243 PyObject *swig_obj[2] ;
5244
5245 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5247 if (!SWIG_IsOK(res1)) {
5248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5249 }
5250 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5251 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5252 if (!SWIG_IsOK(ecode2)) {
5253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5254 }
5255 arg2 = static_cast< double >(val2);
5256 if (arg1) (arg1)->y = arg2;
5257
5258 resultobj = SWIG_Py_Void();
5259 return resultobj;
5260 fail:
5261 return NULL;
5262 }
5263
5264
5265 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5266 PyObject *resultobj = 0;
5267 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5268 double result;
5269 void *argp1 = 0 ;
5270 int res1 = 0 ;
5271 PyObject *swig_obj[1] ;
5272
5273 if (!args) SWIG_fail;
5274 swig_obj[0] = args;
5275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5276 if (!SWIG_IsOK(res1)) {
5277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5278 }
5279 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5280 result = (double) ((arg1)->y);
5281 resultobj = SWIG_From_double(static_cast< double >(result));
5282 return resultobj;
5283 fail:
5284 return NULL;
5285 }
5286
5287
5288 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5289 PyObject *resultobj = 0;
5290 double arg1 = (double) 0.0 ;
5291 double arg2 = (double) 0.0 ;
5292 wxRealPoint *result = 0 ;
5293 double val1 ;
5294 int ecode1 = 0 ;
5295 double val2 ;
5296 int ecode2 = 0 ;
5297 PyObject * obj0 = 0 ;
5298 PyObject * obj1 = 0 ;
5299 char * kwnames[] = {
5300 (char *) "x",(char *) "y", NULL
5301 };
5302
5303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5304 if (obj0) {
5305 ecode1 = SWIG_AsVal_double(obj0, &val1);
5306 if (!SWIG_IsOK(ecode1)) {
5307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5308 }
5309 arg1 = static_cast< double >(val1);
5310 }
5311 if (obj1) {
5312 ecode2 = SWIG_AsVal_double(obj1, &val2);
5313 if (!SWIG_IsOK(ecode2)) {
5314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5315 }
5316 arg2 = static_cast< double >(val2);
5317 }
5318 {
5319 PyThreadState* __tstate = wxPyBeginAllowThreads();
5320 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5321 wxPyEndAllowThreads(__tstate);
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5325 return resultobj;
5326 fail:
5327 return NULL;
5328 }
5329
5330
5331 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5332 PyObject *resultobj = 0;
5333 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5334 void *argp1 = 0 ;
5335 int res1 = 0 ;
5336 PyObject *swig_obj[1] ;
5337
5338 if (!args) SWIG_fail;
5339 swig_obj[0] = args;
5340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5341 if (!SWIG_IsOK(res1)) {
5342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5343 }
5344 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5345 {
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 delete arg1;
5348
5349 wxPyEndAllowThreads(__tstate);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 resultobj = SWIG_Py_Void();
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5360 PyObject *resultobj = 0;
5361 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5362 PyObject *arg2 = (PyObject *) 0 ;
5363 bool result;
5364 void *argp1 = 0 ;
5365 int res1 = 0 ;
5366 PyObject * obj0 = 0 ;
5367 PyObject * obj1 = 0 ;
5368 char * kwnames[] = {
5369 (char *) "self",(char *) "other", NULL
5370 };
5371
5372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5374 if (!SWIG_IsOK(res1)) {
5375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5376 }
5377 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5378 arg2 = obj1;
5379 {
5380 result = (bool)wxRealPoint___eq__(arg1,arg2);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 {
5384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5385 }
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5393 PyObject *resultobj = 0;
5394 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5395 PyObject *arg2 = (PyObject *) 0 ;
5396 bool result;
5397 void *argp1 = 0 ;
5398 int res1 = 0 ;
5399 PyObject * obj0 = 0 ;
5400 PyObject * obj1 = 0 ;
5401 char * kwnames[] = {
5402 (char *) "self",(char *) "other", NULL
5403 };
5404
5405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5407 if (!SWIG_IsOK(res1)) {
5408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5409 }
5410 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5411 arg2 = obj1;
5412 {
5413 result = (bool)wxRealPoint___ne__(arg1,arg2);
5414 if (PyErr_Occurred()) SWIG_fail;
5415 }
5416 {
5417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5418 }
5419 return resultobj;
5420 fail:
5421 return NULL;
5422 }
5423
5424
5425 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5426 PyObject *resultobj = 0;
5427 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5428 wxRealPoint *arg2 = 0 ;
5429 wxRealPoint result;
5430 void *argp1 = 0 ;
5431 int res1 = 0 ;
5432 wxRealPoint temp2 ;
5433 PyObject * obj0 = 0 ;
5434 PyObject * obj1 = 0 ;
5435 char * kwnames[] = {
5436 (char *) "self",(char *) "pt", NULL
5437 };
5438
5439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5441 if (!SWIG_IsOK(res1)) {
5442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5443 }
5444 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5445 {
5446 arg2 = &temp2;
5447 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5448 }
5449 {
5450 PyThreadState* __tstate = wxPyBeginAllowThreads();
5451 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5452 wxPyEndAllowThreads(__tstate);
5453 if (PyErr_Occurred()) SWIG_fail;
5454 }
5455 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5456 return resultobj;
5457 fail:
5458 return NULL;
5459 }
5460
5461
5462 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5463 PyObject *resultobj = 0;
5464 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5465 wxRealPoint *arg2 = 0 ;
5466 wxRealPoint result;
5467 void *argp1 = 0 ;
5468 int res1 = 0 ;
5469 wxRealPoint temp2 ;
5470 PyObject * obj0 = 0 ;
5471 PyObject * obj1 = 0 ;
5472 char * kwnames[] = {
5473 (char *) "self",(char *) "pt", NULL
5474 };
5475
5476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5478 if (!SWIG_IsOK(res1)) {
5479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5480 }
5481 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5482 {
5483 arg2 = &temp2;
5484 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5485 }
5486 {
5487 PyThreadState* __tstate = wxPyBeginAllowThreads();
5488 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5489 wxPyEndAllowThreads(__tstate);
5490 if (PyErr_Occurred()) SWIG_fail;
5491 }
5492 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5493 return resultobj;
5494 fail:
5495 return NULL;
5496 }
5497
5498
5499 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5500 PyObject *resultobj = 0;
5501 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5502 double arg2 ;
5503 double arg3 ;
5504 void *argp1 = 0 ;
5505 int res1 = 0 ;
5506 double val2 ;
5507 int ecode2 = 0 ;
5508 double val3 ;
5509 int ecode3 = 0 ;
5510 PyObject * obj0 = 0 ;
5511 PyObject * obj1 = 0 ;
5512 PyObject * obj2 = 0 ;
5513 char * kwnames[] = {
5514 (char *) "self",(char *) "x",(char *) "y", NULL
5515 };
5516
5517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5519 if (!SWIG_IsOK(res1)) {
5520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5521 }
5522 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5523 ecode2 = SWIG_AsVal_double(obj1, &val2);
5524 if (!SWIG_IsOK(ecode2)) {
5525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5526 }
5527 arg2 = static_cast< double >(val2);
5528 ecode3 = SWIG_AsVal_double(obj2, &val3);
5529 if (!SWIG_IsOK(ecode3)) {
5530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5531 }
5532 arg3 = static_cast< double >(val3);
5533 {
5534 PyThreadState* __tstate = wxPyBeginAllowThreads();
5535 wxRealPoint_Set(arg1,arg2,arg3);
5536 wxPyEndAllowThreads(__tstate);
5537 if (PyErr_Occurred()) SWIG_fail;
5538 }
5539 resultobj = SWIG_Py_Void();
5540 return resultobj;
5541 fail:
5542 return NULL;
5543 }
5544
5545
5546 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5547 PyObject *resultobj = 0;
5548 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5549 PyObject *result = 0 ;
5550 void *argp1 = 0 ;
5551 int res1 = 0 ;
5552 PyObject *swig_obj[1] ;
5553
5554 if (!args) SWIG_fail;
5555 swig_obj[0] = args;
5556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5557 if (!SWIG_IsOK(res1)) {
5558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5559 }
5560 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5561 {
5562 PyThreadState* __tstate = wxPyBeginAllowThreads();
5563 result = (PyObject *)wxRealPoint_Get(arg1);
5564 wxPyEndAllowThreads(__tstate);
5565 if (PyErr_Occurred()) SWIG_fail;
5566 }
5567 resultobj = result;
5568 return resultobj;
5569 fail:
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575 PyObject *obj;
5576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5577 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5578 return SWIG_Py_Void();
5579 }
5580
5581 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5582 return SWIG_Python_InitShadowInstance(args);
5583 }
5584
5585 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5586 PyObject *resultobj = 0;
5587 wxPoint *arg1 = (wxPoint *) 0 ;
5588 int arg2 ;
5589 void *argp1 = 0 ;
5590 int res1 = 0 ;
5591 int val2 ;
5592 int ecode2 = 0 ;
5593 PyObject *swig_obj[2] ;
5594
5595 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5597 if (!SWIG_IsOK(res1)) {
5598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5599 }
5600 arg1 = reinterpret_cast< wxPoint * >(argp1);
5601 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5602 if (!SWIG_IsOK(ecode2)) {
5603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5604 }
5605 arg2 = static_cast< int >(val2);
5606 if (arg1) (arg1)->x = arg2;
5607
5608 resultobj = SWIG_Py_Void();
5609 return resultobj;
5610 fail:
5611 return NULL;
5612 }
5613
5614
5615 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5616 PyObject *resultobj = 0;
5617 wxPoint *arg1 = (wxPoint *) 0 ;
5618 int result;
5619 void *argp1 = 0 ;
5620 int res1 = 0 ;
5621 PyObject *swig_obj[1] ;
5622
5623 if (!args) SWIG_fail;
5624 swig_obj[0] = args;
5625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5626 if (!SWIG_IsOK(res1)) {
5627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5628 }
5629 arg1 = reinterpret_cast< wxPoint * >(argp1);
5630 result = (int) ((arg1)->x);
5631 resultobj = SWIG_From_int(static_cast< int >(result));
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5639 PyObject *resultobj = 0;
5640 wxPoint *arg1 = (wxPoint *) 0 ;
5641 int arg2 ;
5642 void *argp1 = 0 ;
5643 int res1 = 0 ;
5644 int val2 ;
5645 int ecode2 = 0 ;
5646 PyObject *swig_obj[2] ;
5647
5648 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5650 if (!SWIG_IsOK(res1)) {
5651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5652 }
5653 arg1 = reinterpret_cast< wxPoint * >(argp1);
5654 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5655 if (!SWIG_IsOK(ecode2)) {
5656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5657 }
5658 arg2 = static_cast< int >(val2);
5659 if (arg1) (arg1)->y = arg2;
5660
5661 resultobj = SWIG_Py_Void();
5662 return resultobj;
5663 fail:
5664 return NULL;
5665 }
5666
5667
5668 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5669 PyObject *resultobj = 0;
5670 wxPoint *arg1 = (wxPoint *) 0 ;
5671 int result;
5672 void *argp1 = 0 ;
5673 int res1 = 0 ;
5674 PyObject *swig_obj[1] ;
5675
5676 if (!args) SWIG_fail;
5677 swig_obj[0] = args;
5678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5679 if (!SWIG_IsOK(res1)) {
5680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5681 }
5682 arg1 = reinterpret_cast< wxPoint * >(argp1);
5683 result = (int) ((arg1)->y);
5684 resultobj = SWIG_From_int(static_cast< int >(result));
5685 return resultobj;
5686 fail:
5687 return NULL;
5688 }
5689
5690
5691 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5692 PyObject *resultobj = 0;
5693 int arg1 = (int) 0 ;
5694 int arg2 = (int) 0 ;
5695 wxPoint *result = 0 ;
5696 int val1 ;
5697 int ecode1 = 0 ;
5698 int val2 ;
5699 int ecode2 = 0 ;
5700 PyObject * obj0 = 0 ;
5701 PyObject * obj1 = 0 ;
5702 char * kwnames[] = {
5703 (char *) "x",(char *) "y", NULL
5704 };
5705
5706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5707 if (obj0) {
5708 ecode1 = SWIG_AsVal_int(obj0, &val1);
5709 if (!SWIG_IsOK(ecode1)) {
5710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5711 }
5712 arg1 = static_cast< int >(val1);
5713 }
5714 if (obj1) {
5715 ecode2 = SWIG_AsVal_int(obj1, &val2);
5716 if (!SWIG_IsOK(ecode2)) {
5717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5718 }
5719 arg2 = static_cast< int >(val2);
5720 }
5721 {
5722 PyThreadState* __tstate = wxPyBeginAllowThreads();
5723 result = (wxPoint *)new wxPoint(arg1,arg2);
5724 wxPyEndAllowThreads(__tstate);
5725 if (PyErr_Occurred()) SWIG_fail;
5726 }
5727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5728 return resultobj;
5729 fail:
5730 return NULL;
5731 }
5732
5733
5734 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5735 PyObject *resultobj = 0;
5736 wxPoint *arg1 = (wxPoint *) 0 ;
5737 void *argp1 = 0 ;
5738 int res1 = 0 ;
5739 PyObject *swig_obj[1] ;
5740
5741 if (!args) SWIG_fail;
5742 swig_obj[0] = args;
5743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5744 if (!SWIG_IsOK(res1)) {
5745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5746 }
5747 arg1 = reinterpret_cast< wxPoint * >(argp1);
5748 {
5749 PyThreadState* __tstate = wxPyBeginAllowThreads();
5750 delete arg1;
5751
5752 wxPyEndAllowThreads(__tstate);
5753 if (PyErr_Occurred()) SWIG_fail;
5754 }
5755 resultobj = SWIG_Py_Void();
5756 return resultobj;
5757 fail:
5758 return NULL;
5759 }
5760
5761
5762 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5763 PyObject *resultobj = 0;
5764 wxPoint *arg1 = (wxPoint *) 0 ;
5765 PyObject *arg2 = (PyObject *) 0 ;
5766 bool result;
5767 void *argp1 = 0 ;
5768 int res1 = 0 ;
5769 PyObject * obj0 = 0 ;
5770 PyObject * obj1 = 0 ;
5771 char * kwnames[] = {
5772 (char *) "self",(char *) "other", NULL
5773 };
5774
5775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5777 if (!SWIG_IsOK(res1)) {
5778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5779 }
5780 arg1 = reinterpret_cast< wxPoint * >(argp1);
5781 arg2 = obj1;
5782 {
5783 result = (bool)wxPoint___eq__(arg1,arg2);
5784 if (PyErr_Occurred()) SWIG_fail;
5785 }
5786 {
5787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5788 }
5789 return resultobj;
5790 fail:
5791 return NULL;
5792 }
5793
5794
5795 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5796 PyObject *resultobj = 0;
5797 wxPoint *arg1 = (wxPoint *) 0 ;
5798 PyObject *arg2 = (PyObject *) 0 ;
5799 bool result;
5800 void *argp1 = 0 ;
5801 int res1 = 0 ;
5802 PyObject * obj0 = 0 ;
5803 PyObject * obj1 = 0 ;
5804 char * kwnames[] = {
5805 (char *) "self",(char *) "other", NULL
5806 };
5807
5808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5810 if (!SWIG_IsOK(res1)) {
5811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5812 }
5813 arg1 = reinterpret_cast< wxPoint * >(argp1);
5814 arg2 = obj1;
5815 {
5816 result = (bool)wxPoint___ne__(arg1,arg2);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 {
5820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5821 }
5822 return resultobj;
5823 fail:
5824 return NULL;
5825 }
5826
5827
5828 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5829 PyObject *resultobj = 0;
5830 wxPoint *arg1 = (wxPoint *) 0 ;
5831 wxPoint *arg2 = 0 ;
5832 wxPoint result;
5833 void *argp1 = 0 ;
5834 int res1 = 0 ;
5835 wxPoint temp2 ;
5836 PyObject * obj0 = 0 ;
5837 PyObject * obj1 = 0 ;
5838 char * kwnames[] = {
5839 (char *) "self",(char *) "pt", NULL
5840 };
5841
5842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5844 if (!SWIG_IsOK(res1)) {
5845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5846 }
5847 arg1 = reinterpret_cast< wxPoint * >(argp1);
5848 {
5849 arg2 = &temp2;
5850 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5851 }
5852 {
5853 PyThreadState* __tstate = wxPyBeginAllowThreads();
5854 result = (arg1)->operator +((wxPoint const &)*arg2);
5855 wxPyEndAllowThreads(__tstate);
5856 if (PyErr_Occurred()) SWIG_fail;
5857 }
5858 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj = 0;
5867 wxPoint *arg1 = (wxPoint *) 0 ;
5868 wxPoint *arg2 = 0 ;
5869 wxPoint result;
5870 void *argp1 = 0 ;
5871 int res1 = 0 ;
5872 wxPoint temp2 ;
5873 PyObject * obj0 = 0 ;
5874 PyObject * obj1 = 0 ;
5875 char * kwnames[] = {
5876 (char *) "self",(char *) "pt", NULL
5877 };
5878
5879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5881 if (!SWIG_IsOK(res1)) {
5882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5883 }
5884 arg1 = reinterpret_cast< wxPoint * >(argp1);
5885 {
5886 arg2 = &temp2;
5887 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5888 }
5889 {
5890 PyThreadState* __tstate = wxPyBeginAllowThreads();
5891 result = (arg1)->operator -((wxPoint const &)*arg2);
5892 wxPyEndAllowThreads(__tstate);
5893 if (PyErr_Occurred()) SWIG_fail;
5894 }
5895 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5896 return resultobj;
5897 fail:
5898 return NULL;
5899 }
5900
5901
5902 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5903 PyObject *resultobj = 0;
5904 wxPoint *arg1 = (wxPoint *) 0 ;
5905 wxPoint *arg2 = 0 ;
5906 wxPoint *result = 0 ;
5907 void *argp1 = 0 ;
5908 int res1 = 0 ;
5909 wxPoint temp2 ;
5910 PyObject * obj0 = 0 ;
5911 PyObject * obj1 = 0 ;
5912 char * kwnames[] = {
5913 (char *) "self",(char *) "pt", NULL
5914 };
5915
5916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5918 if (!SWIG_IsOK(res1)) {
5919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5920 }
5921 arg1 = reinterpret_cast< wxPoint * >(argp1);
5922 {
5923 arg2 = &temp2;
5924 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5925 }
5926 {
5927 PyThreadState* __tstate = wxPyBeginAllowThreads();
5928 {
5929 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5930 result = (wxPoint *) &_result_ref;
5931 }
5932 wxPyEndAllowThreads(__tstate);
5933 if (PyErr_Occurred()) SWIG_fail;
5934 }
5935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5936 return resultobj;
5937 fail:
5938 return NULL;
5939 }
5940
5941
5942 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5943 PyObject *resultobj = 0;
5944 wxPoint *arg1 = (wxPoint *) 0 ;
5945 wxPoint *arg2 = 0 ;
5946 wxPoint *result = 0 ;
5947 void *argp1 = 0 ;
5948 int res1 = 0 ;
5949 wxPoint temp2 ;
5950 PyObject * obj0 = 0 ;
5951 PyObject * obj1 = 0 ;
5952 char * kwnames[] = {
5953 (char *) "self",(char *) "pt", NULL
5954 };
5955
5956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5958 if (!SWIG_IsOK(res1)) {
5959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5960 }
5961 arg1 = reinterpret_cast< wxPoint * >(argp1);
5962 {
5963 arg2 = &temp2;
5964 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5965 }
5966 {
5967 PyThreadState* __tstate = wxPyBeginAllowThreads();
5968 {
5969 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5970 result = (wxPoint *) &_result_ref;
5971 }
5972 wxPyEndAllowThreads(__tstate);
5973 if (PyErr_Occurred()) SWIG_fail;
5974 }
5975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5976 return resultobj;
5977 fail:
5978 return NULL;
5979 }
5980
5981
5982 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5983 PyObject *resultobj = 0;
5984 wxPoint *arg1 = (wxPoint *) 0 ;
5985 long arg2 ;
5986 long arg3 ;
5987 void *argp1 = 0 ;
5988 int res1 = 0 ;
5989 long val2 ;
5990 int ecode2 = 0 ;
5991 long val3 ;
5992 int ecode3 = 0 ;
5993 PyObject * obj0 = 0 ;
5994 PyObject * obj1 = 0 ;
5995 PyObject * obj2 = 0 ;
5996 char * kwnames[] = {
5997 (char *) "self",(char *) "x",(char *) "y", NULL
5998 };
5999
6000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6002 if (!SWIG_IsOK(res1)) {
6003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6004 }
6005 arg1 = reinterpret_cast< wxPoint * >(argp1);
6006 ecode2 = SWIG_AsVal_long(obj1, &val2);
6007 if (!SWIG_IsOK(ecode2)) {
6008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6009 }
6010 arg2 = static_cast< long >(val2);
6011 ecode3 = SWIG_AsVal_long(obj2, &val3);
6012 if (!SWIG_IsOK(ecode3)) {
6013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6014 }
6015 arg3 = static_cast< long >(val3);
6016 {
6017 PyThreadState* __tstate = wxPyBeginAllowThreads();
6018 wxPoint_Set(arg1,arg2,arg3);
6019 wxPyEndAllowThreads(__tstate);
6020 if (PyErr_Occurred()) SWIG_fail;
6021 }
6022 resultobj = SWIG_Py_Void();
6023 return resultobj;
6024 fail:
6025 return NULL;
6026 }
6027
6028
6029 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6030 PyObject *resultobj = 0;
6031 wxPoint *arg1 = (wxPoint *) 0 ;
6032 PyObject *result = 0 ;
6033 void *argp1 = 0 ;
6034 int res1 = 0 ;
6035 PyObject *swig_obj[1] ;
6036
6037 if (!args) SWIG_fail;
6038 swig_obj[0] = args;
6039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6040 if (!SWIG_IsOK(res1)) {
6041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6042 }
6043 arg1 = reinterpret_cast< wxPoint * >(argp1);
6044 {
6045 PyThreadState* __tstate = wxPyBeginAllowThreads();
6046 result = (PyObject *)wxPoint_Get(arg1);
6047 wxPyEndAllowThreads(__tstate);
6048 if (PyErr_Occurred()) SWIG_fail;
6049 }
6050 resultobj = result;
6051 return resultobj;
6052 fail:
6053 return NULL;
6054 }
6055
6056
6057 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6058 PyObject *obj;
6059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6060 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6061 return SWIG_Py_Void();
6062 }
6063
6064 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6065 return SWIG_Python_InitShadowInstance(args);
6066 }
6067
6068 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6069 PyObject *resultobj = 0;
6070 int arg1 = (int) 0 ;
6071 int arg2 = (int) 0 ;
6072 int arg3 = (int) 0 ;
6073 int arg4 = (int) 0 ;
6074 wxRect *result = 0 ;
6075 int val1 ;
6076 int ecode1 = 0 ;
6077 int val2 ;
6078 int ecode2 = 0 ;
6079 int val3 ;
6080 int ecode3 = 0 ;
6081 int val4 ;
6082 int ecode4 = 0 ;
6083 PyObject * obj0 = 0 ;
6084 PyObject * obj1 = 0 ;
6085 PyObject * obj2 = 0 ;
6086 PyObject * obj3 = 0 ;
6087 char * kwnames[] = {
6088 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6089 };
6090
6091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6092 if (obj0) {
6093 ecode1 = SWIG_AsVal_int(obj0, &val1);
6094 if (!SWIG_IsOK(ecode1)) {
6095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6096 }
6097 arg1 = static_cast< int >(val1);
6098 }
6099 if (obj1) {
6100 ecode2 = SWIG_AsVal_int(obj1, &val2);
6101 if (!SWIG_IsOK(ecode2)) {
6102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6103 }
6104 arg2 = static_cast< int >(val2);
6105 }
6106 if (obj2) {
6107 ecode3 = SWIG_AsVal_int(obj2, &val3);
6108 if (!SWIG_IsOK(ecode3)) {
6109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6110 }
6111 arg3 = static_cast< int >(val3);
6112 }
6113 if (obj3) {
6114 ecode4 = SWIG_AsVal_int(obj3, &val4);
6115 if (!SWIG_IsOK(ecode4)) {
6116 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6117 }
6118 arg4 = static_cast< int >(val4);
6119 }
6120 {
6121 PyThreadState* __tstate = wxPyBeginAllowThreads();
6122 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6123 wxPyEndAllowThreads(__tstate);
6124 if (PyErr_Occurred()) SWIG_fail;
6125 }
6126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6127 return resultobj;
6128 fail:
6129 return NULL;
6130 }
6131
6132
6133 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6134 PyObject *resultobj = 0;
6135 wxPoint *arg1 = 0 ;
6136 wxPoint *arg2 = 0 ;
6137 wxRect *result = 0 ;
6138 wxPoint temp1 ;
6139 wxPoint temp2 ;
6140 PyObject * obj0 = 0 ;
6141 PyObject * obj1 = 0 ;
6142 char * kwnames[] = {
6143 (char *) "topLeft",(char *) "bottomRight", NULL
6144 };
6145
6146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6147 {
6148 arg1 = &temp1;
6149 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6150 }
6151 {
6152 arg2 = &temp2;
6153 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6154 }
6155 {
6156 PyThreadState* __tstate = wxPyBeginAllowThreads();
6157 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6158 wxPyEndAllowThreads(__tstate);
6159 if (PyErr_Occurred()) SWIG_fail;
6160 }
6161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6162 return resultobj;
6163 fail:
6164 return NULL;
6165 }
6166
6167
6168 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj = 0;
6170 wxPoint *arg1 = 0 ;
6171 wxSize *arg2 = 0 ;
6172 wxRect *result = 0 ;
6173 wxPoint temp1 ;
6174 wxSize temp2 ;
6175 PyObject * obj0 = 0 ;
6176 PyObject * obj1 = 0 ;
6177 char * kwnames[] = {
6178 (char *) "pos",(char *) "size", NULL
6179 };
6180
6181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6182 {
6183 arg1 = &temp1;
6184 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6185 }
6186 {
6187 arg2 = &temp2;
6188 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6189 }
6190 {
6191 PyThreadState* __tstate = wxPyBeginAllowThreads();
6192 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6193 wxPyEndAllowThreads(__tstate);
6194 if (PyErr_Occurred()) SWIG_fail;
6195 }
6196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6197 return resultobj;
6198 fail:
6199 return NULL;
6200 }
6201
6202
6203 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj = 0;
6205 wxSize *arg1 = 0 ;
6206 wxRect *result = 0 ;
6207 wxSize temp1 ;
6208 PyObject * obj0 = 0 ;
6209 char * kwnames[] = {
6210 (char *) "size", NULL
6211 };
6212
6213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6214 {
6215 arg1 = &temp1;
6216 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6217 }
6218 {
6219 PyThreadState* __tstate = wxPyBeginAllowThreads();
6220 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6221 wxPyEndAllowThreads(__tstate);
6222 if (PyErr_Occurred()) SWIG_fail;
6223 }
6224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6225 return resultobj;
6226 fail:
6227 return NULL;
6228 }
6229
6230
6231 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6232 PyObject *resultobj = 0;
6233 wxRect *arg1 = (wxRect *) 0 ;
6234 void *argp1 = 0 ;
6235 int res1 = 0 ;
6236 PyObject *swig_obj[1] ;
6237
6238 if (!args) SWIG_fail;
6239 swig_obj[0] = args;
6240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6241 if (!SWIG_IsOK(res1)) {
6242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6243 }
6244 arg1 = reinterpret_cast< wxRect * >(argp1);
6245 {
6246 PyThreadState* __tstate = wxPyBeginAllowThreads();
6247 delete arg1;
6248
6249 wxPyEndAllowThreads(__tstate);
6250 if (PyErr_Occurred()) SWIG_fail;
6251 }
6252 resultobj = SWIG_Py_Void();
6253 return resultobj;
6254 fail:
6255 return NULL;
6256 }
6257
6258
6259 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6260 PyObject *resultobj = 0;
6261 wxRect *arg1 = (wxRect *) 0 ;
6262 int result;
6263 void *argp1 = 0 ;
6264 int res1 = 0 ;
6265 PyObject *swig_obj[1] ;
6266
6267 if (!args) SWIG_fail;
6268 swig_obj[0] = args;
6269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6270 if (!SWIG_IsOK(res1)) {
6271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6272 }
6273 arg1 = reinterpret_cast< wxRect * >(argp1);
6274 {
6275 PyThreadState* __tstate = wxPyBeginAllowThreads();
6276 result = (int)((wxRect const *)arg1)->GetX();
6277 wxPyEndAllowThreads(__tstate);
6278 if (PyErr_Occurred()) SWIG_fail;
6279 }
6280 resultobj = SWIG_From_int(static_cast< int >(result));
6281 return resultobj;
6282 fail:
6283 return NULL;
6284 }
6285
6286
6287 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6288 PyObject *resultobj = 0;
6289 wxRect *arg1 = (wxRect *) 0 ;
6290 int arg2 ;
6291 void *argp1 = 0 ;
6292 int res1 = 0 ;
6293 int val2 ;
6294 int ecode2 = 0 ;
6295 PyObject * obj0 = 0 ;
6296 PyObject * obj1 = 0 ;
6297 char * kwnames[] = {
6298 (char *) "self",(char *) "x", NULL
6299 };
6300
6301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6303 if (!SWIG_IsOK(res1)) {
6304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6305 }
6306 arg1 = reinterpret_cast< wxRect * >(argp1);
6307 ecode2 = SWIG_AsVal_int(obj1, &val2);
6308 if (!SWIG_IsOK(ecode2)) {
6309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6310 }
6311 arg2 = static_cast< int >(val2);
6312 {
6313 PyThreadState* __tstate = wxPyBeginAllowThreads();
6314 (arg1)->SetX(arg2);
6315 wxPyEndAllowThreads(__tstate);
6316 if (PyErr_Occurred()) SWIG_fail;
6317 }
6318 resultobj = SWIG_Py_Void();
6319 return resultobj;
6320 fail:
6321 return NULL;
6322 }
6323
6324
6325 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6326 PyObject *resultobj = 0;
6327 wxRect *arg1 = (wxRect *) 0 ;
6328 int result;
6329 void *argp1 = 0 ;
6330 int res1 = 0 ;
6331 PyObject *swig_obj[1] ;
6332
6333 if (!args) SWIG_fail;
6334 swig_obj[0] = args;
6335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6336 if (!SWIG_IsOK(res1)) {
6337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6338 }
6339 arg1 = reinterpret_cast< wxRect * >(argp1);
6340 {
6341 PyThreadState* __tstate = wxPyBeginAllowThreads();
6342 result = (int)(arg1)->GetY();
6343 wxPyEndAllowThreads(__tstate);
6344 if (PyErr_Occurred()) SWIG_fail;
6345 }
6346 resultobj = SWIG_From_int(static_cast< int >(result));
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj = 0;
6355 wxRect *arg1 = (wxRect *) 0 ;
6356 int arg2 ;
6357 void *argp1 = 0 ;
6358 int res1 = 0 ;
6359 int val2 ;
6360 int ecode2 = 0 ;
6361 PyObject * obj0 = 0 ;
6362 PyObject * obj1 = 0 ;
6363 char * kwnames[] = {
6364 (char *) "self",(char *) "y", NULL
6365 };
6366
6367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6369 if (!SWIG_IsOK(res1)) {
6370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6371 }
6372 arg1 = reinterpret_cast< wxRect * >(argp1);
6373 ecode2 = SWIG_AsVal_int(obj1, &val2);
6374 if (!SWIG_IsOK(ecode2)) {
6375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6376 }
6377 arg2 = static_cast< int >(val2);
6378 {
6379 PyThreadState* __tstate = wxPyBeginAllowThreads();
6380 (arg1)->SetY(arg2);
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 resultobj = SWIG_Py_Void();
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6392 PyObject *resultobj = 0;
6393 wxRect *arg1 = (wxRect *) 0 ;
6394 int result;
6395 void *argp1 = 0 ;
6396 int res1 = 0 ;
6397 PyObject *swig_obj[1] ;
6398
6399 if (!args) SWIG_fail;
6400 swig_obj[0] = args;
6401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6402 if (!SWIG_IsOK(res1)) {
6403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6404 }
6405 arg1 = reinterpret_cast< wxRect * >(argp1);
6406 {
6407 PyThreadState* __tstate = wxPyBeginAllowThreads();
6408 result = (int)((wxRect const *)arg1)->GetWidth();
6409 wxPyEndAllowThreads(__tstate);
6410 if (PyErr_Occurred()) SWIG_fail;
6411 }
6412 resultobj = SWIG_From_int(static_cast< int >(result));
6413 return resultobj;
6414 fail:
6415 return NULL;
6416 }
6417
6418
6419 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6420 PyObject *resultobj = 0;
6421 wxRect *arg1 = (wxRect *) 0 ;
6422 int arg2 ;
6423 void *argp1 = 0 ;
6424 int res1 = 0 ;
6425 int val2 ;
6426 int ecode2 = 0 ;
6427 PyObject * obj0 = 0 ;
6428 PyObject * obj1 = 0 ;
6429 char * kwnames[] = {
6430 (char *) "self",(char *) "w", NULL
6431 };
6432
6433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6435 if (!SWIG_IsOK(res1)) {
6436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6437 }
6438 arg1 = reinterpret_cast< wxRect * >(argp1);
6439 ecode2 = SWIG_AsVal_int(obj1, &val2);
6440 if (!SWIG_IsOK(ecode2)) {
6441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6442 }
6443 arg2 = static_cast< int >(val2);
6444 {
6445 PyThreadState* __tstate = wxPyBeginAllowThreads();
6446 (arg1)->SetWidth(arg2);
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 resultobj = SWIG_Py_Void();
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6458 PyObject *resultobj = 0;
6459 wxRect *arg1 = (wxRect *) 0 ;
6460 int result;
6461 void *argp1 = 0 ;
6462 int res1 = 0 ;
6463 PyObject *swig_obj[1] ;
6464
6465 if (!args) SWIG_fail;
6466 swig_obj[0] = args;
6467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6468 if (!SWIG_IsOK(res1)) {
6469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6470 }
6471 arg1 = reinterpret_cast< wxRect * >(argp1);
6472 {
6473 PyThreadState* __tstate = wxPyBeginAllowThreads();
6474 result = (int)((wxRect const *)arg1)->GetHeight();
6475 wxPyEndAllowThreads(__tstate);
6476 if (PyErr_Occurred()) SWIG_fail;
6477 }
6478 resultobj = SWIG_From_int(static_cast< int >(result));
6479 return resultobj;
6480 fail:
6481 return NULL;
6482 }
6483
6484
6485 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6486 PyObject *resultobj = 0;
6487 wxRect *arg1 = (wxRect *) 0 ;
6488 int arg2 ;
6489 void *argp1 = 0 ;
6490 int res1 = 0 ;
6491 int val2 ;
6492 int ecode2 = 0 ;
6493 PyObject * obj0 = 0 ;
6494 PyObject * obj1 = 0 ;
6495 char * kwnames[] = {
6496 (char *) "self",(char *) "h", NULL
6497 };
6498
6499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6501 if (!SWIG_IsOK(res1)) {
6502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6503 }
6504 arg1 = reinterpret_cast< wxRect * >(argp1);
6505 ecode2 = SWIG_AsVal_int(obj1, &val2);
6506 if (!SWIG_IsOK(ecode2)) {
6507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6508 }
6509 arg2 = static_cast< int >(val2);
6510 {
6511 PyThreadState* __tstate = wxPyBeginAllowThreads();
6512 (arg1)->SetHeight(arg2);
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 resultobj = SWIG_Py_Void();
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6524 PyObject *resultobj = 0;
6525 wxRect *arg1 = (wxRect *) 0 ;
6526 wxPoint result;
6527 void *argp1 = 0 ;
6528 int res1 = 0 ;
6529 PyObject *swig_obj[1] ;
6530
6531 if (!args) SWIG_fail;
6532 swig_obj[0] = args;
6533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 {
6539 PyThreadState* __tstate = wxPyBeginAllowThreads();
6540 result = ((wxRect const *)arg1)->GetPosition();
6541 wxPyEndAllowThreads(__tstate);
6542 if (PyErr_Occurred()) SWIG_fail;
6543 }
6544 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6545 return resultobj;
6546 fail:
6547 return NULL;
6548 }
6549
6550
6551 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6552 PyObject *resultobj = 0;
6553 wxRect *arg1 = (wxRect *) 0 ;
6554 wxPoint *arg2 = 0 ;
6555 void *argp1 = 0 ;
6556 int res1 = 0 ;
6557 wxPoint temp2 ;
6558 PyObject * obj0 = 0 ;
6559 PyObject * obj1 = 0 ;
6560 char * kwnames[] = {
6561 (char *) "self",(char *) "p", NULL
6562 };
6563
6564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6566 if (!SWIG_IsOK(res1)) {
6567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6568 }
6569 arg1 = reinterpret_cast< wxRect * >(argp1);
6570 {
6571 arg2 = &temp2;
6572 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6573 }
6574 {
6575 PyThreadState* __tstate = wxPyBeginAllowThreads();
6576 (arg1)->SetPosition((wxPoint const &)*arg2);
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 resultobj = SWIG_Py_Void();
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6588 PyObject *resultobj = 0;
6589 wxRect *arg1 = (wxRect *) 0 ;
6590 wxSize result;
6591 void *argp1 = 0 ;
6592 int res1 = 0 ;
6593 PyObject *swig_obj[1] ;
6594
6595 if (!args) SWIG_fail;
6596 swig_obj[0] = args;
6597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6598 if (!SWIG_IsOK(res1)) {
6599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6600 }
6601 arg1 = reinterpret_cast< wxRect * >(argp1);
6602 {
6603 PyThreadState* __tstate = wxPyBeginAllowThreads();
6604 result = ((wxRect const *)arg1)->GetSize();
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6609 return resultobj;
6610 fail:
6611 return NULL;
6612 }
6613
6614
6615 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6616 PyObject *resultobj = 0;
6617 wxRect *arg1 = (wxRect *) 0 ;
6618 wxSize *arg2 = 0 ;
6619 void *argp1 = 0 ;
6620 int res1 = 0 ;
6621 wxSize temp2 ;
6622 PyObject * obj0 = 0 ;
6623 PyObject * obj1 = 0 ;
6624 char * kwnames[] = {
6625 (char *) "self",(char *) "s", NULL
6626 };
6627
6628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6630 if (!SWIG_IsOK(res1)) {
6631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6632 }
6633 arg1 = reinterpret_cast< wxRect * >(argp1);
6634 {
6635 arg2 = &temp2;
6636 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6637 }
6638 {
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 (arg1)->SetSize((wxSize const &)*arg2);
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 resultobj = SWIG_Py_Void();
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6652 PyObject *resultobj = 0;
6653 wxRect *arg1 = (wxRect *) 0 ;
6654 bool result;
6655 void *argp1 = 0 ;
6656 int res1 = 0 ;
6657 PyObject *swig_obj[1] ;
6658
6659 if (!args) SWIG_fail;
6660 swig_obj[0] = args;
6661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6662 if (!SWIG_IsOK(res1)) {
6663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6664 }
6665 arg1 = reinterpret_cast< wxRect * >(argp1);
6666 {
6667 PyThreadState* __tstate = wxPyBeginAllowThreads();
6668 result = (bool)((wxRect const *)arg1)->IsEmpty();
6669 wxPyEndAllowThreads(__tstate);
6670 if (PyErr_Occurred()) SWIG_fail;
6671 }
6672 {
6673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6674 }
6675 return resultobj;
6676 fail:
6677 return NULL;
6678 }
6679
6680
6681 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6682 PyObject *resultobj = 0;
6683 wxRect *arg1 = (wxRect *) 0 ;
6684 wxPoint result;
6685 void *argp1 = 0 ;
6686 int res1 = 0 ;
6687 PyObject *swig_obj[1] ;
6688
6689 if (!args) SWIG_fail;
6690 swig_obj[0] = args;
6691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6692 if (!SWIG_IsOK(res1)) {
6693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6694 }
6695 arg1 = reinterpret_cast< wxRect * >(argp1);
6696 {
6697 PyThreadState* __tstate = wxPyBeginAllowThreads();
6698 result = ((wxRect const *)arg1)->GetTopLeft();
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6710 PyObject *resultobj = 0;
6711 wxRect *arg1 = (wxRect *) 0 ;
6712 wxPoint *arg2 = 0 ;
6713 void *argp1 = 0 ;
6714 int res1 = 0 ;
6715 wxPoint temp2 ;
6716 PyObject * obj0 = 0 ;
6717 PyObject * obj1 = 0 ;
6718 char * kwnames[] = {
6719 (char *) "self",(char *) "p", NULL
6720 };
6721
6722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6724 if (!SWIG_IsOK(res1)) {
6725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6726 }
6727 arg1 = reinterpret_cast< wxRect * >(argp1);
6728 {
6729 arg2 = &temp2;
6730 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6731 }
6732 {
6733 PyThreadState* __tstate = wxPyBeginAllowThreads();
6734 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6735 wxPyEndAllowThreads(__tstate);
6736 if (PyErr_Occurred()) SWIG_fail;
6737 }
6738 resultobj = SWIG_Py_Void();
6739 return resultobj;
6740 fail:
6741 return NULL;
6742 }
6743
6744
6745 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6746 PyObject *resultobj = 0;
6747 wxRect *arg1 = (wxRect *) 0 ;
6748 wxPoint result;
6749 void *argp1 = 0 ;
6750 int res1 = 0 ;
6751 PyObject *swig_obj[1] ;
6752
6753 if (!args) SWIG_fail;
6754 swig_obj[0] = args;
6755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6756 if (!SWIG_IsOK(res1)) {
6757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6758 }
6759 arg1 = reinterpret_cast< wxRect * >(argp1);
6760 {
6761 PyThreadState* __tstate = wxPyBeginAllowThreads();
6762 result = ((wxRect const *)arg1)->GetBottomRight();
6763 wxPyEndAllowThreads(__tstate);
6764 if (PyErr_Occurred()) SWIG_fail;
6765 }
6766 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6767 return resultobj;
6768 fail:
6769 return NULL;
6770 }
6771
6772
6773 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6774 PyObject *resultobj = 0;
6775 wxRect *arg1 = (wxRect *) 0 ;
6776 wxPoint *arg2 = 0 ;
6777 void *argp1 = 0 ;
6778 int res1 = 0 ;
6779 wxPoint temp2 ;
6780 PyObject * obj0 = 0 ;
6781 PyObject * obj1 = 0 ;
6782 char * kwnames[] = {
6783 (char *) "self",(char *) "p", NULL
6784 };
6785
6786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6788 if (!SWIG_IsOK(res1)) {
6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6790 }
6791 arg1 = reinterpret_cast< wxRect * >(argp1);
6792 {
6793 arg2 = &temp2;
6794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6795 }
6796 {
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_Py_Void();
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6810 PyObject *resultobj = 0;
6811 wxRect *arg1 = (wxRect *) 0 ;
6812 int result;
6813 void *argp1 = 0 ;
6814 int res1 = 0 ;
6815 PyObject *swig_obj[1] ;
6816
6817 if (!args) SWIG_fail;
6818 swig_obj[0] = args;
6819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6820 if (!SWIG_IsOK(res1)) {
6821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6822 }
6823 arg1 = reinterpret_cast< wxRect * >(argp1);
6824 {
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = (int)((wxRect const *)arg1)->GetLeft();
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_From_int(static_cast< int >(result));
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 wxRect *arg1 = (wxRect *) 0 ;
6840 int result;
6841 void *argp1 = 0 ;
6842 int res1 = 0 ;
6843 PyObject *swig_obj[1] ;
6844
6845 if (!args) SWIG_fail;
6846 swig_obj[0] = args;
6847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6848 if (!SWIG_IsOK(res1)) {
6849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6850 }
6851 arg1 = reinterpret_cast< wxRect * >(argp1);
6852 {
6853 PyThreadState* __tstate = wxPyBeginAllowThreads();
6854 result = (int)((wxRect const *)arg1)->GetTop();
6855 wxPyEndAllowThreads(__tstate);
6856 if (PyErr_Occurred()) SWIG_fail;
6857 }
6858 resultobj = SWIG_From_int(static_cast< int >(result));
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6866 PyObject *resultobj = 0;
6867 wxRect *arg1 = (wxRect *) 0 ;
6868 int result;
6869 void *argp1 = 0 ;
6870 int res1 = 0 ;
6871 PyObject *swig_obj[1] ;
6872
6873 if (!args) SWIG_fail;
6874 swig_obj[0] = args;
6875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6876 if (!SWIG_IsOK(res1)) {
6877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6878 }
6879 arg1 = reinterpret_cast< wxRect * >(argp1);
6880 {
6881 PyThreadState* __tstate = wxPyBeginAllowThreads();
6882 result = (int)((wxRect const *)arg1)->GetBottom();
6883 wxPyEndAllowThreads(__tstate);
6884 if (PyErr_Occurred()) SWIG_fail;
6885 }
6886 resultobj = SWIG_From_int(static_cast< int >(result));
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6894 PyObject *resultobj = 0;
6895 wxRect *arg1 = (wxRect *) 0 ;
6896 int result;
6897 void *argp1 = 0 ;
6898 int res1 = 0 ;
6899 PyObject *swig_obj[1] ;
6900
6901 if (!args) SWIG_fail;
6902 swig_obj[0] = args;
6903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6904 if (!SWIG_IsOK(res1)) {
6905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6906 }
6907 arg1 = reinterpret_cast< wxRect * >(argp1);
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 result = (int)((wxRect const *)arg1)->GetRight();
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_From_int(static_cast< int >(result));
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj = 0;
6923 wxRect *arg1 = (wxRect *) 0 ;
6924 int arg2 ;
6925 void *argp1 = 0 ;
6926 int res1 = 0 ;
6927 int val2 ;
6928 int ecode2 = 0 ;
6929 PyObject * obj0 = 0 ;
6930 PyObject * obj1 = 0 ;
6931 char * kwnames[] = {
6932 (char *) "self",(char *) "left", NULL
6933 };
6934
6935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6937 if (!SWIG_IsOK(res1)) {
6938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6939 }
6940 arg1 = reinterpret_cast< wxRect * >(argp1);
6941 ecode2 = SWIG_AsVal_int(obj1, &val2);
6942 if (!SWIG_IsOK(ecode2)) {
6943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6944 }
6945 arg2 = static_cast< int >(val2);
6946 {
6947 PyThreadState* __tstate = wxPyBeginAllowThreads();
6948 (arg1)->SetLeft(arg2);
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 resultobj = SWIG_Py_Void();
6953 return resultobj;
6954 fail:
6955 return NULL;
6956 }
6957
6958
6959 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6960 PyObject *resultobj = 0;
6961 wxRect *arg1 = (wxRect *) 0 ;
6962 int arg2 ;
6963 void *argp1 = 0 ;
6964 int res1 = 0 ;
6965 int val2 ;
6966 int ecode2 = 0 ;
6967 PyObject * obj0 = 0 ;
6968 PyObject * obj1 = 0 ;
6969 char * kwnames[] = {
6970 (char *) "self",(char *) "right", NULL
6971 };
6972
6973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6975 if (!SWIG_IsOK(res1)) {
6976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6977 }
6978 arg1 = reinterpret_cast< wxRect * >(argp1);
6979 ecode2 = SWIG_AsVal_int(obj1, &val2);
6980 if (!SWIG_IsOK(ecode2)) {
6981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6982 }
6983 arg2 = static_cast< int >(val2);
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 (arg1)->SetRight(arg2);
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 resultobj = SWIG_Py_Void();
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6998 PyObject *resultobj = 0;
6999 wxRect *arg1 = (wxRect *) 0 ;
7000 int arg2 ;
7001 void *argp1 = 0 ;
7002 int res1 = 0 ;
7003 int val2 ;
7004 int ecode2 = 0 ;
7005 PyObject * obj0 = 0 ;
7006 PyObject * obj1 = 0 ;
7007 char * kwnames[] = {
7008 (char *) "self",(char *) "top", NULL
7009 };
7010
7011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7013 if (!SWIG_IsOK(res1)) {
7014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7015 }
7016 arg1 = reinterpret_cast< wxRect * >(argp1);
7017 ecode2 = SWIG_AsVal_int(obj1, &val2);
7018 if (!SWIG_IsOK(ecode2)) {
7019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7020 }
7021 arg2 = static_cast< int >(val2);
7022 {
7023 PyThreadState* __tstate = wxPyBeginAllowThreads();
7024 (arg1)->SetTop(arg2);
7025 wxPyEndAllowThreads(__tstate);
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 resultobj = SWIG_Py_Void();
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7036 PyObject *resultobj = 0;
7037 wxRect *arg1 = (wxRect *) 0 ;
7038 int arg2 ;
7039 void *argp1 = 0 ;
7040 int res1 = 0 ;
7041 int val2 ;
7042 int ecode2 = 0 ;
7043 PyObject * obj0 = 0 ;
7044 PyObject * obj1 = 0 ;
7045 char * kwnames[] = {
7046 (char *) "self",(char *) "bottom", NULL
7047 };
7048
7049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7051 if (!SWIG_IsOK(res1)) {
7052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7053 }
7054 arg1 = reinterpret_cast< wxRect * >(argp1);
7055 ecode2 = SWIG_AsVal_int(obj1, &val2);
7056 if (!SWIG_IsOK(ecode2)) {
7057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7058 }
7059 arg2 = static_cast< int >(val2);
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 (arg1)->SetBottom(arg2);
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 resultobj = SWIG_Py_Void();
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj = 0;
7075 wxRect *arg1 = (wxRect *) 0 ;
7076 int arg2 ;
7077 int arg3 ;
7078 wxRect *result = 0 ;
7079 void *argp1 = 0 ;
7080 int res1 = 0 ;
7081 int val2 ;
7082 int ecode2 = 0 ;
7083 int val3 ;
7084 int ecode3 = 0 ;
7085 PyObject * obj0 = 0 ;
7086 PyObject * obj1 = 0 ;
7087 PyObject * obj2 = 0 ;
7088 char * kwnames[] = {
7089 (char *) "self",(char *) "dx",(char *) "dy", NULL
7090 };
7091
7092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7094 if (!SWIG_IsOK(res1)) {
7095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7096 }
7097 arg1 = reinterpret_cast< wxRect * >(argp1);
7098 ecode2 = SWIG_AsVal_int(obj1, &val2);
7099 if (!SWIG_IsOK(ecode2)) {
7100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7101 }
7102 arg2 = static_cast< int >(val2);
7103 ecode3 = SWIG_AsVal_int(obj2, &val3);
7104 if (!SWIG_IsOK(ecode3)) {
7105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7106 }
7107 arg3 = static_cast< int >(val3);
7108 {
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 {
7111 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7112 result = (wxRect *) &_result_ref;
7113 }
7114 wxPyEndAllowThreads(__tstate);
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj = 0;
7126 wxRect *arg1 = (wxRect *) 0 ;
7127 int arg2 ;
7128 int arg3 ;
7129 wxRect *result = 0 ;
7130 void *argp1 = 0 ;
7131 int res1 = 0 ;
7132 int val2 ;
7133 int ecode2 = 0 ;
7134 int val3 ;
7135 int ecode3 = 0 ;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 PyObject * obj2 = 0 ;
7139 char * kwnames[] = {
7140 (char *) "self",(char *) "dx",(char *) "dy", NULL
7141 };
7142
7143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7145 if (!SWIG_IsOK(res1)) {
7146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7147 }
7148 arg1 = reinterpret_cast< wxRect * >(argp1);
7149 ecode2 = SWIG_AsVal_int(obj1, &val2);
7150 if (!SWIG_IsOK(ecode2)) {
7151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7152 }
7153 arg2 = static_cast< int >(val2);
7154 ecode3 = SWIG_AsVal_int(obj2, &val3);
7155 if (!SWIG_IsOK(ecode3)) {
7156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7157 }
7158 arg3 = static_cast< int >(val3);
7159 {
7160 PyThreadState* __tstate = wxPyBeginAllowThreads();
7161 {
7162 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7163 result = (wxRect *) &_result_ref;
7164 }
7165 wxPyEndAllowThreads(__tstate);
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7176 PyObject *resultobj = 0;
7177 wxRect *arg1 = (wxRect *) 0 ;
7178 int arg2 ;
7179 int arg3 ;
7180 void *argp1 = 0 ;
7181 int res1 = 0 ;
7182 int val2 ;
7183 int ecode2 = 0 ;
7184 int val3 ;
7185 int ecode3 = 0 ;
7186 PyObject * obj0 = 0 ;
7187 PyObject * obj1 = 0 ;
7188 PyObject * obj2 = 0 ;
7189 char * kwnames[] = {
7190 (char *) "self",(char *) "dx",(char *) "dy", NULL
7191 };
7192
7193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7195 if (!SWIG_IsOK(res1)) {
7196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7197 }
7198 arg1 = reinterpret_cast< wxRect * >(argp1);
7199 ecode2 = SWIG_AsVal_int(obj1, &val2);
7200 if (!SWIG_IsOK(ecode2)) {
7201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7202 }
7203 arg2 = static_cast< int >(val2);
7204 ecode3 = SWIG_AsVal_int(obj2, &val3);
7205 if (!SWIG_IsOK(ecode3)) {
7206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7207 }
7208 arg3 = static_cast< int >(val3);
7209 {
7210 PyThreadState* __tstate = wxPyBeginAllowThreads();
7211 (arg1)->Offset(arg2,arg3);
7212 wxPyEndAllowThreads(__tstate);
7213 if (PyErr_Occurred()) SWIG_fail;
7214 }
7215 resultobj = SWIG_Py_Void();
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj = 0;
7224 wxRect *arg1 = (wxRect *) 0 ;
7225 wxPoint *arg2 = 0 ;
7226 void *argp1 = 0 ;
7227 int res1 = 0 ;
7228 wxPoint temp2 ;
7229 PyObject * obj0 = 0 ;
7230 PyObject * obj1 = 0 ;
7231 char * kwnames[] = {
7232 (char *) "self",(char *) "pt", NULL
7233 };
7234
7235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7237 if (!SWIG_IsOK(res1)) {
7238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7239 }
7240 arg1 = reinterpret_cast< wxRect * >(argp1);
7241 {
7242 arg2 = &temp2;
7243 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7244 }
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 (arg1)->Offset((wxPoint const &)*arg2);
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 resultobj = SWIG_Py_Void();
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj = 0;
7260 wxRect *arg1 = (wxRect *) 0 ;
7261 wxRect *arg2 = 0 ;
7262 wxRect result;
7263 void *argp1 = 0 ;
7264 int res1 = 0 ;
7265 wxRect temp2 ;
7266 PyObject * obj0 = 0 ;
7267 PyObject * obj1 = 0 ;
7268 char * kwnames[] = {
7269 (char *) "self",(char *) "rect", NULL
7270 };
7271
7272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7274 if (!SWIG_IsOK(res1)) {
7275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7276 }
7277 arg1 = reinterpret_cast< wxRect * >(argp1);
7278 {
7279 arg2 = &temp2;
7280 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7281 }
7282 {
7283 PyThreadState* __tstate = wxPyBeginAllowThreads();
7284 result = (arg1)->Intersect((wxRect const &)*arg2);
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj = 0;
7297 wxRect *arg1 = (wxRect *) 0 ;
7298 wxRect *arg2 = 0 ;
7299 wxRect result;
7300 void *argp1 = 0 ;
7301 int res1 = 0 ;
7302 wxRect temp2 ;
7303 PyObject * obj0 = 0 ;
7304 PyObject * obj1 = 0 ;
7305 char * kwnames[] = {
7306 (char *) "self",(char *) "rect", NULL
7307 };
7308
7309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7311 if (!SWIG_IsOK(res1)) {
7312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7313 }
7314 arg1 = reinterpret_cast< wxRect * >(argp1);
7315 {
7316 arg2 = &temp2;
7317 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7318 }
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (arg1)->Union((wxRect const &)*arg2);
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj = 0;
7334 wxRect *arg1 = (wxRect *) 0 ;
7335 wxRect *arg2 = 0 ;
7336 wxRect result;
7337 void *argp1 = 0 ;
7338 int res1 = 0 ;
7339 wxRect temp2 ;
7340 PyObject * obj0 = 0 ;
7341 PyObject * obj1 = 0 ;
7342 char * kwnames[] = {
7343 (char *) "self",(char *) "rect", NULL
7344 };
7345
7346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7348 if (!SWIG_IsOK(res1)) {
7349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7350 }
7351 arg1 = reinterpret_cast< wxRect * >(argp1);
7352 {
7353 arg2 = &temp2;
7354 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7355 }
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7359 wxPyEndAllowThreads(__tstate);
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj = 0;
7371 wxRect *arg1 = (wxRect *) 0 ;
7372 wxRect *arg2 = 0 ;
7373 wxRect *result = 0 ;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 wxRect temp2 ;
7377 PyObject * obj0 = 0 ;
7378 PyObject * obj1 = 0 ;
7379 char * kwnames[] = {
7380 (char *) "self",(char *) "rect", NULL
7381 };
7382
7383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7385 if (!SWIG_IsOK(res1)) {
7386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7387 }
7388 arg1 = reinterpret_cast< wxRect * >(argp1);
7389 {
7390 arg2 = &temp2;
7391 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7392 }
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 {
7396 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7397 result = (wxRect *) &_result_ref;
7398 }
7399 wxPyEndAllowThreads(__tstate);
7400 if (PyErr_Occurred()) SWIG_fail;
7401 }
7402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7403 return resultobj;
7404 fail:
7405 return NULL;
7406 }
7407
7408
7409 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7410 PyObject *resultobj = 0;
7411 wxRect *arg1 = (wxRect *) 0 ;
7412 PyObject *arg2 = (PyObject *) 0 ;
7413 bool result;
7414 void *argp1 = 0 ;
7415 int res1 = 0 ;
7416 PyObject * obj0 = 0 ;
7417 PyObject * obj1 = 0 ;
7418 char * kwnames[] = {
7419 (char *) "self",(char *) "other", NULL
7420 };
7421
7422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7424 if (!SWIG_IsOK(res1)) {
7425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7426 }
7427 arg1 = reinterpret_cast< wxRect * >(argp1);
7428 arg2 = obj1;
7429 {
7430 result = (bool)wxRect___eq__(arg1,arg2);
7431 if (PyErr_Occurred()) SWIG_fail;
7432 }
7433 {
7434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7435 }
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7443 PyObject *resultobj = 0;
7444 wxRect *arg1 = (wxRect *) 0 ;
7445 PyObject *arg2 = (PyObject *) 0 ;
7446 bool result;
7447 void *argp1 = 0 ;
7448 int res1 = 0 ;
7449 PyObject * obj0 = 0 ;
7450 PyObject * obj1 = 0 ;
7451 char * kwnames[] = {
7452 (char *) "self",(char *) "other", NULL
7453 };
7454
7455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7457 if (!SWIG_IsOK(res1)) {
7458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7459 }
7460 arg1 = reinterpret_cast< wxRect * >(argp1);
7461 arg2 = obj1;
7462 {
7463 result = (bool)wxRect___ne__(arg1,arg2);
7464 if (PyErr_Occurred()) SWIG_fail;
7465 }
7466 {
7467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7468 }
7469 return resultobj;
7470 fail:
7471 return NULL;
7472 }
7473
7474
7475 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7476 PyObject *resultobj = 0;
7477 wxRect *arg1 = (wxRect *) 0 ;
7478 int arg2 ;
7479 int arg3 ;
7480 bool result;
7481 void *argp1 = 0 ;
7482 int res1 = 0 ;
7483 int val2 ;
7484 int ecode2 = 0 ;
7485 int val3 ;
7486 int ecode3 = 0 ;
7487 PyObject * obj0 = 0 ;
7488 PyObject * obj1 = 0 ;
7489 PyObject * obj2 = 0 ;
7490 char * kwnames[] = {
7491 (char *) "self",(char *) "x",(char *) "y", NULL
7492 };
7493
7494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7496 if (!SWIG_IsOK(res1)) {
7497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7498 }
7499 arg1 = reinterpret_cast< wxRect * >(argp1);
7500 ecode2 = SWIG_AsVal_int(obj1, &val2);
7501 if (!SWIG_IsOK(ecode2)) {
7502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7503 }
7504 arg2 = static_cast< int >(val2);
7505 ecode3 = SWIG_AsVal_int(obj2, &val3);
7506 if (!SWIG_IsOK(ecode3)) {
7507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7508 }
7509 arg3 = static_cast< int >(val3);
7510 {
7511 PyThreadState* __tstate = wxPyBeginAllowThreads();
7512 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7513 wxPyEndAllowThreads(__tstate);
7514 if (PyErr_Occurred()) SWIG_fail;
7515 }
7516 {
7517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7518 }
7519 return resultobj;
7520 fail:
7521 return NULL;
7522 }
7523
7524
7525 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7526 PyObject *resultobj = 0;
7527 wxRect *arg1 = (wxRect *) 0 ;
7528 wxPoint *arg2 = 0 ;
7529 bool result;
7530 void *argp1 = 0 ;
7531 int res1 = 0 ;
7532 wxPoint temp2 ;
7533 PyObject * obj0 = 0 ;
7534 PyObject * obj1 = 0 ;
7535 char * kwnames[] = {
7536 (char *) "self",(char *) "pt", NULL
7537 };
7538
7539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7541 if (!SWIG_IsOK(res1)) {
7542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7543 }
7544 arg1 = reinterpret_cast< wxRect * >(argp1);
7545 {
7546 arg2 = &temp2;
7547 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7548 }
7549 {
7550 PyThreadState* __tstate = wxPyBeginAllowThreads();
7551 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7552 wxPyEndAllowThreads(__tstate);
7553 if (PyErr_Occurred()) SWIG_fail;
7554 }
7555 {
7556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7557 }
7558 return resultobj;
7559 fail:
7560 return NULL;
7561 }
7562
7563
7564 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7565 PyObject *resultobj = 0;
7566 wxRect *arg1 = (wxRect *) 0 ;
7567 wxRect *arg2 = 0 ;
7568 bool result;
7569 void *argp1 = 0 ;
7570 int res1 = 0 ;
7571 wxRect temp2 ;
7572 PyObject * obj0 = 0 ;
7573 PyObject * obj1 = 0 ;
7574 char * kwnames[] = {
7575 (char *) "self",(char *) "rect", NULL
7576 };
7577
7578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7580 if (!SWIG_IsOK(res1)) {
7581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7582 }
7583 arg1 = reinterpret_cast< wxRect * >(argp1);
7584 {
7585 arg2 = &temp2;
7586 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7587 }
7588 {
7589 PyThreadState* __tstate = wxPyBeginAllowThreads();
7590 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7591 wxPyEndAllowThreads(__tstate);
7592 if (PyErr_Occurred()) SWIG_fail;
7593 }
7594 {
7595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7596 }
7597 return resultobj;
7598 fail:
7599 return NULL;
7600 }
7601
7602
7603 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7604 PyObject *resultobj = 0;
7605 wxRect *arg1 = (wxRect *) 0 ;
7606 wxRect *arg2 = 0 ;
7607 int arg3 = (int) wxBOTH ;
7608 wxRect result;
7609 void *argp1 = 0 ;
7610 int res1 = 0 ;
7611 wxRect temp2 ;
7612 int val3 ;
7613 int ecode3 = 0 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 PyObject * obj2 = 0 ;
7617 char * kwnames[] = {
7618 (char *) "self",(char *) "r",(char *) "dir", NULL
7619 };
7620
7621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7623 if (!SWIG_IsOK(res1)) {
7624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7625 }
7626 arg1 = reinterpret_cast< wxRect * >(argp1);
7627 {
7628 arg2 = &temp2;
7629 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7630 }
7631 if (obj2) {
7632 ecode3 = SWIG_AsVal_int(obj2, &val3);
7633 if (!SWIG_IsOK(ecode3)) {
7634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7635 }
7636 arg3 = static_cast< int >(val3);
7637 }
7638 {
7639 PyThreadState* __tstate = wxPyBeginAllowThreads();
7640 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7641 wxPyEndAllowThreads(__tstate);
7642 if (PyErr_Occurred()) SWIG_fail;
7643 }
7644 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7652 PyObject *resultobj = 0;
7653 wxRect *arg1 = (wxRect *) 0 ;
7654 int arg2 ;
7655 void *argp1 = 0 ;
7656 int res1 = 0 ;
7657 int val2 ;
7658 int ecode2 = 0 ;
7659 PyObject *swig_obj[2] ;
7660
7661 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7665 }
7666 arg1 = reinterpret_cast< wxRect * >(argp1);
7667 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7668 if (!SWIG_IsOK(ecode2)) {
7669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7670 }
7671 arg2 = static_cast< int >(val2);
7672 if (arg1) (arg1)->x = arg2;
7673
7674 resultobj = SWIG_Py_Void();
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7682 PyObject *resultobj = 0;
7683 wxRect *arg1 = (wxRect *) 0 ;
7684 int result;
7685 void *argp1 = 0 ;
7686 int res1 = 0 ;
7687 PyObject *swig_obj[1] ;
7688
7689 if (!args) SWIG_fail;
7690 swig_obj[0] = args;
7691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7692 if (!SWIG_IsOK(res1)) {
7693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7694 }
7695 arg1 = reinterpret_cast< wxRect * >(argp1);
7696 result = (int) ((arg1)->x);
7697 resultobj = SWIG_From_int(static_cast< int >(result));
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7705 PyObject *resultobj = 0;
7706 wxRect *arg1 = (wxRect *) 0 ;
7707 int arg2 ;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 PyObject *swig_obj[2] ;
7713
7714 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7716 if (!SWIG_IsOK(res1)) {
7717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7718 }
7719 arg1 = reinterpret_cast< wxRect * >(argp1);
7720 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7721 if (!SWIG_IsOK(ecode2)) {
7722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7723 }
7724 arg2 = static_cast< int >(val2);
7725 if (arg1) (arg1)->y = arg2;
7726
7727 resultobj = SWIG_Py_Void();
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7735 PyObject *resultobj = 0;
7736 wxRect *arg1 = (wxRect *) 0 ;
7737 int result;
7738 void *argp1 = 0 ;
7739 int res1 = 0 ;
7740 PyObject *swig_obj[1] ;
7741
7742 if (!args) SWIG_fail;
7743 swig_obj[0] = args;
7744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7745 if (!SWIG_IsOK(res1)) {
7746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7747 }
7748 arg1 = reinterpret_cast< wxRect * >(argp1);
7749 result = (int) ((arg1)->y);
7750 resultobj = SWIG_From_int(static_cast< int >(result));
7751 return resultobj;
7752 fail:
7753 return NULL;
7754 }
7755
7756
7757 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7758 PyObject *resultobj = 0;
7759 wxRect *arg1 = (wxRect *) 0 ;
7760 int arg2 ;
7761 void *argp1 = 0 ;
7762 int res1 = 0 ;
7763 int val2 ;
7764 int ecode2 = 0 ;
7765 PyObject *swig_obj[2] ;
7766
7767 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7769 if (!SWIG_IsOK(res1)) {
7770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7771 }
7772 arg1 = reinterpret_cast< wxRect * >(argp1);
7773 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7774 if (!SWIG_IsOK(ecode2)) {
7775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7776 }
7777 arg2 = static_cast< int >(val2);
7778 if (arg1) (arg1)->width = arg2;
7779
7780 resultobj = SWIG_Py_Void();
7781 return resultobj;
7782 fail:
7783 return NULL;
7784 }
7785
7786
7787 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7788 PyObject *resultobj = 0;
7789 wxRect *arg1 = (wxRect *) 0 ;
7790 int result;
7791 void *argp1 = 0 ;
7792 int res1 = 0 ;
7793 PyObject *swig_obj[1] ;
7794
7795 if (!args) SWIG_fail;
7796 swig_obj[0] = args;
7797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7798 if (!SWIG_IsOK(res1)) {
7799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7800 }
7801 arg1 = reinterpret_cast< wxRect * >(argp1);
7802 result = (int) ((arg1)->width);
7803 resultobj = SWIG_From_int(static_cast< int >(result));
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7811 PyObject *resultobj = 0;
7812 wxRect *arg1 = (wxRect *) 0 ;
7813 int arg2 ;
7814 void *argp1 = 0 ;
7815 int res1 = 0 ;
7816 int val2 ;
7817 int ecode2 = 0 ;
7818 PyObject *swig_obj[2] ;
7819
7820 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7822 if (!SWIG_IsOK(res1)) {
7823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7824 }
7825 arg1 = reinterpret_cast< wxRect * >(argp1);
7826 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7827 if (!SWIG_IsOK(ecode2)) {
7828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7829 }
7830 arg2 = static_cast< int >(val2);
7831 if (arg1) (arg1)->height = arg2;
7832
7833 resultobj = SWIG_Py_Void();
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7841 PyObject *resultobj = 0;
7842 wxRect *arg1 = (wxRect *) 0 ;
7843 int result;
7844 void *argp1 = 0 ;
7845 int res1 = 0 ;
7846 PyObject *swig_obj[1] ;
7847
7848 if (!args) SWIG_fail;
7849 swig_obj[0] = args;
7850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7851 if (!SWIG_IsOK(res1)) {
7852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7853 }
7854 arg1 = reinterpret_cast< wxRect * >(argp1);
7855 result = (int) ((arg1)->height);
7856 resultobj = SWIG_From_int(static_cast< int >(result));
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7864 PyObject *resultobj = 0;
7865 wxRect *arg1 = (wxRect *) 0 ;
7866 int arg2 = (int) 0 ;
7867 int arg3 = (int) 0 ;
7868 int arg4 = (int) 0 ;
7869 int arg5 = (int) 0 ;
7870 void *argp1 = 0 ;
7871 int res1 = 0 ;
7872 int val2 ;
7873 int ecode2 = 0 ;
7874 int val3 ;
7875 int ecode3 = 0 ;
7876 int val4 ;
7877 int ecode4 = 0 ;
7878 int val5 ;
7879 int ecode5 = 0 ;
7880 PyObject * obj0 = 0 ;
7881 PyObject * obj1 = 0 ;
7882 PyObject * obj2 = 0 ;
7883 PyObject * obj3 = 0 ;
7884 PyObject * obj4 = 0 ;
7885 char * kwnames[] = {
7886 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7887 };
7888
7889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7891 if (!SWIG_IsOK(res1)) {
7892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7893 }
7894 arg1 = reinterpret_cast< wxRect * >(argp1);
7895 if (obj1) {
7896 ecode2 = SWIG_AsVal_int(obj1, &val2);
7897 if (!SWIG_IsOK(ecode2)) {
7898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7899 }
7900 arg2 = static_cast< int >(val2);
7901 }
7902 if (obj2) {
7903 ecode3 = SWIG_AsVal_int(obj2, &val3);
7904 if (!SWIG_IsOK(ecode3)) {
7905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7906 }
7907 arg3 = static_cast< int >(val3);
7908 }
7909 if (obj3) {
7910 ecode4 = SWIG_AsVal_int(obj3, &val4);
7911 if (!SWIG_IsOK(ecode4)) {
7912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7913 }
7914 arg4 = static_cast< int >(val4);
7915 }
7916 if (obj4) {
7917 ecode5 = SWIG_AsVal_int(obj4, &val5);
7918 if (!SWIG_IsOK(ecode5)) {
7919 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7920 }
7921 arg5 = static_cast< int >(val5);
7922 }
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 resultobj = SWIG_Py_Void();
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7937 PyObject *resultobj = 0;
7938 wxRect *arg1 = (wxRect *) 0 ;
7939 PyObject *result = 0 ;
7940 void *argp1 = 0 ;
7941 int res1 = 0 ;
7942 PyObject *swig_obj[1] ;
7943
7944 if (!args) SWIG_fail;
7945 swig_obj[0] = args;
7946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7947 if (!SWIG_IsOK(res1)) {
7948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7949 }
7950 arg1 = reinterpret_cast< wxRect * >(argp1);
7951 {
7952 PyThreadState* __tstate = wxPyBeginAllowThreads();
7953 result = (PyObject *)wxRect_Get(arg1);
7954 wxPyEndAllowThreads(__tstate);
7955 if (PyErr_Occurred()) SWIG_fail;
7956 }
7957 resultobj = result;
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7965 PyObject *obj;
7966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7967 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7968 return SWIG_Py_Void();
7969 }
7970
7971 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7972 return SWIG_Python_InitShadowInstance(args);
7973 }
7974
7975 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7976 PyObject *resultobj = 0;
7977 wxRect *arg1 = (wxRect *) 0 ;
7978 wxRect *arg2 = (wxRect *) 0 ;
7979 PyObject *result = 0 ;
7980 void *argp1 = 0 ;
7981 int res1 = 0 ;
7982 void *argp2 = 0 ;
7983 int res2 = 0 ;
7984 PyObject * obj0 = 0 ;
7985 PyObject * obj1 = 0 ;
7986 char * kwnames[] = {
7987 (char *) "r1",(char *) "r2", NULL
7988 };
7989
7990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7992 if (!SWIG_IsOK(res1)) {
7993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7994 }
7995 arg1 = reinterpret_cast< wxRect * >(argp1);
7996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7997 if (!SWIG_IsOK(res2)) {
7998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7999 }
8000 arg2 = reinterpret_cast< wxRect * >(argp2);
8001 {
8002 if (!wxPyCheckForApp()) SWIG_fail;
8003 PyThreadState* __tstate = wxPyBeginAllowThreads();
8004 result = (PyObject *)wxIntersectRect(arg1,arg2);
8005 wxPyEndAllowThreads(__tstate);
8006 if (PyErr_Occurred()) SWIG_fail;
8007 }
8008 resultobj = result;
8009 return resultobj;
8010 fail:
8011 return NULL;
8012 }
8013
8014
8015 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8016 PyObject *resultobj = 0;
8017 double arg1 = (double) 0.0 ;
8018 double arg2 = (double) 0.0 ;
8019 wxPoint2D *result = 0 ;
8020 double val1 ;
8021 int ecode1 = 0 ;
8022 double val2 ;
8023 int ecode2 = 0 ;
8024 PyObject * obj0 = 0 ;
8025 PyObject * obj1 = 0 ;
8026 char * kwnames[] = {
8027 (char *) "x",(char *) "y", NULL
8028 };
8029
8030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8031 if (obj0) {
8032 ecode1 = SWIG_AsVal_double(obj0, &val1);
8033 if (!SWIG_IsOK(ecode1)) {
8034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8035 }
8036 arg1 = static_cast< double >(val1);
8037 }
8038 if (obj1) {
8039 ecode2 = SWIG_AsVal_double(obj1, &val2);
8040 if (!SWIG_IsOK(ecode2)) {
8041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8042 }
8043 arg2 = static_cast< double >(val2);
8044 }
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8052 return resultobj;
8053 fail:
8054 return NULL;
8055 }
8056
8057
8058 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8059 PyObject *resultobj = 0;
8060 wxPoint2D *arg1 = 0 ;
8061 wxPoint2D *result = 0 ;
8062 wxPoint2D temp1 ;
8063 PyObject * obj0 = 0 ;
8064 char * kwnames[] = {
8065 (char *) "pt", NULL
8066 };
8067
8068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8069 {
8070 arg1 = &temp1;
8071 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8072 }
8073 {
8074 PyThreadState* __tstate = wxPyBeginAllowThreads();
8075 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj = 0;
8088 wxPoint *arg1 = 0 ;
8089 wxPoint2D *result = 0 ;
8090 wxPoint temp1 ;
8091 PyObject * obj0 = 0 ;
8092 char * kwnames[] = {
8093 (char *) "pt", NULL
8094 };
8095
8096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8097 {
8098 arg1 = &temp1;
8099 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8100 }
8101 {
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8115 PyObject *resultobj = 0;
8116 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8117 int *arg2 = (int *) 0 ;
8118 int *arg3 = (int *) 0 ;
8119 void *argp1 = 0 ;
8120 int res1 = 0 ;
8121 int temp2 ;
8122 int res2 = SWIG_TMPOBJ ;
8123 int temp3 ;
8124 int res3 = SWIG_TMPOBJ ;
8125 PyObject *swig_obj[1] ;
8126
8127 arg2 = &temp2;
8128 arg3 = &temp3;
8129 if (!args) SWIG_fail;
8130 swig_obj[0] = args;
8131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8132 if (!SWIG_IsOK(res1)) {
8133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8134 }
8135 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 resultobj = SWIG_Py_Void();
8143 if (SWIG_IsTmpObj(res2)) {
8144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8145 } else {
8146 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8148 }
8149 if (SWIG_IsTmpObj(res3)) {
8150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8151 } else {
8152 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8154 }
8155 return resultobj;
8156 fail:
8157 return NULL;
8158 }
8159
8160
8161 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8162 PyObject *resultobj = 0;
8163 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8164 int *arg2 = (int *) 0 ;
8165 int *arg3 = (int *) 0 ;
8166 void *argp1 = 0 ;
8167 int res1 = 0 ;
8168 int temp2 ;
8169 int res2 = SWIG_TMPOBJ ;
8170 int temp3 ;
8171 int res3 = SWIG_TMPOBJ ;
8172 PyObject *swig_obj[1] ;
8173
8174 arg2 = &temp2;
8175 arg3 = &temp3;
8176 if (!args) SWIG_fail;
8177 swig_obj[0] = args;
8178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8179 if (!SWIG_IsOK(res1)) {
8180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8181 }
8182 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8183 {
8184 PyThreadState* __tstate = wxPyBeginAllowThreads();
8185 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8186 wxPyEndAllowThreads(__tstate);
8187 if (PyErr_Occurred()) SWIG_fail;
8188 }
8189 resultobj = SWIG_Py_Void();
8190 if (SWIG_IsTmpObj(res2)) {
8191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8192 } else {
8193 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8195 }
8196 if (SWIG_IsTmpObj(res3)) {
8197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8198 } else {
8199 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8201 }
8202 return resultobj;
8203 fail:
8204 return NULL;
8205 }
8206
8207
8208 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8209 PyObject *resultobj = 0;
8210 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8211 double result;
8212 void *argp1 = 0 ;
8213 int res1 = 0 ;
8214 PyObject *swig_obj[1] ;
8215
8216 if (!args) SWIG_fail;
8217 swig_obj[0] = args;
8218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8219 if (!SWIG_IsOK(res1)) {
8220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8221 }
8222 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8223 {
8224 PyThreadState* __tstate = wxPyBeginAllowThreads();
8225 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8226 wxPyEndAllowThreads(__tstate);
8227 if (PyErr_Occurred()) SWIG_fail;
8228 }
8229 resultobj = SWIG_From_double(static_cast< double >(result));
8230 return resultobj;
8231 fail:
8232 return NULL;
8233 }
8234
8235
8236 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8237 PyObject *resultobj = 0;
8238 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8239 double result;
8240 void *argp1 = 0 ;
8241 int res1 = 0 ;
8242 PyObject *swig_obj[1] ;
8243
8244 if (!args) SWIG_fail;
8245 swig_obj[0] = args;
8246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8247 if (!SWIG_IsOK(res1)) {
8248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8249 }
8250 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8251 {
8252 PyThreadState* __tstate = wxPyBeginAllowThreads();
8253 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8254 wxPyEndAllowThreads(__tstate);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 resultobj = SWIG_From_double(static_cast< double >(result));
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj = 0;
8266 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8267 double arg2 ;
8268 void *argp1 = 0 ;
8269 int res1 = 0 ;
8270 double val2 ;
8271 int ecode2 = 0 ;
8272 PyObject * obj0 = 0 ;
8273 PyObject * obj1 = 0 ;
8274 char * kwnames[] = {
8275 (char *) "self",(char *) "length", NULL
8276 };
8277
8278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8280 if (!SWIG_IsOK(res1)) {
8281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8282 }
8283 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8284 ecode2 = SWIG_AsVal_double(obj1, &val2);
8285 if (!SWIG_IsOK(ecode2)) {
8286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8287 }
8288 arg2 = static_cast< double >(val2);
8289 {
8290 PyThreadState* __tstate = wxPyBeginAllowThreads();
8291 (arg1)->SetVectorLength(arg2);
8292 wxPyEndAllowThreads(__tstate);
8293 if (PyErr_Occurred()) SWIG_fail;
8294 }
8295 resultobj = SWIG_Py_Void();
8296 return resultobj;
8297 fail:
8298 return NULL;
8299 }
8300
8301
8302 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8303 PyObject *resultobj = 0;
8304 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8305 double arg2 ;
8306 void *argp1 = 0 ;
8307 int res1 = 0 ;
8308 double val2 ;
8309 int ecode2 = 0 ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 char * kwnames[] = {
8313 (char *) "self",(char *) "degrees", NULL
8314 };
8315
8316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8318 if (!SWIG_IsOK(res1)) {
8319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8320 }
8321 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8322 ecode2 = SWIG_AsVal_double(obj1, &val2);
8323 if (!SWIG_IsOK(ecode2)) {
8324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8325 }
8326 arg2 = static_cast< double >(val2);
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 (arg1)->SetVectorAngle(arg2);
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 resultobj = SWIG_Py_Void();
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8343 wxPoint2D *arg2 = 0 ;
8344 double result;
8345 void *argp1 = 0 ;
8346 int res1 = 0 ;
8347 wxPoint2D temp2 ;
8348 PyObject * obj0 = 0 ;
8349 PyObject * obj1 = 0 ;
8350 char * kwnames[] = {
8351 (char *) "self",(char *) "pt", NULL
8352 };
8353
8354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8356 if (!SWIG_IsOK(res1)) {
8357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8358 }
8359 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8360 {
8361 arg2 = &temp2;
8362 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8363 }
8364 {
8365 PyThreadState* __tstate = wxPyBeginAllowThreads();
8366 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8367 wxPyEndAllowThreads(__tstate);
8368 if (PyErr_Occurred()) SWIG_fail;
8369 }
8370 resultobj = SWIG_From_double(static_cast< double >(result));
8371 return resultobj;
8372 fail:
8373 return NULL;
8374 }
8375
8376
8377 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj = 0;
8379 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8380 wxPoint2D *arg2 = 0 ;
8381 double result;
8382 void *argp1 = 0 ;
8383 int res1 = 0 ;
8384 wxPoint2D temp2 ;
8385 PyObject * obj0 = 0 ;
8386 PyObject * obj1 = 0 ;
8387 char * kwnames[] = {
8388 (char *) "self",(char *) "pt", NULL
8389 };
8390
8391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8393 if (!SWIG_IsOK(res1)) {
8394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8395 }
8396 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8397 {
8398 arg2 = &temp2;
8399 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8400 }
8401 {
8402 PyThreadState* __tstate = wxPyBeginAllowThreads();
8403 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8404 wxPyEndAllowThreads(__tstate);
8405 if (PyErr_Occurred()) SWIG_fail;
8406 }
8407 resultobj = SWIG_From_double(static_cast< double >(result));
8408 return resultobj;
8409 fail:
8410 return NULL;
8411 }
8412
8413
8414 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj = 0;
8416 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8417 wxPoint2D *arg2 = 0 ;
8418 double result;
8419 void *argp1 = 0 ;
8420 int res1 = 0 ;
8421 wxPoint2D temp2 ;
8422 PyObject * obj0 = 0 ;
8423 PyObject * obj1 = 0 ;
8424 char * kwnames[] = {
8425 (char *) "self",(char *) "vec", NULL
8426 };
8427
8428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8430 if (!SWIG_IsOK(res1)) {
8431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8432 }
8433 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8434 {
8435 arg2 = &temp2;
8436 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8437 }
8438 {
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 resultobj = SWIG_From_double(static_cast< double >(result));
8445 return resultobj;
8446 fail:
8447 return NULL;
8448 }
8449
8450
8451 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8452 PyObject *resultobj = 0;
8453 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8454 wxPoint2D *arg2 = 0 ;
8455 double result;
8456 void *argp1 = 0 ;
8457 int res1 = 0 ;
8458 wxPoint2D temp2 ;
8459 PyObject * obj0 = 0 ;
8460 PyObject * obj1 = 0 ;
8461 char * kwnames[] = {
8462 (char *) "self",(char *) "vec", NULL
8463 };
8464
8465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8467 if (!SWIG_IsOK(res1)) {
8468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8469 }
8470 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8471 {
8472 arg2 = &temp2;
8473 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8474 }
8475 {
8476 PyThreadState* __tstate = wxPyBeginAllowThreads();
8477 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 resultobj = SWIG_From_double(static_cast< double >(result));
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8489 PyObject *resultobj = 0;
8490 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8491 wxPoint2D result;
8492 void *argp1 = 0 ;
8493 int res1 = 0 ;
8494 PyObject *swig_obj[1] ;
8495
8496 if (!args) SWIG_fail;
8497 swig_obj[0] = args;
8498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8499 if (!SWIG_IsOK(res1)) {
8500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8501 }
8502 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8503 {
8504 PyThreadState* __tstate = wxPyBeginAllowThreads();
8505 result = (arg1)->operator -();
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8510 return resultobj;
8511 fail:
8512 return NULL;
8513 }
8514
8515
8516 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8517 PyObject *resultobj = 0;
8518 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8519 wxPoint2D *arg2 = 0 ;
8520 wxPoint2D *result = 0 ;
8521 void *argp1 = 0 ;
8522 int res1 = 0 ;
8523 wxPoint2D temp2 ;
8524 PyObject * obj0 = 0 ;
8525 PyObject * obj1 = 0 ;
8526 char * kwnames[] = {
8527 (char *) "self",(char *) "pt", NULL
8528 };
8529
8530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8532 if (!SWIG_IsOK(res1)) {
8533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8534 }
8535 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8536 {
8537 arg2 = &temp2;
8538 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8539 }
8540 {
8541 PyThreadState* __tstate = wxPyBeginAllowThreads();
8542 {
8543 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8544 result = (wxPoint2D *) &_result_ref;
8545 }
8546 wxPyEndAllowThreads(__tstate);
8547 if (PyErr_Occurred()) SWIG_fail;
8548 }
8549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8550 return resultobj;
8551 fail:
8552 return NULL;
8553 }
8554
8555
8556 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8557 PyObject *resultobj = 0;
8558 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8559 wxPoint2D *arg2 = 0 ;
8560 wxPoint2D *result = 0 ;
8561 void *argp1 = 0 ;
8562 int res1 = 0 ;
8563 wxPoint2D temp2 ;
8564 PyObject * obj0 = 0 ;
8565 PyObject * obj1 = 0 ;
8566 char * kwnames[] = {
8567 (char *) "self",(char *) "pt", NULL
8568 };
8569
8570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8572 if (!SWIG_IsOK(res1)) {
8573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8574 }
8575 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8576 {
8577 arg2 = &temp2;
8578 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8579 }
8580 {
8581 PyThreadState* __tstate = wxPyBeginAllowThreads();
8582 {
8583 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8584 result = (wxPoint2D *) &_result_ref;
8585 }
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj = 0;
8598 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8599 wxPoint2D *arg2 = 0 ;
8600 wxPoint2D *result = 0 ;
8601 void *argp1 = 0 ;
8602 int res1 = 0 ;
8603 wxPoint2D temp2 ;
8604 PyObject * obj0 = 0 ;
8605 PyObject * obj1 = 0 ;
8606 char * kwnames[] = {
8607 (char *) "self",(char *) "pt", NULL
8608 };
8609
8610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8612 if (!SWIG_IsOK(res1)) {
8613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8614 }
8615 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8616 {
8617 arg2 = &temp2;
8618 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8619 }
8620 {
8621 PyThreadState* __tstate = wxPyBeginAllowThreads();
8622 {
8623 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8624 result = (wxPoint2D *) &_result_ref;
8625 }
8626 wxPyEndAllowThreads(__tstate);
8627 if (PyErr_Occurred()) SWIG_fail;
8628 }
8629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8630 return resultobj;
8631 fail:
8632 return NULL;
8633 }
8634
8635
8636 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8637 PyObject *resultobj = 0;
8638 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8639 wxPoint2D *arg2 = 0 ;
8640 wxPoint2D *result = 0 ;
8641 void *argp1 = 0 ;
8642 int res1 = 0 ;
8643 wxPoint2D temp2 ;
8644 PyObject * obj0 = 0 ;
8645 PyObject * obj1 = 0 ;
8646 char * kwnames[] = {
8647 (char *) "self",(char *) "pt", NULL
8648 };
8649
8650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8652 if (!SWIG_IsOK(res1)) {
8653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8654 }
8655 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8656 {
8657 arg2 = &temp2;
8658 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8659 }
8660 {
8661 PyThreadState* __tstate = wxPyBeginAllowThreads();
8662 {
8663 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8664 result = (wxPoint2D *) &_result_ref;
8665 }
8666 wxPyEndAllowThreads(__tstate);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8670 return resultobj;
8671 fail:
8672 return NULL;
8673 }
8674
8675
8676 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8677 PyObject *resultobj = 0;
8678 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8679 PyObject *arg2 = (PyObject *) 0 ;
8680 bool result;
8681 void *argp1 = 0 ;
8682 int res1 = 0 ;
8683 PyObject * obj0 = 0 ;
8684 PyObject * obj1 = 0 ;
8685 char * kwnames[] = {
8686 (char *) "self",(char *) "other", NULL
8687 };
8688
8689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8691 if (!SWIG_IsOK(res1)) {
8692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8693 }
8694 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8695 arg2 = obj1;
8696 {
8697 result = (bool)wxPoint2D___eq__(arg1,arg2);
8698 if (PyErr_Occurred()) SWIG_fail;
8699 }
8700 {
8701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8702 }
8703 return resultobj;
8704 fail:
8705 return NULL;
8706 }
8707
8708
8709 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8710 PyObject *resultobj = 0;
8711 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8712 PyObject *arg2 = (PyObject *) 0 ;
8713 bool result;
8714 void *argp1 = 0 ;
8715 int res1 = 0 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 char * kwnames[] = {
8719 (char *) "self",(char *) "other", NULL
8720 };
8721
8722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8724 if (!SWIG_IsOK(res1)) {
8725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8726 }
8727 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8728 arg2 = obj1;
8729 {
8730 result = (bool)wxPoint2D___ne__(arg1,arg2);
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 {
8734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8735 }
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8743 PyObject *resultobj = 0;
8744 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8745 double arg2 ;
8746 void *argp1 = 0 ;
8747 int res1 = 0 ;
8748 double val2 ;
8749 int ecode2 = 0 ;
8750 PyObject *swig_obj[2] ;
8751
8752 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8754 if (!SWIG_IsOK(res1)) {
8755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8756 }
8757 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8758 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8759 if (!SWIG_IsOK(ecode2)) {
8760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8761 }
8762 arg2 = static_cast< double >(val2);
8763 if (arg1) (arg1)->m_x = arg2;
8764
8765 resultobj = SWIG_Py_Void();
8766 return resultobj;
8767 fail:
8768 return NULL;
8769 }
8770
8771
8772 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8773 PyObject *resultobj = 0;
8774 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8775 double result;
8776 void *argp1 = 0 ;
8777 int res1 = 0 ;
8778 PyObject *swig_obj[1] ;
8779
8780 if (!args) SWIG_fail;
8781 swig_obj[0] = args;
8782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8783 if (!SWIG_IsOK(res1)) {
8784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8785 }
8786 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8787 result = (double) ((arg1)->m_x);
8788 resultobj = SWIG_From_double(static_cast< double >(result));
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8796 PyObject *resultobj = 0;
8797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8798 double arg2 ;
8799 void *argp1 = 0 ;
8800 int res1 = 0 ;
8801 double val2 ;
8802 int ecode2 = 0 ;
8803 PyObject *swig_obj[2] ;
8804
8805 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8807 if (!SWIG_IsOK(res1)) {
8808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8809 }
8810 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8811 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8812 if (!SWIG_IsOK(ecode2)) {
8813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8814 }
8815 arg2 = static_cast< double >(val2);
8816 if (arg1) (arg1)->m_y = arg2;
8817
8818 resultobj = SWIG_Py_Void();
8819 return resultobj;
8820 fail:
8821 return NULL;
8822 }
8823
8824
8825 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8826 PyObject *resultobj = 0;
8827 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8828 double result;
8829 void *argp1 = 0 ;
8830 int res1 = 0 ;
8831 PyObject *swig_obj[1] ;
8832
8833 if (!args) SWIG_fail;
8834 swig_obj[0] = args;
8835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8836 if (!SWIG_IsOK(res1)) {
8837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8838 }
8839 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8840 result = (double) ((arg1)->m_y);
8841 resultobj = SWIG_From_double(static_cast< double >(result));
8842 return resultobj;
8843 fail:
8844 return NULL;
8845 }
8846
8847
8848 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8849 PyObject *resultobj = 0;
8850 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8851 double arg2 = (double) 0 ;
8852 double arg3 = (double) 0 ;
8853 void *argp1 = 0 ;
8854 int res1 = 0 ;
8855 double val2 ;
8856 int ecode2 = 0 ;
8857 double val3 ;
8858 int ecode3 = 0 ;
8859 PyObject * obj0 = 0 ;
8860 PyObject * obj1 = 0 ;
8861 PyObject * obj2 = 0 ;
8862 char * kwnames[] = {
8863 (char *) "self",(char *) "x",(char *) "y", NULL
8864 };
8865
8866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8868 if (!SWIG_IsOK(res1)) {
8869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8870 }
8871 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8872 if (obj1) {
8873 ecode2 = SWIG_AsVal_double(obj1, &val2);
8874 if (!SWIG_IsOK(ecode2)) {
8875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8876 }
8877 arg2 = static_cast< double >(val2);
8878 }
8879 if (obj2) {
8880 ecode3 = SWIG_AsVal_double(obj2, &val3);
8881 if (!SWIG_IsOK(ecode3)) {
8882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8883 }
8884 arg3 = static_cast< double >(val3);
8885 }
8886 {
8887 PyThreadState* __tstate = wxPyBeginAllowThreads();
8888 wxPoint2D_Set(arg1,arg2,arg3);
8889 wxPyEndAllowThreads(__tstate);
8890 if (PyErr_Occurred()) SWIG_fail;
8891 }
8892 resultobj = SWIG_Py_Void();
8893 return resultobj;
8894 fail:
8895 return NULL;
8896 }
8897
8898
8899 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8900 PyObject *resultobj = 0;
8901 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8902 PyObject *result = 0 ;
8903 void *argp1 = 0 ;
8904 int res1 = 0 ;
8905 PyObject *swig_obj[1] ;
8906
8907 if (!args) SWIG_fail;
8908 swig_obj[0] = args;
8909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8910 if (!SWIG_IsOK(res1)) {
8911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8912 }
8913 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 result = (PyObject *)wxPoint2D_Get(arg1);
8917 wxPyEndAllowThreads(__tstate);
8918 if (PyErr_Occurred()) SWIG_fail;
8919 }
8920 resultobj = result;
8921 return resultobj;
8922 fail:
8923 return NULL;
8924 }
8925
8926
8927 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8928 PyObject *obj;
8929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8930 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8931 return SWIG_Py_Void();
8932 }
8933
8934 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8935 return SWIG_Python_InitShadowInstance(args);
8936 }
8937
8938 SWIGINTERN int DefaultPosition_set(PyObject *) {
8939 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8940 return 1;
8941 }
8942
8943
8944 SWIGINTERN PyObject *DefaultPosition_get(void) {
8945 PyObject *pyobj = 0;
8946
8947 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8948 return pyobj;
8949 }
8950
8951
8952 SWIGINTERN int DefaultSize_set(PyObject *) {
8953 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8954 return 1;
8955 }
8956
8957
8958 SWIGINTERN PyObject *DefaultSize_get(void) {
8959 PyObject *pyobj = 0;
8960
8961 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8962 return pyobj;
8963 }
8964
8965
8966 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8967 PyObject *resultobj = 0;
8968 PyObject *arg1 = (PyObject *) 0 ;
8969 wxPyInputStream *result = 0 ;
8970 PyObject * obj0 = 0 ;
8971 char * kwnames[] = {
8972 (char *) "p", NULL
8973 };
8974
8975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8976 arg1 = obj0;
8977 {
8978 PyThreadState* __tstate = wxPyBeginAllowThreads();
8979 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8991 PyObject *resultobj = 0;
8992 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8993 void *argp1 = 0 ;
8994 int res1 = 0 ;
8995 PyObject *swig_obj[1] ;
8996
8997 if (!args) SWIG_fail;
8998 swig_obj[0] = args;
8999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9000 if (!SWIG_IsOK(res1)) {
9001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9002 }
9003 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 delete arg1;
9007
9008 wxPyEndAllowThreads(__tstate);
9009 if (PyErr_Occurred()) SWIG_fail;
9010 }
9011 resultobj = SWIG_Py_Void();
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9019 PyObject *resultobj = 0;
9020 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9021 void *argp1 = 0 ;
9022 int res1 = 0 ;
9023 PyObject *swig_obj[1] ;
9024
9025 if (!args) SWIG_fail;
9026 swig_obj[0] = args;
9027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9028 if (!SWIG_IsOK(res1)) {
9029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9030 }
9031 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9032 {
9033 PyThreadState* __tstate = wxPyBeginAllowThreads();
9034 (arg1)->close();
9035 wxPyEndAllowThreads(__tstate);
9036 if (PyErr_Occurred()) SWIG_fail;
9037 }
9038 resultobj = SWIG_Py_Void();
9039 return resultobj;
9040 fail:
9041 return NULL;
9042 }
9043
9044
9045 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9046 PyObject *resultobj = 0;
9047 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9048 void *argp1 = 0 ;
9049 int res1 = 0 ;
9050 PyObject *swig_obj[1] ;
9051
9052 if (!args) SWIG_fail;
9053 swig_obj[0] = args;
9054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9055 if (!SWIG_IsOK(res1)) {
9056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9057 }
9058 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9059 {
9060 PyThreadState* __tstate = wxPyBeginAllowThreads();
9061 (arg1)->flush();
9062 wxPyEndAllowThreads(__tstate);
9063 if (PyErr_Occurred()) SWIG_fail;
9064 }
9065 resultobj = SWIG_Py_Void();
9066 return resultobj;
9067 fail:
9068 return NULL;
9069 }
9070
9071
9072 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9073 PyObject *resultobj = 0;
9074 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9075 bool result;
9076 void *argp1 = 0 ;
9077 int res1 = 0 ;
9078 PyObject *swig_obj[1] ;
9079
9080 if (!args) SWIG_fail;
9081 swig_obj[0] = args;
9082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9083 if (!SWIG_IsOK(res1)) {
9084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9085 }
9086 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9087 {
9088 PyThreadState* __tstate = wxPyBeginAllowThreads();
9089 result = (bool)(arg1)->eof();
9090 wxPyEndAllowThreads(__tstate);
9091 if (PyErr_Occurred()) SWIG_fail;
9092 }
9093 {
9094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9095 }
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9103 PyObject *resultobj = 0;
9104 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9105 int arg2 = (int) -1 ;
9106 PyObject *result = 0 ;
9107 void *argp1 = 0 ;
9108 int res1 = 0 ;
9109 int val2 ;
9110 int ecode2 = 0 ;
9111 PyObject * obj0 = 0 ;
9112 PyObject * obj1 = 0 ;
9113 char * kwnames[] = {
9114 (char *) "self",(char *) "size", NULL
9115 };
9116
9117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9121 }
9122 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9123 if (obj1) {
9124 ecode2 = SWIG_AsVal_int(obj1, &val2);
9125 if (!SWIG_IsOK(ecode2)) {
9126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9127 }
9128 arg2 = static_cast< int >(val2);
9129 }
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 result = (PyObject *)(arg1)->read(arg2);
9133 wxPyEndAllowThreads(__tstate);
9134 if (PyErr_Occurred()) SWIG_fail;
9135 }
9136 resultobj = result;
9137 return resultobj;
9138 fail:
9139 return NULL;
9140 }
9141
9142
9143 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9144 PyObject *resultobj = 0;
9145 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9146 int arg2 = (int) -1 ;
9147 PyObject *result = 0 ;
9148 void *argp1 = 0 ;
9149 int res1 = 0 ;
9150 int val2 ;
9151 int ecode2 = 0 ;
9152 PyObject * obj0 = 0 ;
9153 PyObject * obj1 = 0 ;
9154 char * kwnames[] = {
9155 (char *) "self",(char *) "size", NULL
9156 };
9157
9158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9160 if (!SWIG_IsOK(res1)) {
9161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9162 }
9163 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9164 if (obj1) {
9165 ecode2 = SWIG_AsVal_int(obj1, &val2);
9166 if (!SWIG_IsOK(ecode2)) {
9167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9168 }
9169 arg2 = static_cast< int >(val2);
9170 }
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 result = (PyObject *)(arg1)->readline(arg2);
9174 wxPyEndAllowThreads(__tstate);
9175 if (PyErr_Occurred()) SWIG_fail;
9176 }
9177 resultobj = result;
9178 return resultobj;
9179 fail:
9180 return NULL;
9181 }
9182
9183
9184 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9185 PyObject *resultobj = 0;
9186 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9187 int arg2 = (int) -1 ;
9188 PyObject *result = 0 ;
9189 void *argp1 = 0 ;
9190 int res1 = 0 ;
9191 int val2 ;
9192 int ecode2 = 0 ;
9193 PyObject * obj0 = 0 ;
9194 PyObject * obj1 = 0 ;
9195 char * kwnames[] = {
9196 (char *) "self",(char *) "sizehint", NULL
9197 };
9198
9199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9201 if (!SWIG_IsOK(res1)) {
9202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9203 }
9204 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9205 if (obj1) {
9206 ecode2 = SWIG_AsVal_int(obj1, &val2);
9207 if (!SWIG_IsOK(ecode2)) {
9208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9209 }
9210 arg2 = static_cast< int >(val2);
9211 }
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 result = (PyObject *)(arg1)->readlines(arg2);
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 resultobj = result;
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9226 PyObject *resultobj = 0;
9227 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9228 int arg2 ;
9229 int arg3 = (int) 0 ;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 int val2 ;
9233 int ecode2 = 0 ;
9234 int val3 ;
9235 int ecode3 = 0 ;
9236 PyObject * obj0 = 0 ;
9237 PyObject * obj1 = 0 ;
9238 PyObject * obj2 = 0 ;
9239 char * kwnames[] = {
9240 (char *) "self",(char *) "offset",(char *) "whence", NULL
9241 };
9242
9243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9245 if (!SWIG_IsOK(res1)) {
9246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9247 }
9248 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9249 ecode2 = SWIG_AsVal_int(obj1, &val2);
9250 if (!SWIG_IsOK(ecode2)) {
9251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9252 }
9253 arg2 = static_cast< int >(val2);
9254 if (obj2) {
9255 ecode3 = SWIG_AsVal_int(obj2, &val3);
9256 if (!SWIG_IsOK(ecode3)) {
9257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9258 }
9259 arg3 = static_cast< int >(val3);
9260 }
9261 {
9262 PyThreadState* __tstate = wxPyBeginAllowThreads();
9263 (arg1)->seek(arg2,arg3);
9264 wxPyEndAllowThreads(__tstate);
9265 if (PyErr_Occurred()) SWIG_fail;
9266 }
9267 resultobj = SWIG_Py_Void();
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9275 PyObject *resultobj = 0;
9276 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9277 int result;
9278 void *argp1 = 0 ;
9279 int res1 = 0 ;
9280 PyObject *swig_obj[1] ;
9281
9282 if (!args) SWIG_fail;
9283 swig_obj[0] = args;
9284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9285 if (!SWIG_IsOK(res1)) {
9286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9287 }
9288 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9289 {
9290 PyThreadState* __tstate = wxPyBeginAllowThreads();
9291 result = (int)(arg1)->tell();
9292 wxPyEndAllowThreads(__tstate);
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 resultobj = SWIG_From_int(static_cast< int >(result));
9296 return resultobj;
9297 fail:
9298 return NULL;
9299 }
9300
9301
9302 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9303 PyObject *resultobj = 0;
9304 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9305 char result;
9306 void *argp1 = 0 ;
9307 int res1 = 0 ;
9308 PyObject *swig_obj[1] ;
9309
9310 if (!args) SWIG_fail;
9311 swig_obj[0] = args;
9312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9313 if (!SWIG_IsOK(res1)) {
9314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9315 }
9316 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 result = (char)(arg1)->Peek();
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 resultobj = SWIG_From_char(static_cast< char >(result));
9324 return resultobj;
9325 fail:
9326 return NULL;
9327 }
9328
9329
9330 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9331 PyObject *resultobj = 0;
9332 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9333 char result;
9334 void *argp1 = 0 ;
9335 int res1 = 0 ;
9336 PyObject *swig_obj[1] ;
9337
9338 if (!args) SWIG_fail;
9339 swig_obj[0] = args;
9340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9341 if (!SWIG_IsOK(res1)) {
9342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9343 }
9344 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9345 {
9346 PyThreadState* __tstate = wxPyBeginAllowThreads();
9347 result = (char)(arg1)->GetC();
9348 wxPyEndAllowThreads(__tstate);
9349 if (PyErr_Occurred()) SWIG_fail;
9350 }
9351 resultobj = SWIG_From_char(static_cast< char >(result));
9352 return resultobj;
9353 fail:
9354 return NULL;
9355 }
9356
9357
9358 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9359 PyObject *resultobj = 0;
9360 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9361 size_t result;
9362 void *argp1 = 0 ;
9363 int res1 = 0 ;
9364 PyObject *swig_obj[1] ;
9365
9366 if (!args) SWIG_fail;
9367 swig_obj[0] = args;
9368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9369 if (!SWIG_IsOK(res1)) {
9370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9371 }
9372 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9373 {
9374 PyThreadState* __tstate = wxPyBeginAllowThreads();
9375 result = (size_t)(arg1)->LastRead();
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9380 return resultobj;
9381 fail:
9382 return NULL;
9383 }
9384
9385
9386 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9387 PyObject *resultobj = 0;
9388 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9389 bool result;
9390 void *argp1 = 0 ;
9391 int res1 = 0 ;
9392 PyObject *swig_obj[1] ;
9393
9394 if (!args) SWIG_fail;
9395 swig_obj[0] = args;
9396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9397 if (!SWIG_IsOK(res1)) {
9398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9399 }
9400 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 result = (bool)(arg1)->CanRead();
9404 wxPyEndAllowThreads(__tstate);
9405 if (PyErr_Occurred()) SWIG_fail;
9406 }
9407 {
9408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9409 }
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9417 PyObject *resultobj = 0;
9418 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9419 bool result;
9420 void *argp1 = 0 ;
9421 int res1 = 0 ;
9422 PyObject *swig_obj[1] ;
9423
9424 if (!args) SWIG_fail;
9425 swig_obj[0] = args;
9426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9427 if (!SWIG_IsOK(res1)) {
9428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9429 }
9430 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9431 {
9432 PyThreadState* __tstate = wxPyBeginAllowThreads();
9433 result = (bool)(arg1)->Eof();
9434 wxPyEndAllowThreads(__tstate);
9435 if (PyErr_Occurred()) SWIG_fail;
9436 }
9437 {
9438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9439 }
9440 return resultobj;
9441 fail:
9442 return NULL;
9443 }
9444
9445
9446 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9447 PyObject *resultobj = 0;
9448 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9449 char arg2 ;
9450 bool result;
9451 void *argp1 = 0 ;
9452 int res1 = 0 ;
9453 char val2 ;
9454 int ecode2 = 0 ;
9455 PyObject * obj0 = 0 ;
9456 PyObject * obj1 = 0 ;
9457 char * kwnames[] = {
9458 (char *) "self",(char *) "c", NULL
9459 };
9460
9461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9463 if (!SWIG_IsOK(res1)) {
9464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9465 }
9466 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9467 ecode2 = SWIG_AsVal_char(obj1, &val2);
9468 if (!SWIG_IsOK(ecode2)) {
9469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9470 }
9471 arg2 = static_cast< char >(val2);
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (bool)(arg1)->Ungetch(arg2);
9475 wxPyEndAllowThreads(__tstate);
9476 if (PyErr_Occurred()) SWIG_fail;
9477 }
9478 {
9479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9480 }
9481 return resultobj;
9482 fail:
9483 return NULL;
9484 }
9485
9486
9487 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9488 PyObject *resultobj = 0;
9489 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9490 long arg2 ;
9491 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9492 long result;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 long val2 ;
9496 int ecode2 = 0 ;
9497 int val3 ;
9498 int ecode3 = 0 ;
9499 PyObject * obj0 = 0 ;
9500 PyObject * obj1 = 0 ;
9501 PyObject * obj2 = 0 ;
9502 char * kwnames[] = {
9503 (char *) "self",(char *) "pos",(char *) "mode", NULL
9504 };
9505
9506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9508 if (!SWIG_IsOK(res1)) {
9509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9510 }
9511 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9512 ecode2 = SWIG_AsVal_long(obj1, &val2);
9513 if (!SWIG_IsOK(ecode2)) {
9514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9515 }
9516 arg2 = static_cast< long >(val2);
9517 if (obj2) {
9518 ecode3 = SWIG_AsVal_int(obj2, &val3);
9519 if (!SWIG_IsOK(ecode3)) {
9520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9521 }
9522 arg3 = static_cast< wxSeekMode >(val3);
9523 }
9524 {
9525 PyThreadState* __tstate = wxPyBeginAllowThreads();
9526 result = (long)(arg1)->SeekI(arg2,arg3);
9527 wxPyEndAllowThreads(__tstate);
9528 if (PyErr_Occurred()) SWIG_fail;
9529 }
9530 resultobj = SWIG_From_long(static_cast< long >(result));
9531 return resultobj;
9532 fail:
9533 return NULL;
9534 }
9535
9536
9537 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9538 PyObject *resultobj = 0;
9539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9540 long result;
9541 void *argp1 = 0 ;
9542 int res1 = 0 ;
9543 PyObject *swig_obj[1] ;
9544
9545 if (!args) SWIG_fail;
9546 swig_obj[0] = args;
9547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9548 if (!SWIG_IsOK(res1)) {
9549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9550 }
9551 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9552 {
9553 PyThreadState* __tstate = wxPyBeginAllowThreads();
9554 result = (long)(arg1)->TellI();
9555 wxPyEndAllowThreads(__tstate);
9556 if (PyErr_Occurred()) SWIG_fail;
9557 }
9558 resultobj = SWIG_From_long(static_cast< long >(result));
9559 return resultobj;
9560 fail:
9561 return NULL;
9562 }
9563
9564
9565 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9566 PyObject *obj;
9567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9568 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9569 return SWIG_Py_Void();
9570 }
9571
9572 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9573 return SWIG_Python_InitShadowInstance(args);
9574 }
9575
9576 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9577 PyObject *resultobj = 0;
9578 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9579 PyObject *arg2 = (PyObject *) 0 ;
9580 void *argp1 = 0 ;
9581 int res1 = 0 ;
9582 PyObject * obj0 = 0 ;
9583 PyObject * obj1 = 0 ;
9584 char * kwnames[] = {
9585 (char *) "self",(char *) "obj", NULL
9586 };
9587
9588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9590 if (!SWIG_IsOK(res1)) {
9591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9592 }
9593 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9594 arg2 = obj1;
9595 {
9596 PyThreadState* __tstate = wxPyBeginAllowThreads();
9597 wxOutputStream_write(arg1,arg2);
9598 wxPyEndAllowThreads(__tstate);
9599 if (PyErr_Occurred()) SWIG_fail;
9600 }
9601 resultobj = SWIG_Py_Void();
9602 return resultobj;
9603 fail:
9604 return NULL;
9605 }
9606
9607
9608 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9609 PyObject *resultobj = 0;
9610 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9611 size_t result;
9612 void *argp1 = 0 ;
9613 int res1 = 0 ;
9614 PyObject *swig_obj[1] ;
9615
9616 if (!args) SWIG_fail;
9617 swig_obj[0] = args;
9618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9619 if (!SWIG_IsOK(res1)) {
9620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9621 }
9622 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9626 wxPyEndAllowThreads(__tstate);
9627 if (PyErr_Occurred()) SWIG_fail;
9628 }
9629 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9630 return resultobj;
9631 fail:
9632 return NULL;
9633 }
9634
9635
9636 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9637 PyObject *obj;
9638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9639 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9640 return SWIG_Py_Void();
9641 }
9642
9643 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9644 PyObject *resultobj = 0;
9645 wxInputStream *arg1 = (wxInputStream *) 0 ;
9646 wxString *arg2 = 0 ;
9647 wxString *arg3 = 0 ;
9648 wxString *arg4 = 0 ;
9649 wxDateTime arg5 ;
9650 wxFSFile *result = 0 ;
9651 wxPyInputStream *temp1 ;
9652 bool temp2 = false ;
9653 bool temp3 = false ;
9654 bool temp4 = false ;
9655 void *argp5 ;
9656 int res5 = 0 ;
9657 PyObject * obj0 = 0 ;
9658 PyObject * obj1 = 0 ;
9659 PyObject * obj2 = 0 ;
9660 PyObject * obj3 = 0 ;
9661 PyObject * obj4 = 0 ;
9662 char * kwnames[] = {
9663 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9664 };
9665
9666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9667 {
9668 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9669 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9670 } else {
9671 PyErr_Clear(); // clear the failure of the wxPyConvert above
9672 arg1 = wxPyCBInputStream_create(obj0, true);
9673 if (arg1 == NULL) {
9674 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9675 SWIG_fail;
9676 }
9677 }
9678 }
9679 {
9680 arg2 = wxString_in_helper(obj1);
9681 if (arg2 == NULL) SWIG_fail;
9682 temp2 = true;
9683 }
9684 {
9685 arg3 = wxString_in_helper(obj2);
9686 if (arg3 == NULL) SWIG_fail;
9687 temp3 = true;
9688 }
9689 {
9690 arg4 = wxString_in_helper(obj3);
9691 if (arg4 == NULL) SWIG_fail;
9692 temp4 = true;
9693 }
9694 {
9695 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9696 if (!SWIG_IsOK(res5)) {
9697 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9698 }
9699 if (!argp5) {
9700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9701 } else {
9702 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9703 arg5 = *temp;
9704 if (SWIG_IsNewObj(res5)) delete temp;
9705 }
9706 }
9707 {
9708 PyThreadState* __tstate = wxPyBeginAllowThreads();
9709 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9710 wxPyEndAllowThreads(__tstate);
9711 if (PyErr_Occurred()) SWIG_fail;
9712 }
9713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9714 {
9715 if (temp2)
9716 delete arg2;
9717 }
9718 {
9719 if (temp3)
9720 delete arg3;
9721 }
9722 {
9723 if (temp4)
9724 delete arg4;
9725 }
9726 return resultobj;
9727 fail:
9728 {
9729 if (temp2)
9730 delete arg2;
9731 }
9732 {
9733 if (temp3)
9734 delete arg3;
9735 }
9736 {
9737 if (temp4)
9738 delete arg4;
9739 }
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9745 PyObject *resultobj = 0;
9746 wxFSFile *arg1 = (wxFSFile *) 0 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 PyObject *swig_obj[1] ;
9750
9751 if (!args) SWIG_fail;
9752 swig_obj[0] = args;
9753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9754 if (!SWIG_IsOK(res1)) {
9755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9756 }
9757 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9758 {
9759 PyThreadState* __tstate = wxPyBeginAllowThreads();
9760 delete arg1;
9761
9762 wxPyEndAllowThreads(__tstate);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_Py_Void();
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9773 PyObject *resultobj = 0;
9774 wxFSFile *arg1 = (wxFSFile *) 0 ;
9775 wxInputStream *result = 0 ;
9776 void *argp1 = 0 ;
9777 int res1 = 0 ;
9778 PyObject *swig_obj[1] ;
9779
9780 if (!args) SWIG_fail;
9781 swig_obj[0] = args;
9782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9783 if (!SWIG_IsOK(res1)) {
9784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9785 }
9786 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9787 {
9788 PyThreadState* __tstate = wxPyBeginAllowThreads();
9789 result = (wxInputStream *)(arg1)->GetStream();
9790 wxPyEndAllowThreads(__tstate);
9791 if (PyErr_Occurred()) SWIG_fail;
9792 }
9793 {
9794 wxPyInputStream * _ptr = NULL;
9795
9796 if (result) {
9797 _ptr = new wxPyInputStream(result);
9798 }
9799 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9800 }
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9808 PyObject *resultobj = 0;
9809 wxFSFile *arg1 = (wxFSFile *) 0 ;
9810 wxString *result = 0 ;
9811 void *argp1 = 0 ;
9812 int res1 = 0 ;
9813 PyObject *swig_obj[1] ;
9814
9815 if (!args) SWIG_fail;
9816 swig_obj[0] = args;
9817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9818 if (!SWIG_IsOK(res1)) {
9819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9820 }
9821 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9822 {
9823 PyThreadState* __tstate = wxPyBeginAllowThreads();
9824 {
9825 wxString const &_result_ref = (arg1)->GetMimeType();
9826 result = (wxString *) &_result_ref;
9827 }
9828 wxPyEndAllowThreads(__tstate);
9829 if (PyErr_Occurred()) SWIG_fail;
9830 }
9831 {
9832 #if wxUSE_UNICODE
9833 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9834 #else
9835 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9836 #endif
9837 }
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9845 PyObject *resultobj = 0;
9846 wxFSFile *arg1 = (wxFSFile *) 0 ;
9847 wxString *result = 0 ;
9848 void *argp1 = 0 ;
9849 int res1 = 0 ;
9850 PyObject *swig_obj[1] ;
9851
9852 if (!args) SWIG_fail;
9853 swig_obj[0] = args;
9854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9855 if (!SWIG_IsOK(res1)) {
9856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9857 }
9858 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9859 {
9860 PyThreadState* __tstate = wxPyBeginAllowThreads();
9861 {
9862 wxString const &_result_ref = (arg1)->GetLocation();
9863 result = (wxString *) &_result_ref;
9864 }
9865 wxPyEndAllowThreads(__tstate);
9866 if (PyErr_Occurred()) SWIG_fail;
9867 }
9868 {
9869 #if wxUSE_UNICODE
9870 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9871 #else
9872 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9873 #endif
9874 }
9875 return resultobj;
9876 fail:
9877 return NULL;
9878 }
9879
9880
9881 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9882 PyObject *resultobj = 0;
9883 wxFSFile *arg1 = (wxFSFile *) 0 ;
9884 wxString *result = 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 PyObject *swig_obj[1] ;
9888
9889 if (!args) SWIG_fail;
9890 swig_obj[0] = args;
9891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9892 if (!SWIG_IsOK(res1)) {
9893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9894 }
9895 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 {
9899 wxString const &_result_ref = (arg1)->GetAnchor();
9900 result = (wxString *) &_result_ref;
9901 }
9902 wxPyEndAllowThreads(__tstate);
9903 if (PyErr_Occurred()) SWIG_fail;
9904 }
9905 {
9906 #if wxUSE_UNICODE
9907 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9908 #else
9909 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9910 #endif
9911 }
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9919 PyObject *resultobj = 0;
9920 wxFSFile *arg1 = (wxFSFile *) 0 ;
9921 wxDateTime result;
9922 void *argp1 = 0 ;
9923 int res1 = 0 ;
9924 PyObject *swig_obj[1] ;
9925
9926 if (!args) SWIG_fail;
9927 swig_obj[0] = args;
9928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9931 }
9932 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (arg1)->GetModificationTime();
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947 PyObject *obj;
9948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9949 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9950 return SWIG_Py_Void();
9951 }
9952
9953 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9954 return SWIG_Python_InitShadowInstance(args);
9955 }
9956
9957 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9958 PyObject *resultobj = 0;
9959 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9960 void *argp1 = 0 ;
9961 int res1 = 0 ;
9962 PyObject *swig_obj[1] ;
9963
9964 if (!args) SWIG_fail;
9965 swig_obj[0] = args;
9966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9967 if (!SWIG_IsOK(res1)) {
9968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9969 }
9970 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9971 {
9972 PyThreadState* __tstate = wxPyBeginAllowThreads();
9973 delete arg1;
9974
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_Py_Void();
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9986 PyObject *obj;
9987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9988 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9989 return SWIG_Py_Void();
9990 }
9991
9992 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9993 PyObject *resultobj = 0;
9994 wxPyFileSystemHandler *result = 0 ;
9995
9996 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10000 wxPyEndAllowThreads(__tstate);
10001 if (PyErr_Occurred()) SWIG_fail;
10002 }
10003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10004 return resultobj;
10005 fail:
10006 return NULL;
10007 }
10008
10009
10010 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10011 PyObject *resultobj = 0;
10012 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10013 PyObject *arg2 = (PyObject *) 0 ;
10014 PyObject *arg3 = (PyObject *) 0 ;
10015 void *argp1 = 0 ;
10016 int res1 = 0 ;
10017 PyObject * obj0 = 0 ;
10018 PyObject * obj1 = 0 ;
10019 PyObject * obj2 = 0 ;
10020 char * kwnames[] = {
10021 (char *) "self",(char *) "self",(char *) "_class", NULL
10022 };
10023
10024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10026 if (!SWIG_IsOK(res1)) {
10027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10028 }
10029 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10030 arg2 = obj1;
10031 arg3 = obj2;
10032 {
10033 PyThreadState* __tstate = wxPyBeginAllowThreads();
10034 (arg1)->_setCallbackInfo(arg2,arg3);
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 resultobj = SWIG_Py_Void();
10039 return resultobj;
10040 fail:
10041 return NULL;
10042 }
10043
10044
10045 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj = 0;
10047 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10048 wxString *arg2 = 0 ;
10049 bool result;
10050 void *argp1 = 0 ;
10051 int res1 = 0 ;
10052 bool temp2 = false ;
10053 PyObject * obj0 = 0 ;
10054 PyObject * obj1 = 0 ;
10055 char * kwnames[] = {
10056 (char *) "self",(char *) "location", NULL
10057 };
10058
10059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10061 if (!SWIG_IsOK(res1)) {
10062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10063 }
10064 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10065 {
10066 arg2 = wxString_in_helper(obj1);
10067 if (arg2 == NULL) SWIG_fail;
10068 temp2 = true;
10069 }
10070 {
10071 PyThreadState* __tstate = wxPyBeginAllowThreads();
10072 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10073 wxPyEndAllowThreads(__tstate);
10074 if (PyErr_Occurred()) SWIG_fail;
10075 }
10076 {
10077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10078 }
10079 {
10080 if (temp2)
10081 delete arg2;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp2)
10087 delete arg2;
10088 }
10089 return NULL;
10090 }
10091
10092
10093 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj = 0;
10095 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10096 wxFileSystem *arg2 = 0 ;
10097 wxString *arg3 = 0 ;
10098 wxFSFile *result = 0 ;
10099 void *argp1 = 0 ;
10100 int res1 = 0 ;
10101 void *argp2 = 0 ;
10102 int res2 = 0 ;
10103 bool temp3 = false ;
10104 PyObject * obj0 = 0 ;
10105 PyObject * obj1 = 0 ;
10106 PyObject * obj2 = 0 ;
10107 char * kwnames[] = {
10108 (char *) "self",(char *) "fs",(char *) "location", NULL
10109 };
10110
10111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10113 if (!SWIG_IsOK(res1)) {
10114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10115 }
10116 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10117 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10118 if (!SWIG_IsOK(res2)) {
10119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10120 }
10121 if (!argp2) {
10122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10123 }
10124 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10125 {
10126 arg3 = wxString_in_helper(obj2);
10127 if (arg3 == NULL) SWIG_fail;
10128 temp3 = true;
10129 }
10130 {
10131 PyThreadState* __tstate = wxPyBeginAllowThreads();
10132 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 {
10137 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10138 }
10139 {
10140 if (temp3)
10141 delete arg3;
10142 }
10143 return resultobj;
10144 fail:
10145 {
10146 if (temp3)
10147 delete arg3;
10148 }
10149 return NULL;
10150 }
10151
10152
10153 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10154 PyObject *resultobj = 0;
10155 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10156 wxString *arg2 = 0 ;
10157 int arg3 = (int) 0 ;
10158 wxString result;
10159 void *argp1 = 0 ;
10160 int res1 = 0 ;
10161 bool temp2 = false ;
10162 int val3 ;
10163 int ecode3 = 0 ;
10164 PyObject * obj0 = 0 ;
10165 PyObject * obj1 = 0 ;
10166 PyObject * obj2 = 0 ;
10167 char * kwnames[] = {
10168 (char *) "self",(char *) "spec",(char *) "flags", NULL
10169 };
10170
10171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10173 if (!SWIG_IsOK(res1)) {
10174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10175 }
10176 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10177 {
10178 arg2 = wxString_in_helper(obj1);
10179 if (arg2 == NULL) SWIG_fail;
10180 temp2 = true;
10181 }
10182 if (obj2) {
10183 ecode3 = SWIG_AsVal_int(obj2, &val3);
10184 if (!SWIG_IsOK(ecode3)) {
10185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10186 }
10187 arg3 = static_cast< int >(val3);
10188 }
10189 {
10190 PyThreadState* __tstate = wxPyBeginAllowThreads();
10191 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10192 wxPyEndAllowThreads(__tstate);
10193 if (PyErr_Occurred()) SWIG_fail;
10194 }
10195 {
10196 #if wxUSE_UNICODE
10197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10198 #else
10199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10200 #endif
10201 }
10202 {
10203 if (temp2)
10204 delete arg2;
10205 }
10206 return resultobj;
10207 fail:
10208 {
10209 if (temp2)
10210 delete arg2;
10211 }
10212 return NULL;
10213 }
10214
10215
10216 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10217 PyObject *resultobj = 0;
10218 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10219 wxString result;
10220 void *argp1 = 0 ;
10221 int res1 = 0 ;
10222 PyObject *swig_obj[1] ;
10223
10224 if (!args) SWIG_fail;
10225 swig_obj[0] = args;
10226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10227 if (!SWIG_IsOK(res1)) {
10228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10229 }
10230 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10231 {
10232 PyThreadState* __tstate = wxPyBeginAllowThreads();
10233 result = (arg1)->FindNext();
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 {
10238 #if wxUSE_UNICODE
10239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10240 #else
10241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10242 #endif
10243 }
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = 0;
10252 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10253 wxString *arg2 = 0 ;
10254 wxString result;
10255 void *argp1 = 0 ;
10256 int res1 = 0 ;
10257 bool temp2 = false ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char * kwnames[] = {
10261 (char *) "self",(char *) "location", NULL
10262 };
10263
10264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10268 }
10269 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10270 {
10271 arg2 = wxString_in_helper(obj1);
10272 if (arg2 == NULL) SWIG_fail;
10273 temp2 = true;
10274 }
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 result = (arg1)->GetProtocol((wxString const &)*arg2);
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 {
10282 #if wxUSE_UNICODE
10283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10284 #else
10285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10286 #endif
10287 }
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return resultobj;
10293 fail:
10294 {
10295 if (temp2)
10296 delete arg2;
10297 }
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10305 wxString *arg2 = 0 ;
10306 wxString result;
10307 void *argp1 = 0 ;
10308 int res1 = 0 ;
10309 bool temp2 = false ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "location", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10320 }
10321 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10322 {
10323 arg2 = wxString_in_helper(obj1);
10324 if (arg2 == NULL) SWIG_fail;
10325 temp2 = true;
10326 }
10327 {
10328 PyThreadState* __tstate = wxPyBeginAllowThreads();
10329 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 {
10334 #if wxUSE_UNICODE
10335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10336 #else
10337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10338 #endif
10339 }
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return resultobj;
10345 fail:
10346 {
10347 if (temp2)
10348 delete arg2;
10349 }
10350 return NULL;
10351 }
10352
10353
10354 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10355 PyObject *resultobj = 0;
10356 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10357 wxString *arg2 = 0 ;
10358 wxString result;
10359 void *argp1 = 0 ;
10360 int res1 = 0 ;
10361 bool temp2 = false ;
10362 PyObject * obj0 = 0 ;
10363 PyObject * obj1 = 0 ;
10364 char * kwnames[] = {
10365 (char *) "self",(char *) "location", NULL
10366 };
10367
10368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10370 if (!SWIG_IsOK(res1)) {
10371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10372 }
10373 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10374 {
10375 arg2 = wxString_in_helper(obj1);
10376 if (arg2 == NULL) SWIG_fail;
10377 temp2 = true;
10378 }
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 result = (arg1)->GetAnchor((wxString const &)*arg2);
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 {
10386 #if wxUSE_UNICODE
10387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10388 #else
10389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10390 #endif
10391 }
10392 {
10393 if (temp2)
10394 delete arg2;
10395 }
10396 return resultobj;
10397 fail:
10398 {
10399 if (temp2)
10400 delete arg2;
10401 }
10402 return NULL;
10403 }
10404
10405
10406 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10407 PyObject *resultobj = 0;
10408 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10409 wxString *arg2 = 0 ;
10410 wxString result;
10411 void *argp1 = 0 ;
10412 int res1 = 0 ;
10413 bool temp2 = false ;
10414 PyObject * obj0 = 0 ;
10415 PyObject * obj1 = 0 ;
10416 char * kwnames[] = {
10417 (char *) "self",(char *) "location", NULL
10418 };
10419
10420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10422 if (!SWIG_IsOK(res1)) {
10423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10424 }
10425 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10426 {
10427 arg2 = wxString_in_helper(obj1);
10428 if (arg2 == NULL) SWIG_fail;
10429 temp2 = true;
10430 }
10431 {
10432 PyThreadState* __tstate = wxPyBeginAllowThreads();
10433 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10434 wxPyEndAllowThreads(__tstate);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 {
10438 #if wxUSE_UNICODE
10439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10440 #else
10441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10442 #endif
10443 }
10444 {
10445 if (temp2)
10446 delete arg2;
10447 }
10448 return resultobj;
10449 fail:
10450 {
10451 if (temp2)
10452 delete arg2;
10453 }
10454 return NULL;
10455 }
10456
10457
10458 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10459 PyObject *resultobj = 0;
10460 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10461 wxString *arg2 = 0 ;
10462 wxString result;
10463 void *argp1 = 0 ;
10464 int res1 = 0 ;
10465 bool temp2 = false ;
10466 PyObject * obj0 = 0 ;
10467 PyObject * obj1 = 0 ;
10468 char * kwnames[] = {
10469 (char *) "self",(char *) "location", NULL
10470 };
10471
10472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10474 if (!SWIG_IsOK(res1)) {
10475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10476 }
10477 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10478 {
10479 arg2 = wxString_in_helper(obj1);
10480 if (arg2 == NULL) SWIG_fail;
10481 temp2 = true;
10482 }
10483 {
10484 PyThreadState* __tstate = wxPyBeginAllowThreads();
10485 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10486 wxPyEndAllowThreads(__tstate);
10487 if (PyErr_Occurred()) SWIG_fail;
10488 }
10489 {
10490 #if wxUSE_UNICODE
10491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10492 #else
10493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10494 #endif
10495 }
10496 {
10497 if (temp2)
10498 delete arg2;
10499 }
10500 return resultobj;
10501 fail:
10502 {
10503 if (temp2)
10504 delete arg2;
10505 }
10506 return NULL;
10507 }
10508
10509
10510 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10511 PyObject *obj;
10512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10513 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10514 return SWIG_Py_Void();
10515 }
10516
10517 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10518 return SWIG_Python_InitShadowInstance(args);
10519 }
10520
10521 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10522 PyObject *resultobj = 0;
10523 wxFileSystem *result = 0 ;
10524
10525 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 result = (wxFileSystem *)new wxFileSystem();
10529 wxPyEndAllowThreads(__tstate);
10530 if (PyErr_Occurred()) SWIG_fail;
10531 }
10532 {
10533 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10534 }
10535 return resultobj;
10536 fail:
10537 return NULL;
10538 }
10539
10540
10541 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10542 PyObject *resultobj = 0;
10543 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10544 void *argp1 = 0 ;
10545 int res1 = 0 ;
10546 PyObject *swig_obj[1] ;
10547
10548 if (!args) SWIG_fail;
10549 swig_obj[0] = args;
10550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10553 }
10554 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 delete arg1;
10558
10559 wxPyEndAllowThreads(__tstate);
10560 if (PyErr_Occurred()) SWIG_fail;
10561 }
10562 resultobj = SWIG_Py_Void();
10563 return resultobj;
10564 fail:
10565 return NULL;
10566 }
10567
10568
10569 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10570 PyObject *resultobj = 0;
10571 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10572 wxString *arg2 = 0 ;
10573 bool arg3 = (bool) false ;
10574 void *argp1 = 0 ;
10575 int res1 = 0 ;
10576 bool temp2 = false ;
10577 bool val3 ;
10578 int ecode3 = 0 ;
10579 PyObject * obj0 = 0 ;
10580 PyObject * obj1 = 0 ;
10581 PyObject * obj2 = 0 ;
10582 char * kwnames[] = {
10583 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10584 };
10585
10586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10588 if (!SWIG_IsOK(res1)) {
10589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10590 }
10591 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10592 {
10593 arg2 = wxString_in_helper(obj1);
10594 if (arg2 == NULL) SWIG_fail;
10595 temp2 = true;
10596 }
10597 if (obj2) {
10598 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10599 if (!SWIG_IsOK(ecode3)) {
10600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10601 }
10602 arg3 = static_cast< bool >(val3);
10603 }
10604 {
10605 PyThreadState* __tstate = wxPyBeginAllowThreads();
10606 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10607 wxPyEndAllowThreads(__tstate);
10608 if (PyErr_Occurred()) SWIG_fail;
10609 }
10610 resultobj = SWIG_Py_Void();
10611 {
10612 if (temp2)
10613 delete arg2;
10614 }
10615 return resultobj;
10616 fail:
10617 {
10618 if (temp2)
10619 delete arg2;
10620 }
10621 return NULL;
10622 }
10623
10624
10625 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10626 PyObject *resultobj = 0;
10627 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10628 wxString result;
10629 void *argp1 = 0 ;
10630 int res1 = 0 ;
10631 PyObject *swig_obj[1] ;
10632
10633 if (!args) SWIG_fail;
10634 swig_obj[0] = args;
10635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10636 if (!SWIG_IsOK(res1)) {
10637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10638 }
10639 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10640 {
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 result = (arg1)->GetPath();
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 {
10647 #if wxUSE_UNICODE
10648 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10649 #else
10650 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10651 #endif
10652 }
10653 return resultobj;
10654 fail:
10655 return NULL;
10656 }
10657
10658
10659 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10660 PyObject *resultobj = 0;
10661 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10662 wxString *arg2 = 0 ;
10663 wxFSFile *result = 0 ;
10664 void *argp1 = 0 ;
10665 int res1 = 0 ;
10666 bool temp2 = false ;
10667 PyObject * obj0 = 0 ;
10668 PyObject * obj1 = 0 ;
10669 char * kwnames[] = {
10670 (char *) "self",(char *) "location", NULL
10671 };
10672
10673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10675 if (!SWIG_IsOK(res1)) {
10676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10677 }
10678 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10679 {
10680 arg2 = wxString_in_helper(obj1);
10681 if (arg2 == NULL) SWIG_fail;
10682 temp2 = true;
10683 }
10684 {
10685 PyThreadState* __tstate = wxPyBeginAllowThreads();
10686 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10687 wxPyEndAllowThreads(__tstate);
10688 if (PyErr_Occurred()) SWIG_fail;
10689 }
10690 {
10691 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10692 }
10693 {
10694 if (temp2)
10695 delete arg2;
10696 }
10697 return resultobj;
10698 fail:
10699 {
10700 if (temp2)
10701 delete arg2;
10702 }
10703 return NULL;
10704 }
10705
10706
10707 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10708 PyObject *resultobj = 0;
10709 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10710 wxString *arg2 = 0 ;
10711 int arg3 = (int) 0 ;
10712 wxString result;
10713 void *argp1 = 0 ;
10714 int res1 = 0 ;
10715 bool temp2 = false ;
10716 int val3 ;
10717 int ecode3 = 0 ;
10718 PyObject * obj0 = 0 ;
10719 PyObject * obj1 = 0 ;
10720 PyObject * obj2 = 0 ;
10721 char * kwnames[] = {
10722 (char *) "self",(char *) "spec",(char *) "flags", NULL
10723 };
10724
10725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10727 if (!SWIG_IsOK(res1)) {
10728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10729 }
10730 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10731 {
10732 arg2 = wxString_in_helper(obj1);
10733 if (arg2 == NULL) SWIG_fail;
10734 temp2 = true;
10735 }
10736 if (obj2) {
10737 ecode3 = SWIG_AsVal_int(obj2, &val3);
10738 if (!SWIG_IsOK(ecode3)) {
10739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10740 }
10741 arg3 = static_cast< int >(val3);
10742 }
10743 {
10744 PyThreadState* __tstate = wxPyBeginAllowThreads();
10745 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10746 wxPyEndAllowThreads(__tstate);
10747 if (PyErr_Occurred()) SWIG_fail;
10748 }
10749 {
10750 #if wxUSE_UNICODE
10751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10752 #else
10753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10754 #endif
10755 }
10756 {
10757 if (temp2)
10758 delete arg2;
10759 }
10760 return resultobj;
10761 fail:
10762 {
10763 if (temp2)
10764 delete arg2;
10765 }
10766 return NULL;
10767 }
10768
10769
10770 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10771 PyObject *resultobj = 0;
10772 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10773 wxString result;
10774 void *argp1 = 0 ;
10775 int res1 = 0 ;
10776 PyObject *swig_obj[1] ;
10777
10778 if (!args) SWIG_fail;
10779 swig_obj[0] = args;
10780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10781 if (!SWIG_IsOK(res1)) {
10782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10783 }
10784 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10785 {
10786 PyThreadState* __tstate = wxPyBeginAllowThreads();
10787 result = (arg1)->FindNext();
10788 wxPyEndAllowThreads(__tstate);
10789 if (PyErr_Occurred()) SWIG_fail;
10790 }
10791 {
10792 #if wxUSE_UNICODE
10793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10794 #else
10795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10796 #endif
10797 }
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj = 0;
10806 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10807 int res1 = 0 ;
10808 PyObject * obj0 = 0 ;
10809 char * kwnames[] = {
10810 (char *) "handler", NULL
10811 };
10812
10813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10814 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10815 if (!SWIG_IsOK(res1)) {
10816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10817 }
10818 {
10819 PyThreadState* __tstate = wxPyBeginAllowThreads();
10820 wxFileSystem::AddHandler(arg1);
10821 wxPyEndAllowThreads(__tstate);
10822 if (PyErr_Occurred()) SWIG_fail;
10823 }
10824 resultobj = SWIG_Py_Void();
10825 return resultobj;
10826 fail:
10827 return NULL;
10828 }
10829
10830
10831 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10832 PyObject *resultobj = 0;
10833
10834 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10835 {
10836 PyThreadState* __tstate = wxPyBeginAllowThreads();
10837 wxFileSystem::CleanUpHandlers();
10838 wxPyEndAllowThreads(__tstate);
10839 if (PyErr_Occurred()) SWIG_fail;
10840 }
10841 resultobj = SWIG_Py_Void();
10842 return resultobj;
10843 fail:
10844 return NULL;
10845 }
10846
10847
10848 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10849 PyObject *resultobj = 0;
10850 wxString *arg1 = 0 ;
10851 wxString result;
10852 bool temp1 = false ;
10853 PyObject * obj0 = 0 ;
10854 char * kwnames[] = {
10855 (char *) "filename", NULL
10856 };
10857
10858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10859 {
10860 arg1 = wxString_in_helper(obj0);
10861 if (arg1 == NULL) SWIG_fail;
10862 temp1 = true;
10863 }
10864 {
10865 PyThreadState* __tstate = wxPyBeginAllowThreads();
10866 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 {
10871 #if wxUSE_UNICODE
10872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10873 #else
10874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10875 #endif
10876 }
10877 {
10878 if (temp1)
10879 delete arg1;
10880 }
10881 return resultobj;
10882 fail:
10883 {
10884 if (temp1)
10885 delete arg1;
10886 }
10887 return NULL;
10888 }
10889
10890
10891 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10892 PyObject *resultobj = 0;
10893 wxString *arg1 = 0 ;
10894 wxString result;
10895 bool temp1 = false ;
10896 PyObject * obj0 = 0 ;
10897 char * kwnames[] = {
10898 (char *) "url", NULL
10899 };
10900
10901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10902 {
10903 arg1 = wxString_in_helper(obj0);
10904 if (arg1 == NULL) SWIG_fail;
10905 temp1 = true;
10906 }
10907 {
10908 PyThreadState* __tstate = wxPyBeginAllowThreads();
10909 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10910 wxPyEndAllowThreads(__tstate);
10911 if (PyErr_Occurred()) SWIG_fail;
10912 }
10913 {
10914 #if wxUSE_UNICODE
10915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10916 #else
10917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10918 #endif
10919 }
10920 {
10921 if (temp1)
10922 delete arg1;
10923 }
10924 return resultobj;
10925 fail:
10926 {
10927 if (temp1)
10928 delete arg1;
10929 }
10930 return NULL;
10931 }
10932
10933
10934 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10935 PyObject *obj;
10936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10937 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10938 return SWIG_Py_Void();
10939 }
10940
10941 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10942 return SWIG_Python_InitShadowInstance(args);
10943 }
10944
10945 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10946 PyObject *resultobj = 0;
10947 wxInternetFSHandler *result = 0 ;
10948
10949 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10950 {
10951 PyThreadState* __tstate = wxPyBeginAllowThreads();
10952 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10953 wxPyEndAllowThreads(__tstate);
10954 if (PyErr_Occurred()) SWIG_fail;
10955 }
10956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10957 return resultobj;
10958 fail:
10959 return NULL;
10960 }
10961
10962
10963 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10964 PyObject *resultobj = 0;
10965 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10966 wxString *arg2 = 0 ;
10967 bool result;
10968 void *argp1 = 0 ;
10969 int res1 = 0 ;
10970 bool temp2 = false ;
10971 PyObject * obj0 = 0 ;
10972 PyObject * obj1 = 0 ;
10973 char * kwnames[] = {
10974 (char *) "self",(char *) "location", NULL
10975 };
10976
10977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10979 if (!SWIG_IsOK(res1)) {
10980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10981 }
10982 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10983 {
10984 arg2 = wxString_in_helper(obj1);
10985 if (arg2 == NULL) SWIG_fail;
10986 temp2 = true;
10987 }
10988 {
10989 PyThreadState* __tstate = wxPyBeginAllowThreads();
10990 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10991 wxPyEndAllowThreads(__tstate);
10992 if (PyErr_Occurred()) SWIG_fail;
10993 }
10994 {
10995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10996 }
10997 {
10998 if (temp2)
10999 delete arg2;
11000 }
11001 return resultobj;
11002 fail:
11003 {
11004 if (temp2)
11005 delete arg2;
11006 }
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11012 PyObject *resultobj = 0;
11013 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11014 wxFileSystem *arg2 = 0 ;
11015 wxString *arg3 = 0 ;
11016 wxFSFile *result = 0 ;
11017 void *argp1 = 0 ;
11018 int res1 = 0 ;
11019 void *argp2 = 0 ;
11020 int res2 = 0 ;
11021 bool temp3 = false ;
11022 PyObject * obj0 = 0 ;
11023 PyObject * obj1 = 0 ;
11024 PyObject * obj2 = 0 ;
11025 char * kwnames[] = {
11026 (char *) "self",(char *) "fs",(char *) "location", NULL
11027 };
11028
11029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11031 if (!SWIG_IsOK(res1)) {
11032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11033 }
11034 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11035 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11036 if (!SWIG_IsOK(res2)) {
11037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11038 }
11039 if (!argp2) {
11040 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11041 }
11042 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11043 {
11044 arg3 = wxString_in_helper(obj2);
11045 if (arg3 == NULL) SWIG_fail;
11046 temp3 = true;
11047 }
11048 {
11049 PyThreadState* __tstate = wxPyBeginAllowThreads();
11050 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11051 wxPyEndAllowThreads(__tstate);
11052 if (PyErr_Occurred()) SWIG_fail;
11053 }
11054 {
11055 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11056 }
11057 {
11058 if (temp3)
11059 delete arg3;
11060 }
11061 return resultobj;
11062 fail:
11063 {
11064 if (temp3)
11065 delete arg3;
11066 }
11067 return NULL;
11068 }
11069
11070
11071 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11072 PyObject *obj;
11073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11074 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11075 return SWIG_Py_Void();
11076 }
11077
11078 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11079 return SWIG_Python_InitShadowInstance(args);
11080 }
11081
11082 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11083 PyObject *resultobj = 0;
11084 wxZipFSHandler *result = 0 ;
11085
11086 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11087 {
11088 PyThreadState* __tstate = wxPyBeginAllowThreads();
11089 result = (wxZipFSHandler *)new wxZipFSHandler();
11090 wxPyEndAllowThreads(__tstate);
11091 if (PyErr_Occurred()) SWIG_fail;
11092 }
11093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11094 return resultobj;
11095 fail:
11096 return NULL;
11097 }
11098
11099
11100 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11101 PyObject *resultobj = 0;
11102 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11103 wxString *arg2 = 0 ;
11104 bool result;
11105 void *argp1 = 0 ;
11106 int res1 = 0 ;
11107 bool temp2 = false ;
11108 PyObject * obj0 = 0 ;
11109 PyObject * obj1 = 0 ;
11110 char * kwnames[] = {
11111 (char *) "self",(char *) "location", NULL
11112 };
11113
11114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11116 if (!SWIG_IsOK(res1)) {
11117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11118 }
11119 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11120 {
11121 arg2 = wxString_in_helper(obj1);
11122 if (arg2 == NULL) SWIG_fail;
11123 temp2 = true;
11124 }
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11128 wxPyEndAllowThreads(__tstate);
11129 if (PyErr_Occurred()) SWIG_fail;
11130 }
11131 {
11132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11133 }
11134 {
11135 if (temp2)
11136 delete arg2;
11137 }
11138 return resultobj;
11139 fail:
11140 {
11141 if (temp2)
11142 delete arg2;
11143 }
11144 return NULL;
11145 }
11146
11147
11148 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj = 0;
11150 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11151 wxFileSystem *arg2 = 0 ;
11152 wxString *arg3 = 0 ;
11153 wxFSFile *result = 0 ;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 void *argp2 = 0 ;
11157 int res2 = 0 ;
11158 bool temp3 = false ;
11159 PyObject * obj0 = 0 ;
11160 PyObject * obj1 = 0 ;
11161 PyObject * obj2 = 0 ;
11162 char * kwnames[] = {
11163 (char *) "self",(char *) "fs",(char *) "location", NULL
11164 };
11165
11166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11168 if (!SWIG_IsOK(res1)) {
11169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11170 }
11171 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11173 if (!SWIG_IsOK(res2)) {
11174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11175 }
11176 if (!argp2) {
11177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11178 }
11179 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11180 {
11181 arg3 = wxString_in_helper(obj2);
11182 if (arg3 == NULL) SWIG_fail;
11183 temp3 = true;
11184 }
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11188 wxPyEndAllowThreads(__tstate);
11189 if (PyErr_Occurred()) SWIG_fail;
11190 }
11191 {
11192 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11193 }
11194 {
11195 if (temp3)
11196 delete arg3;
11197 }
11198 return resultobj;
11199 fail:
11200 {
11201 if (temp3)
11202 delete arg3;
11203 }
11204 return NULL;
11205 }
11206
11207
11208 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11209 PyObject *resultobj = 0;
11210 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11211 wxString *arg2 = 0 ;
11212 int arg3 = (int) 0 ;
11213 wxString result;
11214 void *argp1 = 0 ;
11215 int res1 = 0 ;
11216 bool temp2 = false ;
11217 int val3 ;
11218 int ecode3 = 0 ;
11219 PyObject * obj0 = 0 ;
11220 PyObject * obj1 = 0 ;
11221 PyObject * obj2 = 0 ;
11222 char * kwnames[] = {
11223 (char *) "self",(char *) "spec",(char *) "flags", NULL
11224 };
11225
11226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11228 if (!SWIG_IsOK(res1)) {
11229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11230 }
11231 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11232 {
11233 arg2 = wxString_in_helper(obj1);
11234 if (arg2 == NULL) SWIG_fail;
11235 temp2 = true;
11236 }
11237 if (obj2) {
11238 ecode3 = SWIG_AsVal_int(obj2, &val3);
11239 if (!SWIG_IsOK(ecode3)) {
11240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11241 }
11242 arg3 = static_cast< int >(val3);
11243 }
11244 {
11245 PyThreadState* __tstate = wxPyBeginAllowThreads();
11246 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11247 wxPyEndAllowThreads(__tstate);
11248 if (PyErr_Occurred()) SWIG_fail;
11249 }
11250 {
11251 #if wxUSE_UNICODE
11252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11253 #else
11254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11255 #endif
11256 }
11257 {
11258 if (temp2)
11259 delete arg2;
11260 }
11261 return resultobj;
11262 fail:
11263 {
11264 if (temp2)
11265 delete arg2;
11266 }
11267 return NULL;
11268 }
11269
11270
11271 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11272 PyObject *resultobj = 0;
11273 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11274 wxString result;
11275 void *argp1 = 0 ;
11276 int res1 = 0 ;
11277 PyObject *swig_obj[1] ;
11278
11279 if (!args) SWIG_fail;
11280 swig_obj[0] = args;
11281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11282 if (!SWIG_IsOK(res1)) {
11283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11284 }
11285 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 result = (arg1)->FindNext();
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 {
11293 #if wxUSE_UNICODE
11294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11295 #else
11296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11297 #endif
11298 }
11299 return resultobj;
11300 fail:
11301 return NULL;
11302 }
11303
11304
11305 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11306 PyObject *obj;
11307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11308 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11309 return SWIG_Py_Void();
11310 }
11311
11312 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11313 return SWIG_Python_InitShadowInstance(args);
11314 }
11315
11316 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11317 PyObject *resultobj = 0;
11318 wxString *arg1 = 0 ;
11319 wxImage *arg2 = 0 ;
11320 long arg3 ;
11321 bool temp1 = false ;
11322 void *argp2 = 0 ;
11323 int res2 = 0 ;
11324 long val3 ;
11325 int ecode3 = 0 ;
11326 PyObject * obj0 = 0 ;
11327 PyObject * obj1 = 0 ;
11328 PyObject * obj2 = 0 ;
11329 char * kwnames[] = {
11330 (char *) "filename",(char *) "image",(char *) "type", NULL
11331 };
11332
11333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11334 {
11335 arg1 = wxString_in_helper(obj0);
11336 if (arg1 == NULL) SWIG_fail;
11337 temp1 = true;
11338 }
11339 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11340 if (!SWIG_IsOK(res2)) {
11341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11342 }
11343 if (!argp2) {
11344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11345 }
11346 arg2 = reinterpret_cast< wxImage * >(argp2);
11347 ecode3 = SWIG_AsVal_long(obj2, &val3);
11348 if (!SWIG_IsOK(ecode3)) {
11349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11350 }
11351 arg3 = static_cast< long >(val3);
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 {
11360 if (temp1)
11361 delete arg1;
11362 }
11363 return resultobj;
11364 fail:
11365 {
11366 if (temp1)
11367 delete arg1;
11368 }
11369 return NULL;
11370 }
11371
11372
11373 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 wxString *arg1 = 0 ;
11376 wxBitmap *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 *) "bitmap",(char *) "type", NULL
11388 };
11389
11390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",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_wxBitmap, 0 | 0);
11397 if (!SWIG_IsOK(res2)) {
11398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11399 }
11400 if (!argp2) {
11401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11402 }
11403 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11404 ecode3 = SWIG_AsVal_long(obj2, &val3);
11405 if (!SWIG_IsOK(ecode3)) {
11406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11407 }
11408 arg3 = static_cast< long >(val3);
11409 {
11410 PyThreadState* __tstate = wxPyBeginAllowThreads();
11411 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*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_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 wxString *arg1 = 0 ;
11433 PyObject *arg2 = (PyObject *) 0 ;
11434 bool temp1 = false ;
11435 PyObject * obj0 = 0 ;
11436 PyObject * obj1 = 0 ;
11437 char * kwnames[] = {
11438 (char *) "filename",(char *) "data", NULL
11439 };
11440
11441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11442 {
11443 arg1 = wxString_in_helper(obj0);
11444 if (arg1 == NULL) SWIG_fail;
11445 temp1 = true;
11446 }
11447 arg2 = obj1;
11448 {
11449 PyThreadState* __tstate = wxPyBeginAllowThreads();
11450 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11451 wxPyEndAllowThreads(__tstate);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 resultobj = SWIG_Py_Void();
11455 {
11456 if (temp1)
11457 delete arg1;
11458 }
11459 return resultobj;
11460 fail:
11461 {
11462 if (temp1)
11463 delete arg1;
11464 }
11465 return NULL;
11466 }
11467
11468
11469 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11470 PyObject *resultobj = 0;
11471 wxMemoryFSHandler *result = 0 ;
11472
11473 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11477 wxPyEndAllowThreads(__tstate);
11478 if (PyErr_Occurred()) SWIG_fail;
11479 }
11480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11481 return resultobj;
11482 fail:
11483 return NULL;
11484 }
11485
11486
11487 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11488 PyObject *resultobj = 0;
11489 wxString *arg1 = 0 ;
11490 bool temp1 = false ;
11491 PyObject * obj0 = 0 ;
11492 char * kwnames[] = {
11493 (char *) "filename", NULL
11494 };
11495
11496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11497 {
11498 arg1 = wxString_in_helper(obj0);
11499 if (arg1 == NULL) SWIG_fail;
11500 temp1 = true;
11501 }
11502 {
11503 PyThreadState* __tstate = wxPyBeginAllowThreads();
11504 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11505 wxPyEndAllowThreads(__tstate);
11506 if (PyErr_Occurred()) SWIG_fail;
11507 }
11508 resultobj = SWIG_Py_Void();
11509 {
11510 if (temp1)
11511 delete arg1;
11512 }
11513 return resultobj;
11514 fail:
11515 {
11516 if (temp1)
11517 delete arg1;
11518 }
11519 return NULL;
11520 }
11521
11522
11523 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11524 PyObject *resultobj = 0;
11525 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11526 wxString *arg2 = 0 ;
11527 bool result;
11528 void *argp1 = 0 ;
11529 int res1 = 0 ;
11530 bool temp2 = false ;
11531 PyObject * obj0 = 0 ;
11532 PyObject * obj1 = 0 ;
11533 char * kwnames[] = {
11534 (char *) "self",(char *) "location", NULL
11535 };
11536
11537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11539 if (!SWIG_IsOK(res1)) {
11540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11541 }
11542 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11543 {
11544 arg2 = wxString_in_helper(obj1);
11545 if (arg2 == NULL) SWIG_fail;
11546 temp2 = true;
11547 }
11548 {
11549 PyThreadState* __tstate = wxPyBeginAllowThreads();
11550 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 {
11555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11556 }
11557 {
11558 if (temp2)
11559 delete arg2;
11560 }
11561 return resultobj;
11562 fail:
11563 {
11564 if (temp2)
11565 delete arg2;
11566 }
11567 return NULL;
11568 }
11569
11570
11571 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11572 PyObject *resultobj = 0;
11573 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11574 wxFileSystem *arg2 = 0 ;
11575 wxString *arg3 = 0 ;
11576 wxFSFile *result = 0 ;
11577 void *argp1 = 0 ;
11578 int res1 = 0 ;
11579 void *argp2 = 0 ;
11580 int res2 = 0 ;
11581 bool temp3 = false ;
11582 PyObject * obj0 = 0 ;
11583 PyObject * obj1 = 0 ;
11584 PyObject * obj2 = 0 ;
11585 char * kwnames[] = {
11586 (char *) "self",(char *) "fs",(char *) "location", NULL
11587 };
11588
11589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11591 if (!SWIG_IsOK(res1)) {
11592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11593 }
11594 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11596 if (!SWIG_IsOK(res2)) {
11597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11598 }
11599 if (!argp2) {
11600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11601 }
11602 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11603 {
11604 arg3 = wxString_in_helper(obj2);
11605 if (arg3 == NULL) SWIG_fail;
11606 temp3 = true;
11607 }
11608 {
11609 PyThreadState* __tstate = wxPyBeginAllowThreads();
11610 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11611 wxPyEndAllowThreads(__tstate);
11612 if (PyErr_Occurred()) SWIG_fail;
11613 }
11614 {
11615 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11616 }
11617 {
11618 if (temp3)
11619 delete arg3;
11620 }
11621 return resultobj;
11622 fail:
11623 {
11624 if (temp3)
11625 delete arg3;
11626 }
11627 return NULL;
11628 }
11629
11630
11631 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11632 PyObject *resultobj = 0;
11633 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11634 wxString *arg2 = 0 ;
11635 int arg3 = (int) 0 ;
11636 wxString result;
11637 void *argp1 = 0 ;
11638 int res1 = 0 ;
11639 bool temp2 = false ;
11640 int val3 ;
11641 int ecode3 = 0 ;
11642 PyObject * obj0 = 0 ;
11643 PyObject * obj1 = 0 ;
11644 PyObject * obj2 = 0 ;
11645 char * kwnames[] = {
11646 (char *) "self",(char *) "spec",(char *) "flags", NULL
11647 };
11648
11649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11651 if (!SWIG_IsOK(res1)) {
11652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11653 }
11654 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11655 {
11656 arg2 = wxString_in_helper(obj1);
11657 if (arg2 == NULL) SWIG_fail;
11658 temp2 = true;
11659 }
11660 if (obj2) {
11661 ecode3 = SWIG_AsVal_int(obj2, &val3);
11662 if (!SWIG_IsOK(ecode3)) {
11663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11664 }
11665 arg3 = static_cast< int >(val3);
11666 }
11667 {
11668 PyThreadState* __tstate = wxPyBeginAllowThreads();
11669 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11670 wxPyEndAllowThreads(__tstate);
11671 if (PyErr_Occurred()) SWIG_fail;
11672 }
11673 {
11674 #if wxUSE_UNICODE
11675 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11676 #else
11677 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11678 #endif
11679 }
11680 {
11681 if (temp2)
11682 delete arg2;
11683 }
11684 return resultobj;
11685 fail:
11686 {
11687 if (temp2)
11688 delete arg2;
11689 }
11690 return NULL;
11691 }
11692
11693
11694 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11695 PyObject *resultobj = 0;
11696 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11697 wxString result;
11698 void *argp1 = 0 ;
11699 int res1 = 0 ;
11700 PyObject *swig_obj[1] ;
11701
11702 if (!args) SWIG_fail;
11703 swig_obj[0] = args;
11704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11705 if (!SWIG_IsOK(res1)) {
11706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11707 }
11708 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (arg1)->FindNext();
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 {
11716 #if wxUSE_UNICODE
11717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11718 #else
11719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11720 #endif
11721 }
11722 return resultobj;
11723 fail:
11724 return NULL;
11725 }
11726
11727
11728 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11729 PyObject *obj;
11730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11731 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11732 return SWIG_Py_Void();
11733 }
11734
11735 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11736 return SWIG_Python_InitShadowInstance(args);
11737 }
11738
11739 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11740 PyObject *resultobj = 0;
11741 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11742 wxString result;
11743 void *argp1 = 0 ;
11744 int res1 = 0 ;
11745 PyObject *swig_obj[1] ;
11746
11747 if (!args) SWIG_fail;
11748 swig_obj[0] = args;
11749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11750 if (!SWIG_IsOK(res1)) {
11751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11752 }
11753 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11754 {
11755 PyThreadState* __tstate = wxPyBeginAllowThreads();
11756 result = (arg1)->GetName();
11757 wxPyEndAllowThreads(__tstate);
11758 if (PyErr_Occurred()) SWIG_fail;
11759 }
11760 {
11761 #if wxUSE_UNICODE
11762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11763 #else
11764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11765 #endif
11766 }
11767 return resultobj;
11768 fail:
11769 return NULL;
11770 }
11771
11772
11773 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11774 PyObject *resultobj = 0;
11775 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11776 wxString result;
11777 void *argp1 = 0 ;
11778 int res1 = 0 ;
11779 PyObject *swig_obj[1] ;
11780
11781 if (!args) SWIG_fail;
11782 swig_obj[0] = args;
11783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11784 if (!SWIG_IsOK(res1)) {
11785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11786 }
11787 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11788 {
11789 PyThreadState* __tstate = wxPyBeginAllowThreads();
11790 result = (arg1)->GetExtension();
11791 wxPyEndAllowThreads(__tstate);
11792 if (PyErr_Occurred()) SWIG_fail;
11793 }
11794 {
11795 #if wxUSE_UNICODE
11796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11797 #else
11798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11799 #endif
11800 }
11801 return resultobj;
11802 fail:
11803 return NULL;
11804 }
11805
11806
11807 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11808 PyObject *resultobj = 0;
11809 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11810 long result;
11811 void *argp1 = 0 ;
11812 int res1 = 0 ;
11813 PyObject *swig_obj[1] ;
11814
11815 if (!args) SWIG_fail;
11816 swig_obj[0] = args;
11817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11818 if (!SWIG_IsOK(res1)) {
11819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11820 }
11821 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (long)(arg1)->GetType();
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 resultobj = SWIG_From_long(static_cast< long >(result));
11829 return resultobj;
11830 fail:
11831 return NULL;
11832 }
11833
11834
11835 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 PyObject *resultobj = 0;
11837 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11838 wxString result;
11839 void *argp1 = 0 ;
11840 int res1 = 0 ;
11841 PyObject *swig_obj[1] ;
11842
11843 if (!args) SWIG_fail;
11844 swig_obj[0] = args;
11845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11846 if (!SWIG_IsOK(res1)) {
11847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11848 }
11849 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (arg1)->GetMimeType();
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 {
11857 #if wxUSE_UNICODE
11858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11859 #else
11860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11861 #endif
11862 }
11863 return resultobj;
11864 fail:
11865 return NULL;
11866 }
11867
11868
11869 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11870 PyObject *resultobj = 0;
11871 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11872 wxString *arg2 = 0 ;
11873 bool result;
11874 void *argp1 = 0 ;
11875 int res1 = 0 ;
11876 bool temp2 = false ;
11877 PyObject * obj0 = 0 ;
11878 PyObject * obj1 = 0 ;
11879 char * kwnames[] = {
11880 (char *) "self",(char *) "name", NULL
11881 };
11882
11883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11885 if (!SWIG_IsOK(res1)) {
11886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11887 }
11888 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11889 {
11890 arg2 = wxString_in_helper(obj1);
11891 if (arg2 == NULL) SWIG_fail;
11892 temp2 = true;
11893 }
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11897 wxPyEndAllowThreads(__tstate);
11898 if (PyErr_Occurred()) SWIG_fail;
11899 }
11900 {
11901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11902 }
11903 {
11904 if (temp2)
11905 delete arg2;
11906 }
11907 return resultobj;
11908 fail:
11909 {
11910 if (temp2)
11911 delete arg2;
11912 }
11913 return NULL;
11914 }
11915
11916
11917 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11918 PyObject *resultobj = 0;
11919 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11920 wxInputStream *arg2 = 0 ;
11921 bool result;
11922 void *argp1 = 0 ;
11923 int res1 = 0 ;
11924 wxPyInputStream *temp2 ;
11925 bool created2 ;
11926 PyObject * obj0 = 0 ;
11927 PyObject * obj1 = 0 ;
11928 char * kwnames[] = {
11929 (char *) "self",(char *) "stream", NULL
11930 };
11931
11932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11934 if (!SWIG_IsOK(res1)) {
11935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11936 }
11937 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11938 {
11939 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11940 arg2 = temp2->m_wxis;
11941 created2 = false;
11942 } else {
11943 PyErr_Clear(); // clear the failure of the wxPyConvert above
11944 arg2 = wxPyCBInputStream_create(obj1, false);
11945 if (arg2 == NULL) {
11946 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11947 SWIG_fail;
11948 }
11949 created2 = true;
11950 }
11951 }
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (bool)(arg1)->CanRead(*arg2);
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11960 }
11961 {
11962 if (created2) delete arg2;
11963 }
11964 return resultobj;
11965 fail:
11966 {
11967 if (created2) delete arg2;
11968 }
11969 return NULL;
11970 }
11971
11972
11973 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11974 PyObject *resultobj = 0;
11975 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11976 wxString *arg2 = 0 ;
11977 void *argp1 = 0 ;
11978 int res1 = 0 ;
11979 bool temp2 = false ;
11980 PyObject * obj0 = 0 ;
11981 PyObject * obj1 = 0 ;
11982 char * kwnames[] = {
11983 (char *) "self",(char *) "name", NULL
11984 };
11985
11986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11988 if (!SWIG_IsOK(res1)) {
11989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11990 }
11991 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11992 {
11993 arg2 = wxString_in_helper(obj1);
11994 if (arg2 == NULL) SWIG_fail;
11995 temp2 = true;
11996 }
11997 {
11998 PyThreadState* __tstate = wxPyBeginAllowThreads();
11999 (arg1)->SetName((wxString const &)*arg2);
12000 wxPyEndAllowThreads(__tstate);
12001 if (PyErr_Occurred()) SWIG_fail;
12002 }
12003 resultobj = SWIG_Py_Void();
12004 {
12005 if (temp2)
12006 delete arg2;
12007 }
12008 return resultobj;
12009 fail:
12010 {
12011 if (temp2)
12012 delete arg2;
12013 }
12014 return NULL;
12015 }
12016
12017
12018 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12019 PyObject *resultobj = 0;
12020 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12021 wxString *arg2 = 0 ;
12022 void *argp1 = 0 ;
12023 int res1 = 0 ;
12024 bool temp2 = false ;
12025 PyObject * obj0 = 0 ;
12026 PyObject * obj1 = 0 ;
12027 char * kwnames[] = {
12028 (char *) "self",(char *) "extension", NULL
12029 };
12030
12031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12033 if (!SWIG_IsOK(res1)) {
12034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12035 }
12036 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12037 {
12038 arg2 = wxString_in_helper(obj1);
12039 if (arg2 == NULL) SWIG_fail;
12040 temp2 = true;
12041 }
12042 {
12043 PyThreadState* __tstate = wxPyBeginAllowThreads();
12044 (arg1)->SetExtension((wxString const &)*arg2);
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 resultobj = SWIG_Py_Void();
12049 {
12050 if (temp2)
12051 delete arg2;
12052 }
12053 return resultobj;
12054 fail:
12055 {
12056 if (temp2)
12057 delete arg2;
12058 }
12059 return NULL;
12060 }
12061
12062
12063 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12064 PyObject *resultobj = 0;
12065 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12066 long arg2 ;
12067 void *argp1 = 0 ;
12068 int res1 = 0 ;
12069 long val2 ;
12070 int ecode2 = 0 ;
12071 PyObject * obj0 = 0 ;
12072 PyObject * obj1 = 0 ;
12073 char * kwnames[] = {
12074 (char *) "self",(char *) "type", NULL
12075 };
12076
12077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12079 if (!SWIG_IsOK(res1)) {
12080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12081 }
12082 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12083 ecode2 = SWIG_AsVal_long(obj1, &val2);
12084 if (!SWIG_IsOK(ecode2)) {
12085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12086 }
12087 arg2 = static_cast< long >(val2);
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 (arg1)->SetType(arg2);
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 resultobj = SWIG_Py_Void();
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12102 PyObject *resultobj = 0;
12103 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12104 wxString *arg2 = 0 ;
12105 void *argp1 = 0 ;
12106 int res1 = 0 ;
12107 bool temp2 = false ;
12108 PyObject * obj0 = 0 ;
12109 PyObject * obj1 = 0 ;
12110 char * kwnames[] = {
12111 (char *) "self",(char *) "mimetype", NULL
12112 };
12113
12114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12116 if (!SWIG_IsOK(res1)) {
12117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12118 }
12119 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12120 {
12121 arg2 = wxString_in_helper(obj1);
12122 if (arg2 == NULL) SWIG_fail;
12123 temp2 = true;
12124 }
12125 {
12126 PyThreadState* __tstate = wxPyBeginAllowThreads();
12127 (arg1)->SetMimeType((wxString const &)*arg2);
12128 wxPyEndAllowThreads(__tstate);
12129 if (PyErr_Occurred()) SWIG_fail;
12130 }
12131 resultobj = SWIG_Py_Void();
12132 {
12133 if (temp2)
12134 delete arg2;
12135 }
12136 return resultobj;
12137 fail:
12138 {
12139 if (temp2)
12140 delete arg2;
12141 }
12142 return NULL;
12143 }
12144
12145
12146 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12147 PyObject *obj;
12148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12149 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12150 return SWIG_Py_Void();
12151 }
12152
12153 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12154 PyObject *resultobj = 0;
12155 wxPyImageHandler *result = 0 ;
12156
12157 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (wxPyImageHandler *)new wxPyImageHandler();
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12172 PyObject *resultobj = 0;
12173 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12174 PyObject *arg2 = (PyObject *) 0 ;
12175 void *argp1 = 0 ;
12176 int res1 = 0 ;
12177 PyObject * obj0 = 0 ;
12178 PyObject * obj1 = 0 ;
12179 char * kwnames[] = {
12180 (char *) "self",(char *) "self", NULL
12181 };
12182
12183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12185 if (!SWIG_IsOK(res1)) {
12186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12187 }
12188 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12189 arg2 = obj1;
12190 {
12191 PyThreadState* __tstate = wxPyBeginAllowThreads();
12192 (arg1)->_SetSelf(arg2);
12193 wxPyEndAllowThreads(__tstate);
12194 if (PyErr_Occurred()) SWIG_fail;
12195 }
12196 resultobj = SWIG_Py_Void();
12197 return resultobj;
12198 fail:
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *PyImageHandler_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_wxPyImageHandler, SWIG_NewClientData(obj));
12207 return SWIG_Py_Void();
12208 }
12209
12210 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12211 return SWIG_Python_InitShadowInstance(args);
12212 }
12213
12214 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12215 PyObject *resultobj = 0;
12216 wxImageHistogram *result = 0 ;
12217
12218 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (wxImageHistogram *)new wxImageHistogram();
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12226 return resultobj;
12227 fail:
12228 return NULL;
12229 }
12230
12231
12232 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12233 PyObject *resultobj = 0;
12234 byte arg1 ;
12235 byte arg2 ;
12236 byte arg3 ;
12237 unsigned long result;
12238 unsigned char val1 ;
12239 int ecode1 = 0 ;
12240 unsigned char val2 ;
12241 int ecode2 = 0 ;
12242 unsigned char val3 ;
12243 int ecode3 = 0 ;
12244 PyObject * obj0 = 0 ;
12245 PyObject * obj1 = 0 ;
12246 PyObject * obj2 = 0 ;
12247 char * kwnames[] = {
12248 (char *) "r",(char *) "g",(char *) "b", NULL
12249 };
12250
12251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12252 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12253 if (!SWIG_IsOK(ecode1)) {
12254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12255 }
12256 arg1 = static_cast< byte >(val1);
12257 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12258 if (!SWIG_IsOK(ecode2)) {
12259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12260 }
12261 arg2 = static_cast< byte >(val2);
12262 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12263 if (!SWIG_IsOK(ecode3)) {
12264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12265 }
12266 arg3 = static_cast< byte >(val3);
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12274 return resultobj;
12275 fail:
12276 return NULL;
12277 }
12278
12279
12280 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12281 PyObject *resultobj = 0;
12282 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12283 byte *arg2 = (byte *) 0 ;
12284 byte *arg3 = (byte *) 0 ;
12285 byte *arg4 = (byte *) 0 ;
12286 byte arg5 = (byte) 1 ;
12287 byte arg6 = (byte) 0 ;
12288 byte arg7 = (byte) 0 ;
12289 bool result;
12290 void *argp1 = 0 ;
12291 int res1 = 0 ;
12292 byte temp2 ;
12293 int res2 = SWIG_TMPOBJ ;
12294 byte temp3 ;
12295 int res3 = SWIG_TMPOBJ ;
12296 byte temp4 ;
12297 int res4 = SWIG_TMPOBJ ;
12298 unsigned char val5 ;
12299 int ecode5 = 0 ;
12300 unsigned char val6 ;
12301 int ecode6 = 0 ;
12302 unsigned char val7 ;
12303 int ecode7 = 0 ;
12304 PyObject * obj0 = 0 ;
12305 PyObject * obj1 = 0 ;
12306 PyObject * obj2 = 0 ;
12307 PyObject * obj3 = 0 ;
12308 char * kwnames[] = {
12309 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12310 };
12311
12312 arg2 = &temp2;
12313 arg3 = &temp3;
12314 arg4 = &temp4;
12315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12317 if (!SWIG_IsOK(res1)) {
12318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12319 }
12320 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12321 if (obj1) {
12322 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12323 if (!SWIG_IsOK(ecode5)) {
12324 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12325 }
12326 arg5 = static_cast< byte >(val5);
12327 }
12328 if (obj2) {
12329 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12330 if (!SWIG_IsOK(ecode6)) {
12331 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12332 }
12333 arg6 = static_cast< byte >(val6);
12334 }
12335 if (obj3) {
12336 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12337 if (!SWIG_IsOK(ecode7)) {
12338 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12339 }
12340 arg7 = static_cast< byte >(val7);
12341 }
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 {
12349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12350 }
12351 if (SWIG_IsTmpObj(res2)) {
12352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12353 } else {
12354 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12356 }
12357 if (SWIG_IsTmpObj(res3)) {
12358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12359 } else {
12360 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12362 }
12363 if (SWIG_IsTmpObj(res4)) {
12364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12365 } else {
12366 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12368 }
12369 return resultobj;
12370 fail:
12371 return NULL;
12372 }
12373
12374
12375 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12376 PyObject *resultobj = 0;
12377 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12378 unsigned long arg2 ;
12379 unsigned long result;
12380 void *argp1 = 0 ;
12381 int res1 = 0 ;
12382 unsigned long val2 ;
12383 int ecode2 = 0 ;
12384 PyObject * obj0 = 0 ;
12385 PyObject * obj1 = 0 ;
12386 char * kwnames[] = {
12387 (char *) "self",(char *) "key", NULL
12388 };
12389
12390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12392 if (!SWIG_IsOK(res1)) {
12393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12394 }
12395 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12396 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12397 if (!SWIG_IsOK(ecode2)) {
12398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12399 }
12400 arg2 = static_cast< unsigned long >(val2);
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = 0;
12416 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12417 byte arg2 ;
12418 byte arg3 ;
12419 byte arg4 ;
12420 unsigned long result;
12421 void *argp1 = 0 ;
12422 int res1 = 0 ;
12423 unsigned char val2 ;
12424 int ecode2 = 0 ;
12425 unsigned char val3 ;
12426 int ecode3 = 0 ;
12427 unsigned char val4 ;
12428 int ecode4 = 0 ;
12429 PyObject * obj0 = 0 ;
12430 PyObject * obj1 = 0 ;
12431 PyObject * obj2 = 0 ;
12432 PyObject * obj3 = 0 ;
12433 char * kwnames[] = {
12434 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12435 };
12436
12437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12439 if (!SWIG_IsOK(res1)) {
12440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12441 }
12442 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12443 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12444 if (!SWIG_IsOK(ecode2)) {
12445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12446 }
12447 arg2 = static_cast< byte >(val2);
12448 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12449 if (!SWIG_IsOK(ecode3)) {
12450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12451 }
12452 arg3 = static_cast< byte >(val3);
12453 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12454 if (!SWIG_IsOK(ecode4)) {
12455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12456 }
12457 arg4 = static_cast< byte >(val4);
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
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_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj = 0;
12473 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12474 wxColour *arg2 = 0 ;
12475 unsigned long result;
12476 void *argp1 = 0 ;
12477 int res1 = 0 ;
12478 wxColour temp2 ;
12479 PyObject * obj0 = 0 ;
12480 PyObject * obj1 = 0 ;
12481 char * kwnames[] = {
12482 (char *) "self",(char *) "colour", NULL
12483 };
12484
12485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12487 if (!SWIG_IsOK(res1)) {
12488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12489 }
12490 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12491 {
12492 arg2 = &temp2;
12493 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12494 }
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12509 PyObject *obj;
12510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12511 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12512 return SWIG_Py_Void();
12513 }
12514
12515 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12516 return SWIG_Python_InitShadowInstance(args);
12517 }
12518
12519 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12520 PyObject *resultobj = 0;
12521 byte arg1 = (byte) 0 ;
12522 byte arg2 = (byte) 0 ;
12523 byte arg3 = (byte) 0 ;
12524 wxImage_RGBValue *result = 0 ;
12525 unsigned char val1 ;
12526 int ecode1 = 0 ;
12527 unsigned char val2 ;
12528 int ecode2 = 0 ;
12529 unsigned char val3 ;
12530 int ecode3 = 0 ;
12531 PyObject * obj0 = 0 ;
12532 PyObject * obj1 = 0 ;
12533 PyObject * obj2 = 0 ;
12534 char * kwnames[] = {
12535 (char *) "r",(char *) "g",(char *) "b", NULL
12536 };
12537
12538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12539 if (obj0) {
12540 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12541 if (!SWIG_IsOK(ecode1)) {
12542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12543 }
12544 arg1 = static_cast< byte >(val1);
12545 }
12546 if (obj1) {
12547 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12548 if (!SWIG_IsOK(ecode2)) {
12549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12550 }
12551 arg2 = static_cast< byte >(val2);
12552 }
12553 if (obj2) {
12554 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12555 if (!SWIG_IsOK(ecode3)) {
12556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12557 }
12558 arg3 = static_cast< byte >(val3);
12559 }
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12567 return resultobj;
12568 fail:
12569 return NULL;
12570 }
12571
12572
12573 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12574 PyObject *resultobj = 0;
12575 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12576 byte arg2 ;
12577 void *argp1 = 0 ;
12578 int res1 = 0 ;
12579 unsigned char val2 ;
12580 int ecode2 = 0 ;
12581 PyObject *swig_obj[2] ;
12582
12583 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12585 if (!SWIG_IsOK(res1)) {
12586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12587 }
12588 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12589 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12590 if (!SWIG_IsOK(ecode2)) {
12591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12592 }
12593 arg2 = static_cast< byte >(val2);
12594 if (arg1) (arg1)->red = arg2;
12595
12596 resultobj = SWIG_Py_Void();
12597 return resultobj;
12598 fail:
12599 return NULL;
12600 }
12601
12602
12603 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12604 PyObject *resultobj = 0;
12605 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12606 byte result;
12607 void *argp1 = 0 ;
12608 int res1 = 0 ;
12609 PyObject *swig_obj[1] ;
12610
12611 if (!args) SWIG_fail;
12612 swig_obj[0] = args;
12613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12614 if (!SWIG_IsOK(res1)) {
12615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12616 }
12617 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12618 result = (byte) ((arg1)->red);
12619 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12620 return resultobj;
12621 fail:
12622 return NULL;
12623 }
12624
12625
12626 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12627 PyObject *resultobj = 0;
12628 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12629 byte arg2 ;
12630 void *argp1 = 0 ;
12631 int res1 = 0 ;
12632 unsigned char val2 ;
12633 int ecode2 = 0 ;
12634 PyObject *swig_obj[2] ;
12635
12636 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12638 if (!SWIG_IsOK(res1)) {
12639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12640 }
12641 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12642 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12643 if (!SWIG_IsOK(ecode2)) {
12644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12645 }
12646 arg2 = static_cast< byte >(val2);
12647 if (arg1) (arg1)->green = arg2;
12648
12649 resultobj = SWIG_Py_Void();
12650 return resultobj;
12651 fail:
12652 return NULL;
12653 }
12654
12655
12656 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12657 PyObject *resultobj = 0;
12658 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12659 byte result;
12660 void *argp1 = 0 ;
12661 int res1 = 0 ;
12662 PyObject *swig_obj[1] ;
12663
12664 if (!args) SWIG_fail;
12665 swig_obj[0] = args;
12666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12667 if (!SWIG_IsOK(res1)) {
12668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12669 }
12670 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12671 result = (byte) ((arg1)->green);
12672 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12680 PyObject *resultobj = 0;
12681 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12682 byte arg2 ;
12683 void *argp1 = 0 ;
12684 int res1 = 0 ;
12685 unsigned char val2 ;
12686 int ecode2 = 0 ;
12687 PyObject *swig_obj[2] ;
12688
12689 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12691 if (!SWIG_IsOK(res1)) {
12692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12693 }
12694 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12695 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12696 if (!SWIG_IsOK(ecode2)) {
12697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12698 }
12699 arg2 = static_cast< byte >(val2);
12700 if (arg1) (arg1)->blue = arg2;
12701
12702 resultobj = SWIG_Py_Void();
12703 return resultobj;
12704 fail:
12705 return NULL;
12706 }
12707
12708
12709 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12710 PyObject *resultobj = 0;
12711 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12712 byte result;
12713 void *argp1 = 0 ;
12714 int res1 = 0 ;
12715 PyObject *swig_obj[1] ;
12716
12717 if (!args) SWIG_fail;
12718 swig_obj[0] = args;
12719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12720 if (!SWIG_IsOK(res1)) {
12721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12722 }
12723 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12724 result = (byte) ((arg1)->blue);
12725 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12726 return resultobj;
12727 fail:
12728 return NULL;
12729 }
12730
12731
12732 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12733 PyObject *obj;
12734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12735 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12736 return SWIG_Py_Void();
12737 }
12738
12739 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12740 return SWIG_Python_InitShadowInstance(args);
12741 }
12742
12743 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12744 PyObject *resultobj = 0;
12745 double arg1 = (double) 0.0 ;
12746 double arg2 = (double) 0.0 ;
12747 double arg3 = (double) 0.0 ;
12748 wxImage_HSVValue *result = 0 ;
12749 double val1 ;
12750 int ecode1 = 0 ;
12751 double val2 ;
12752 int ecode2 = 0 ;
12753 double val3 ;
12754 int ecode3 = 0 ;
12755 PyObject * obj0 = 0 ;
12756 PyObject * obj1 = 0 ;
12757 PyObject * obj2 = 0 ;
12758 char * kwnames[] = {
12759 (char *) "h",(char *) "s",(char *) "v", NULL
12760 };
12761
12762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12763 if (obj0) {
12764 ecode1 = SWIG_AsVal_double(obj0, &val1);
12765 if (!SWIG_IsOK(ecode1)) {
12766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12767 }
12768 arg1 = static_cast< double >(val1);
12769 }
12770 if (obj1) {
12771 ecode2 = SWIG_AsVal_double(obj1, &val2);
12772 if (!SWIG_IsOK(ecode2)) {
12773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12774 }
12775 arg2 = static_cast< double >(val2);
12776 }
12777 if (obj2) {
12778 ecode3 = SWIG_AsVal_double(obj2, &val3);
12779 if (!SWIG_IsOK(ecode3)) {
12780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12781 }
12782 arg3 = static_cast< double >(val3);
12783 }
12784 {
12785 PyThreadState* __tstate = wxPyBeginAllowThreads();
12786 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12787 wxPyEndAllowThreads(__tstate);
12788 if (PyErr_Occurred()) SWIG_fail;
12789 }
12790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12791 return resultobj;
12792 fail:
12793 return NULL;
12794 }
12795
12796
12797 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12798 PyObject *resultobj = 0;
12799 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12800 double arg2 ;
12801 void *argp1 = 0 ;
12802 int res1 = 0 ;
12803 double val2 ;
12804 int ecode2 = 0 ;
12805 PyObject *swig_obj[2] ;
12806
12807 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12809 if (!SWIG_IsOK(res1)) {
12810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12811 }
12812 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12813 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12814 if (!SWIG_IsOK(ecode2)) {
12815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12816 }
12817 arg2 = static_cast< double >(val2);
12818 if (arg1) (arg1)->hue = arg2;
12819
12820 resultobj = SWIG_Py_Void();
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12828 PyObject *resultobj = 0;
12829 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12830 double result;
12831 void *argp1 = 0 ;
12832 int res1 = 0 ;
12833 PyObject *swig_obj[1] ;
12834
12835 if (!args) SWIG_fail;
12836 swig_obj[0] = args;
12837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12838 if (!SWIG_IsOK(res1)) {
12839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12840 }
12841 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12842 result = (double) ((arg1)->hue);
12843 resultobj = SWIG_From_double(static_cast< double >(result));
12844 return resultobj;
12845 fail:
12846 return NULL;
12847 }
12848
12849
12850 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12851 PyObject *resultobj = 0;
12852 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12853 double arg2 ;
12854 void *argp1 = 0 ;
12855 int res1 = 0 ;
12856 double val2 ;
12857 int ecode2 = 0 ;
12858 PyObject *swig_obj[2] ;
12859
12860 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12862 if (!SWIG_IsOK(res1)) {
12863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12864 }
12865 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12866 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12867 if (!SWIG_IsOK(ecode2)) {
12868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12869 }
12870 arg2 = static_cast< double >(val2);
12871 if (arg1) (arg1)->saturation = arg2;
12872
12873 resultobj = SWIG_Py_Void();
12874 return resultobj;
12875 fail:
12876 return NULL;
12877 }
12878
12879
12880 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12881 PyObject *resultobj = 0;
12882 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12883 double result;
12884 void *argp1 = 0 ;
12885 int res1 = 0 ;
12886 PyObject *swig_obj[1] ;
12887
12888 if (!args) SWIG_fail;
12889 swig_obj[0] = args;
12890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12891 if (!SWIG_IsOK(res1)) {
12892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12893 }
12894 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12895 result = (double) ((arg1)->saturation);
12896 resultobj = SWIG_From_double(static_cast< double >(result));
12897 return resultobj;
12898 fail:
12899 return NULL;
12900 }
12901
12902
12903 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12904 PyObject *resultobj = 0;
12905 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12906 double arg2 ;
12907 void *argp1 = 0 ;
12908 int res1 = 0 ;
12909 double val2 ;
12910 int ecode2 = 0 ;
12911 PyObject *swig_obj[2] ;
12912
12913 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12915 if (!SWIG_IsOK(res1)) {
12916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12917 }
12918 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12919 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12920 if (!SWIG_IsOK(ecode2)) {
12921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12922 }
12923 arg2 = static_cast< double >(val2);
12924 if (arg1) (arg1)->value = arg2;
12925
12926 resultobj = SWIG_Py_Void();
12927 return resultobj;
12928 fail:
12929 return NULL;
12930 }
12931
12932
12933 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12934 PyObject *resultobj = 0;
12935 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12936 double result;
12937 void *argp1 = 0 ;
12938 int res1 = 0 ;
12939 PyObject *swig_obj[1] ;
12940
12941 if (!args) SWIG_fail;
12942 swig_obj[0] = args;
12943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12944 if (!SWIG_IsOK(res1)) {
12945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12946 }
12947 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12948 result = (double) ((arg1)->value);
12949 resultobj = SWIG_From_double(static_cast< double >(result));
12950 return resultobj;
12951 fail:
12952 return NULL;
12953 }
12954
12955
12956 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12957 PyObject *obj;
12958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12959 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12960 return SWIG_Py_Void();
12961 }
12962
12963 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12964 return SWIG_Python_InitShadowInstance(args);
12965 }
12966
12967 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12968 PyObject *resultobj = 0;
12969 wxString *arg1 = 0 ;
12970 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12971 int arg3 = (int) -1 ;
12972 wxImage *result = 0 ;
12973 bool temp1 = false ;
12974 long val2 ;
12975 int ecode2 = 0 ;
12976 int val3 ;
12977 int ecode3 = 0 ;
12978 PyObject * obj0 = 0 ;
12979 PyObject * obj1 = 0 ;
12980 PyObject * obj2 = 0 ;
12981 char * kwnames[] = {
12982 (char *) "name",(char *) "type",(char *) "index", NULL
12983 };
12984
12985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12986 {
12987 arg1 = wxString_in_helper(obj0);
12988 if (arg1 == NULL) SWIG_fail;
12989 temp1 = true;
12990 }
12991 if (obj1) {
12992 ecode2 = SWIG_AsVal_long(obj1, &val2);
12993 if (!SWIG_IsOK(ecode2)) {
12994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12995 }
12996 arg2 = static_cast< long >(val2);
12997 }
12998 if (obj2) {
12999 ecode3 = SWIG_AsVal_int(obj2, &val3);
13000 if (!SWIG_IsOK(ecode3)) {
13001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13002 }
13003 arg3 = static_cast< int >(val3);
13004 }
13005 {
13006 PyThreadState* __tstate = wxPyBeginAllowThreads();
13007 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13008 wxPyEndAllowThreads(__tstate);
13009 if (PyErr_Occurred()) SWIG_fail;
13010 }
13011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13012 {
13013 if (temp1)
13014 delete arg1;
13015 }
13016 return resultobj;
13017 fail:
13018 {
13019 if (temp1)
13020 delete arg1;
13021 }
13022 return NULL;
13023 }
13024
13025
13026 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13027 PyObject *resultobj = 0;
13028 wxImage *arg1 = (wxImage *) 0 ;
13029 void *argp1 = 0 ;
13030 int res1 = 0 ;
13031 PyObject *swig_obj[1] ;
13032
13033 if (!args) SWIG_fail;
13034 swig_obj[0] = args;
13035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13036 if (!SWIG_IsOK(res1)) {
13037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13038 }
13039 arg1 = reinterpret_cast< wxImage * >(argp1);
13040 {
13041 PyThreadState* __tstate = wxPyBeginAllowThreads();
13042 delete arg1;
13043
13044 wxPyEndAllowThreads(__tstate);
13045 if (PyErr_Occurred()) SWIG_fail;
13046 }
13047 resultobj = SWIG_Py_Void();
13048 return resultobj;
13049 fail:
13050 return NULL;
13051 }
13052
13053
13054 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj = 0;
13056 wxString *arg1 = 0 ;
13057 wxString *arg2 = 0 ;
13058 int arg3 = (int) -1 ;
13059 wxImage *result = 0 ;
13060 bool temp1 = false ;
13061 bool temp2 = false ;
13062 int val3 ;
13063 int ecode3 = 0 ;
13064 PyObject * obj0 = 0 ;
13065 PyObject * obj1 = 0 ;
13066 PyObject * obj2 = 0 ;
13067 char * kwnames[] = {
13068 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13069 };
13070
13071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13072 {
13073 arg1 = wxString_in_helper(obj0);
13074 if (arg1 == NULL) SWIG_fail;
13075 temp1 = true;
13076 }
13077 {
13078 arg2 = wxString_in_helper(obj1);
13079 if (arg2 == NULL) SWIG_fail;
13080 temp2 = true;
13081 }
13082 if (obj2) {
13083 ecode3 = SWIG_AsVal_int(obj2, &val3);
13084 if (!SWIG_IsOK(ecode3)) {
13085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13086 }
13087 arg3 = static_cast< int >(val3);
13088 }
13089 {
13090 PyThreadState* __tstate = wxPyBeginAllowThreads();
13091 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13092 wxPyEndAllowThreads(__tstate);
13093 if (PyErr_Occurred()) SWIG_fail;
13094 }
13095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13096 {
13097 if (temp1)
13098 delete arg1;
13099 }
13100 {
13101 if (temp2)
13102 delete arg2;
13103 }
13104 return resultobj;
13105 fail:
13106 {
13107 if (temp1)
13108 delete arg1;
13109 }
13110 {
13111 if (temp2)
13112 delete arg2;
13113 }
13114 return NULL;
13115 }
13116
13117
13118 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13119 PyObject *resultobj = 0;
13120 wxInputStream *arg1 = 0 ;
13121 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13122 int arg3 = (int) -1 ;
13123 wxImage *result = 0 ;
13124 wxPyInputStream *temp1 ;
13125 bool created1 ;
13126 long val2 ;
13127 int ecode2 = 0 ;
13128 int val3 ;
13129 int ecode3 = 0 ;
13130 PyObject * obj0 = 0 ;
13131 PyObject * obj1 = 0 ;
13132 PyObject * obj2 = 0 ;
13133 char * kwnames[] = {
13134 (char *) "stream",(char *) "type",(char *) "index", NULL
13135 };
13136
13137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13138 {
13139 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13140 arg1 = temp1->m_wxis;
13141 created1 = false;
13142 } else {
13143 PyErr_Clear(); // clear the failure of the wxPyConvert above
13144 arg1 = wxPyCBInputStream_create(obj0, false);
13145 if (arg1 == NULL) {
13146 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13147 SWIG_fail;
13148 }
13149 created1 = true;
13150 }
13151 }
13152 if (obj1) {
13153 ecode2 = SWIG_AsVal_long(obj1, &val2);
13154 if (!SWIG_IsOK(ecode2)) {
13155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13156 }
13157 arg2 = static_cast< long >(val2);
13158 }
13159 if (obj2) {
13160 ecode3 = SWIG_AsVal_int(obj2, &val3);
13161 if (!SWIG_IsOK(ecode3)) {
13162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13163 }
13164 arg3 = static_cast< int >(val3);
13165 }
13166 {
13167 PyThreadState* __tstate = wxPyBeginAllowThreads();
13168 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13169 wxPyEndAllowThreads(__tstate);
13170 if (PyErr_Occurred()) SWIG_fail;
13171 }
13172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13173 {
13174 if (created1) delete arg1;
13175 }
13176 return resultobj;
13177 fail:
13178 {
13179 if (created1) delete arg1;
13180 }
13181 return NULL;
13182 }
13183
13184
13185 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13186 PyObject *resultobj = 0;
13187 wxInputStream *arg1 = 0 ;
13188 wxString *arg2 = 0 ;
13189 int arg3 = (int) -1 ;
13190 wxImage *result = 0 ;
13191 wxPyInputStream *temp1 ;
13192 bool created1 ;
13193 bool temp2 = false ;
13194 int val3 ;
13195 int ecode3 = 0 ;
13196 PyObject * obj0 = 0 ;
13197 PyObject * obj1 = 0 ;
13198 PyObject * obj2 = 0 ;
13199 char * kwnames[] = {
13200 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13201 };
13202
13203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13204 {
13205 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13206 arg1 = temp1->m_wxis;
13207 created1 = false;
13208 } else {
13209 PyErr_Clear(); // clear the failure of the wxPyConvert above
13210 arg1 = wxPyCBInputStream_create(obj0, false);
13211 if (arg1 == NULL) {
13212 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13213 SWIG_fail;
13214 }
13215 created1 = true;
13216 }
13217 }
13218 {
13219 arg2 = wxString_in_helper(obj1);
13220 if (arg2 == NULL) SWIG_fail;
13221 temp2 = true;
13222 }
13223 if (obj2) {
13224 ecode3 = SWIG_AsVal_int(obj2, &val3);
13225 if (!SWIG_IsOK(ecode3)) {
13226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13227 }
13228 arg3 = static_cast< int >(val3);
13229 }
13230 {
13231 PyThreadState* __tstate = wxPyBeginAllowThreads();
13232 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13233 wxPyEndAllowThreads(__tstate);
13234 if (PyErr_Occurred()) SWIG_fail;
13235 }
13236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13237 {
13238 if (created1) delete arg1;
13239 }
13240 {
13241 if (temp2)
13242 delete arg2;
13243 }
13244 return resultobj;
13245 fail:
13246 {
13247 if (created1) delete arg1;
13248 }
13249 {
13250 if (temp2)
13251 delete arg2;
13252 }
13253 return NULL;
13254 }
13255
13256
13257 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13258 PyObject *resultobj = 0;
13259 int arg1 = (int) 0 ;
13260 int arg2 = (int) 0 ;
13261 bool arg3 = (bool) true ;
13262 wxImage *result = 0 ;
13263 int val1 ;
13264 int ecode1 = 0 ;
13265 int val2 ;
13266 int ecode2 = 0 ;
13267 bool val3 ;
13268 int ecode3 = 0 ;
13269 PyObject * obj0 = 0 ;
13270 PyObject * obj1 = 0 ;
13271 PyObject * obj2 = 0 ;
13272 char * kwnames[] = {
13273 (char *) "width",(char *) "height",(char *) "clear", NULL
13274 };
13275
13276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13277 if (obj0) {
13278 ecode1 = SWIG_AsVal_int(obj0, &val1);
13279 if (!SWIG_IsOK(ecode1)) {
13280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13281 }
13282 arg1 = static_cast< int >(val1);
13283 }
13284 if (obj1) {
13285 ecode2 = SWIG_AsVal_int(obj1, &val2);
13286 if (!SWIG_IsOK(ecode2)) {
13287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13288 }
13289 arg2 = static_cast< int >(val2);
13290 }
13291 if (obj2) {
13292 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13293 if (!SWIG_IsOK(ecode3)) {
13294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13295 }
13296 arg3 = static_cast< bool >(val3);
13297 }
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13305 return resultobj;
13306 fail:
13307 return NULL;
13308 }
13309
13310
13311 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13312 PyObject *resultobj = 0;
13313 wxBitmap *arg1 = 0 ;
13314 wxImage *result = 0 ;
13315 void *argp1 = 0 ;
13316 int res1 = 0 ;
13317 PyObject * obj0 = 0 ;
13318 char * kwnames[] = {
13319 (char *) "bitmap", NULL
13320 };
13321
13322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13323 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13324 if (!SWIG_IsOK(res1)) {
13325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13326 }
13327 if (!argp1) {
13328 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13329 }
13330 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13331 {
13332 if (!wxPyCheckForApp()) SWIG_fail;
13333 PyThreadState* __tstate = wxPyBeginAllowThreads();
13334 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13339 return resultobj;
13340 fail:
13341 return NULL;
13342 }
13343
13344
13345 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13346 PyObject *resultobj = 0;
13347 int arg1 ;
13348 int arg2 ;
13349 buffer arg3 ;
13350 int arg4 ;
13351 wxImage *result = 0 ;
13352 int val1 ;
13353 int ecode1 = 0 ;
13354 int val2 ;
13355 int ecode2 = 0 ;
13356 PyObject * obj0 = 0 ;
13357 PyObject * obj1 = 0 ;
13358 PyObject * obj2 = 0 ;
13359 char * kwnames[] = {
13360 (char *) "width",(char *) "height",(char *) "data", NULL
13361 };
13362
13363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13364 ecode1 = SWIG_AsVal_int(obj0, &val1);
13365 if (!SWIG_IsOK(ecode1)) {
13366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13367 }
13368 arg1 = static_cast< int >(val1);
13369 ecode2 = SWIG_AsVal_int(obj1, &val2);
13370 if (!SWIG_IsOK(ecode2)) {
13371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13372 }
13373 arg2 = static_cast< int >(val2);
13374 {
13375 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13376 }
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj = 0;
13392 int arg1 ;
13393 int arg2 ;
13394 buffer arg3 ;
13395 int arg4 ;
13396 buffer arg5 ;
13397 int arg6 ;
13398 wxImage *result = 0 ;
13399 int val1 ;
13400 int ecode1 = 0 ;
13401 int val2 ;
13402 int ecode2 = 0 ;
13403 PyObject * obj0 = 0 ;
13404 PyObject * obj1 = 0 ;
13405 PyObject * obj2 = 0 ;
13406 PyObject * obj3 = 0 ;
13407 char * kwnames[] = {
13408 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13409 };
13410
13411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13412 ecode1 = SWIG_AsVal_int(obj0, &val1);
13413 if (!SWIG_IsOK(ecode1)) {
13414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13415 }
13416 arg1 = static_cast< int >(val1);
13417 ecode2 = SWIG_AsVal_int(obj1, &val2);
13418 if (!SWIG_IsOK(ecode2)) {
13419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13420 }
13421 arg2 = static_cast< int >(val2);
13422 {
13423 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13424 }
13425 {
13426 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13427 }
13428 {
13429 PyThreadState* __tstate = wxPyBeginAllowThreads();
13430 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13431 wxPyEndAllowThreads(__tstate);
13432 if (PyErr_Occurred()) SWIG_fail;
13433 }
13434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13435 return resultobj;
13436 fail:
13437 return NULL;
13438 }
13439
13440
13441 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13442 PyObject *resultobj = 0;
13443 wxImage *arg1 = (wxImage *) 0 ;
13444 int arg2 ;
13445 int arg3 ;
13446 bool arg4 = (bool) true ;
13447 void *argp1 = 0 ;
13448 int res1 = 0 ;
13449 int val2 ;
13450 int ecode2 = 0 ;
13451 int val3 ;
13452 int ecode3 = 0 ;
13453 bool val4 ;
13454 int ecode4 = 0 ;
13455 PyObject * obj0 = 0 ;
13456 PyObject * obj1 = 0 ;
13457 PyObject * obj2 = 0 ;
13458 PyObject * obj3 = 0 ;
13459 char * kwnames[] = {
13460 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13461 };
13462
13463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13465 if (!SWIG_IsOK(res1)) {
13466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13467 }
13468 arg1 = reinterpret_cast< wxImage * >(argp1);
13469 ecode2 = SWIG_AsVal_int(obj1, &val2);
13470 if (!SWIG_IsOK(ecode2)) {
13471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13472 }
13473 arg2 = static_cast< int >(val2);
13474 ecode3 = SWIG_AsVal_int(obj2, &val3);
13475 if (!SWIG_IsOK(ecode3)) {
13476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13477 }
13478 arg3 = static_cast< int >(val3);
13479 if (obj3) {
13480 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13481 if (!SWIG_IsOK(ecode4)) {
13482 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13483 }
13484 arg4 = static_cast< bool >(val4);
13485 }
13486 {
13487 PyThreadState* __tstate = wxPyBeginAllowThreads();
13488 (arg1)->Create(arg2,arg3,arg4);
13489 wxPyEndAllowThreads(__tstate);
13490 if (PyErr_Occurred()) SWIG_fail;
13491 }
13492 resultobj = SWIG_Py_Void();
13493 return resultobj;
13494 fail:
13495 return NULL;
13496 }
13497
13498
13499 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13500 PyObject *resultobj = 0;
13501 wxImage *arg1 = (wxImage *) 0 ;
13502 void *argp1 = 0 ;
13503 int res1 = 0 ;
13504 PyObject *swig_obj[1] ;
13505
13506 if (!args) SWIG_fail;
13507 swig_obj[0] = args;
13508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13509 if (!SWIG_IsOK(res1)) {
13510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13511 }
13512 arg1 = reinterpret_cast< wxImage * >(argp1);
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 (arg1)->Destroy();
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 resultobj = SWIG_Py_Void();
13520 return resultobj;
13521 fail:
13522 return NULL;
13523 }
13524
13525
13526 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13527 PyObject *resultobj = 0;
13528 wxImage *arg1 = (wxImage *) 0 ;
13529 int arg2 ;
13530 int arg3 ;
13531 SwigValueWrapper<wxImage > result;
13532 void *argp1 = 0 ;
13533 int res1 = 0 ;
13534 int val2 ;
13535 int ecode2 = 0 ;
13536 int val3 ;
13537 int ecode3 = 0 ;
13538 PyObject * obj0 = 0 ;
13539 PyObject * obj1 = 0 ;
13540 PyObject * obj2 = 0 ;
13541 char * kwnames[] = {
13542 (char *) "self",(char *) "width",(char *) "height", NULL
13543 };
13544
13545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13547 if (!SWIG_IsOK(res1)) {
13548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13549 }
13550 arg1 = reinterpret_cast< wxImage * >(argp1);
13551 ecode2 = SWIG_AsVal_int(obj1, &val2);
13552 if (!SWIG_IsOK(ecode2)) {
13553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13554 }
13555 arg2 = static_cast< int >(val2);
13556 ecode3 = SWIG_AsVal_int(obj2, &val3);
13557 if (!SWIG_IsOK(ecode3)) {
13558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13559 }
13560 arg3 = static_cast< int >(val3);
13561 {
13562 PyThreadState* __tstate = wxPyBeginAllowThreads();
13563 result = (arg1)->Scale(arg2,arg3);
13564 wxPyEndAllowThreads(__tstate);
13565 if (PyErr_Occurred()) SWIG_fail;
13566 }
13567 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13568 return resultobj;
13569 fail:
13570 return NULL;
13571 }
13572
13573
13574 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13575 PyObject *resultobj = 0;
13576 wxImage *arg1 = (wxImage *) 0 ;
13577 int arg2 ;
13578 int arg3 ;
13579 SwigValueWrapper<wxImage > result;
13580 void *argp1 = 0 ;
13581 int res1 = 0 ;
13582 int val2 ;
13583 int ecode2 = 0 ;
13584 int val3 ;
13585 int ecode3 = 0 ;
13586 PyObject * obj0 = 0 ;
13587 PyObject * obj1 = 0 ;
13588 PyObject * obj2 = 0 ;
13589 char * kwnames[] = {
13590 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13591 };
13592
13593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13595 if (!SWIG_IsOK(res1)) {
13596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13597 }
13598 arg1 = reinterpret_cast< wxImage * >(argp1);
13599 ecode2 = SWIG_AsVal_int(obj1, &val2);
13600 if (!SWIG_IsOK(ecode2)) {
13601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13602 }
13603 arg2 = static_cast< int >(val2);
13604 ecode3 = SWIG_AsVal_int(obj2, &val3);
13605 if (!SWIG_IsOK(ecode3)) {
13606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13607 }
13608 arg3 = static_cast< int >(val3);
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13623 PyObject *resultobj = 0;
13624 wxImage *arg1 = (wxImage *) 0 ;
13625 int arg2 ;
13626 int arg3 ;
13627 wxImage *result = 0 ;
13628 void *argp1 = 0 ;
13629 int res1 = 0 ;
13630 int val2 ;
13631 int ecode2 = 0 ;
13632 int val3 ;
13633 int ecode3 = 0 ;
13634 PyObject * obj0 = 0 ;
13635 PyObject * obj1 = 0 ;
13636 PyObject * obj2 = 0 ;
13637 char * kwnames[] = {
13638 (char *) "self",(char *) "width",(char *) "height", NULL
13639 };
13640
13641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13643 if (!SWIG_IsOK(res1)) {
13644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13645 }
13646 arg1 = reinterpret_cast< wxImage * >(argp1);
13647 ecode2 = SWIG_AsVal_int(obj1, &val2);
13648 if (!SWIG_IsOK(ecode2)) {
13649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13650 }
13651 arg2 = static_cast< int >(val2);
13652 ecode3 = SWIG_AsVal_int(obj2, &val3);
13653 if (!SWIG_IsOK(ecode3)) {
13654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13655 }
13656 arg3 = static_cast< int >(val3);
13657 {
13658 PyThreadState* __tstate = wxPyBeginAllowThreads();
13659 {
13660 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13661 result = (wxImage *) &_result_ref;
13662 }
13663 wxPyEndAllowThreads(__tstate);
13664 if (PyErr_Occurred()) SWIG_fail;
13665 }
13666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13667 return resultobj;
13668 fail:
13669 return NULL;
13670 }
13671
13672
13673 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13674 PyObject *resultobj = 0;
13675 wxImage *arg1 = (wxImage *) 0 ;
13676 wxSize *arg2 = 0 ;
13677 wxPoint *arg3 = 0 ;
13678 int arg4 = (int) -1 ;
13679 int arg5 = (int) -1 ;
13680 int arg6 = (int) -1 ;
13681 wxImage *result = 0 ;
13682 void *argp1 = 0 ;
13683 int res1 = 0 ;
13684 wxSize temp2 ;
13685 wxPoint temp3 ;
13686 int val4 ;
13687 int ecode4 = 0 ;
13688 int val5 ;
13689 int ecode5 = 0 ;
13690 int val6 ;
13691 int ecode6 = 0 ;
13692 PyObject * obj0 = 0 ;
13693 PyObject * obj1 = 0 ;
13694 PyObject * obj2 = 0 ;
13695 PyObject * obj3 = 0 ;
13696 PyObject * obj4 = 0 ;
13697 PyObject * obj5 = 0 ;
13698 char * kwnames[] = {
13699 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13700 };
13701
13702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13704 if (!SWIG_IsOK(res1)) {
13705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13706 }
13707 arg1 = reinterpret_cast< wxImage * >(argp1);
13708 {
13709 arg2 = &temp2;
13710 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13711 }
13712 {
13713 arg3 = &temp3;
13714 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13715 }
13716 if (obj3) {
13717 ecode4 = SWIG_AsVal_int(obj3, &val4);
13718 if (!SWIG_IsOK(ecode4)) {
13719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13720 }
13721 arg4 = static_cast< int >(val4);
13722 }
13723 if (obj4) {
13724 ecode5 = SWIG_AsVal_int(obj4, &val5);
13725 if (!SWIG_IsOK(ecode5)) {
13726 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13727 }
13728 arg5 = static_cast< int >(val5);
13729 }
13730 if (obj5) {
13731 ecode6 = SWIG_AsVal_int(obj5, &val6);
13732 if (!SWIG_IsOK(ecode6)) {
13733 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13734 }
13735 arg6 = static_cast< int >(val6);
13736 }
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 {
13740 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13741 result = (wxImage *) &_result_ref;
13742 }
13743 wxPyEndAllowThreads(__tstate);
13744 if (PyErr_Occurred()) SWIG_fail;
13745 }
13746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13747 return resultobj;
13748 fail:
13749 return NULL;
13750 }
13751
13752
13753 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13754 PyObject *resultobj = 0;
13755 wxImage *arg1 = (wxImage *) 0 ;
13756 int arg2 ;
13757 int arg3 ;
13758 byte arg4 ;
13759 byte arg5 ;
13760 byte arg6 ;
13761 void *argp1 = 0 ;
13762 int res1 = 0 ;
13763 int val2 ;
13764 int ecode2 = 0 ;
13765 int val3 ;
13766 int ecode3 = 0 ;
13767 unsigned char val4 ;
13768 int ecode4 = 0 ;
13769 unsigned char val5 ;
13770 int ecode5 = 0 ;
13771 unsigned char val6 ;
13772 int ecode6 = 0 ;
13773 PyObject * obj0 = 0 ;
13774 PyObject * obj1 = 0 ;
13775 PyObject * obj2 = 0 ;
13776 PyObject * obj3 = 0 ;
13777 PyObject * obj4 = 0 ;
13778 PyObject * obj5 = 0 ;
13779 char * kwnames[] = {
13780 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13781 };
13782
13783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13787 }
13788 arg1 = reinterpret_cast< wxImage * >(argp1);
13789 ecode2 = SWIG_AsVal_int(obj1, &val2);
13790 if (!SWIG_IsOK(ecode2)) {
13791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13792 }
13793 arg2 = static_cast< int >(val2);
13794 ecode3 = SWIG_AsVal_int(obj2, &val3);
13795 if (!SWIG_IsOK(ecode3)) {
13796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13797 }
13798 arg3 = static_cast< int >(val3);
13799 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13800 if (!SWIG_IsOK(ecode4)) {
13801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13802 }
13803 arg4 = static_cast< byte >(val4);
13804 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13805 if (!SWIG_IsOK(ecode5)) {
13806 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13807 }
13808 arg5 = static_cast< byte >(val5);
13809 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13810 if (!SWIG_IsOK(ecode6)) {
13811 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13812 }
13813 arg6 = static_cast< byte >(val6);
13814 {
13815 PyThreadState* __tstate = wxPyBeginAllowThreads();
13816 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 resultobj = SWIG_Py_Void();
13821 return resultobj;
13822 fail:
13823 return NULL;
13824 }
13825
13826
13827 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13828 PyObject *resultobj = 0;
13829 wxImage *arg1 = (wxImage *) 0 ;
13830 wxRect *arg2 = 0 ;
13831 byte arg3 ;
13832 byte arg4 ;
13833 byte arg5 ;
13834 void *argp1 = 0 ;
13835 int res1 = 0 ;
13836 wxRect temp2 ;
13837 unsigned char val3 ;
13838 int ecode3 = 0 ;
13839 unsigned char val4 ;
13840 int ecode4 = 0 ;
13841 unsigned char val5 ;
13842 int ecode5 = 0 ;
13843 PyObject * obj0 = 0 ;
13844 PyObject * obj1 = 0 ;
13845 PyObject * obj2 = 0 ;
13846 PyObject * obj3 = 0 ;
13847 PyObject * obj4 = 0 ;
13848 char * kwnames[] = {
13849 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13850 };
13851
13852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13854 if (!SWIG_IsOK(res1)) {
13855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13856 }
13857 arg1 = reinterpret_cast< wxImage * >(argp1);
13858 {
13859 arg2 = &temp2;
13860 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13861 }
13862 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13863 if (!SWIG_IsOK(ecode3)) {
13864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13865 }
13866 arg3 = static_cast< byte >(val3);
13867 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13868 if (!SWIG_IsOK(ecode4)) {
13869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13870 }
13871 arg4 = static_cast< byte >(val4);
13872 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13873 if (!SWIG_IsOK(ecode5)) {
13874 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13875 }
13876 arg5 = static_cast< byte >(val5);
13877 {
13878 PyThreadState* __tstate = wxPyBeginAllowThreads();
13879 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13880 wxPyEndAllowThreads(__tstate);
13881 if (PyErr_Occurred()) SWIG_fail;
13882 }
13883 resultobj = SWIG_Py_Void();
13884 return resultobj;
13885 fail:
13886 return NULL;
13887 }
13888
13889
13890 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj = 0;
13892 wxImage *arg1 = (wxImage *) 0 ;
13893 int arg2 ;
13894 int arg3 ;
13895 byte result;
13896 void *argp1 = 0 ;
13897 int res1 = 0 ;
13898 int val2 ;
13899 int ecode2 = 0 ;
13900 int val3 ;
13901 int ecode3 = 0 ;
13902 PyObject * obj0 = 0 ;
13903 PyObject * obj1 = 0 ;
13904 PyObject * obj2 = 0 ;
13905 char * kwnames[] = {
13906 (char *) "self",(char *) "x",(char *) "y", NULL
13907 };
13908
13909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13911 if (!SWIG_IsOK(res1)) {
13912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13913 }
13914 arg1 = reinterpret_cast< wxImage * >(argp1);
13915 ecode2 = SWIG_AsVal_int(obj1, &val2);
13916 if (!SWIG_IsOK(ecode2)) {
13917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13918 }
13919 arg2 = static_cast< int >(val2);
13920 ecode3 = SWIG_AsVal_int(obj2, &val3);
13921 if (!SWIG_IsOK(ecode3)) {
13922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13923 }
13924 arg3 = static_cast< int >(val3);
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 result = (byte)(arg1)->GetRed(arg2,arg3);
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13932 return resultobj;
13933 fail:
13934 return NULL;
13935 }
13936
13937
13938 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13939 PyObject *resultobj = 0;
13940 wxImage *arg1 = (wxImage *) 0 ;
13941 int arg2 ;
13942 int arg3 ;
13943 byte result;
13944 void *argp1 = 0 ;
13945 int res1 = 0 ;
13946 int val2 ;
13947 int ecode2 = 0 ;
13948 int val3 ;
13949 int ecode3 = 0 ;
13950 PyObject * obj0 = 0 ;
13951 PyObject * obj1 = 0 ;
13952 PyObject * obj2 = 0 ;
13953 char * kwnames[] = {
13954 (char *) "self",(char *) "x",(char *) "y", NULL
13955 };
13956
13957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13959 if (!SWIG_IsOK(res1)) {
13960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13961 }
13962 arg1 = reinterpret_cast< wxImage * >(argp1);
13963 ecode2 = SWIG_AsVal_int(obj1, &val2);
13964 if (!SWIG_IsOK(ecode2)) {
13965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13966 }
13967 arg2 = static_cast< int >(val2);
13968 ecode3 = SWIG_AsVal_int(obj2, &val3);
13969 if (!SWIG_IsOK(ecode3)) {
13970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13971 }
13972 arg3 = static_cast< int >(val3);
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (byte)(arg1)->GetGreen(arg2,arg3);
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13987 PyObject *resultobj = 0;
13988 wxImage *arg1 = (wxImage *) 0 ;
13989 int arg2 ;
13990 int arg3 ;
13991 byte result;
13992 void *argp1 = 0 ;
13993 int res1 = 0 ;
13994 int val2 ;
13995 int ecode2 = 0 ;
13996 int val3 ;
13997 int ecode3 = 0 ;
13998 PyObject * obj0 = 0 ;
13999 PyObject * obj1 = 0 ;
14000 PyObject * obj2 = 0 ;
14001 char * kwnames[] = {
14002 (char *) "self",(char *) "x",(char *) "y", NULL
14003 };
14004
14005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14007 if (!SWIG_IsOK(res1)) {
14008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14009 }
14010 arg1 = reinterpret_cast< wxImage * >(argp1);
14011 ecode2 = SWIG_AsVal_int(obj1, &val2);
14012 if (!SWIG_IsOK(ecode2)) {
14013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14014 }
14015 arg2 = static_cast< int >(val2);
14016 ecode3 = SWIG_AsVal_int(obj2, &val3);
14017 if (!SWIG_IsOK(ecode3)) {
14018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14019 }
14020 arg3 = static_cast< int >(val3);
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 result = (byte)(arg1)->GetBlue(arg2,arg3);
14024 wxPyEndAllowThreads(__tstate);
14025 if (PyErr_Occurred()) SWIG_fail;
14026 }
14027 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14028 return resultobj;
14029 fail:
14030 return NULL;
14031 }
14032
14033
14034 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14035 PyObject *resultobj = 0;
14036 wxImage *arg1 = (wxImage *) 0 ;
14037 int arg2 ;
14038 int arg3 ;
14039 byte arg4 ;
14040 void *argp1 = 0 ;
14041 int res1 = 0 ;
14042 int val2 ;
14043 int ecode2 = 0 ;
14044 int val3 ;
14045 int ecode3 = 0 ;
14046 unsigned char val4 ;
14047 int ecode4 = 0 ;
14048 PyObject * obj0 = 0 ;
14049 PyObject * obj1 = 0 ;
14050 PyObject * obj2 = 0 ;
14051 PyObject * obj3 = 0 ;
14052 char * kwnames[] = {
14053 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14054 };
14055
14056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14058 if (!SWIG_IsOK(res1)) {
14059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14060 }
14061 arg1 = reinterpret_cast< wxImage * >(argp1);
14062 ecode2 = SWIG_AsVal_int(obj1, &val2);
14063 if (!SWIG_IsOK(ecode2)) {
14064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14065 }
14066 arg2 = static_cast< int >(val2);
14067 ecode3 = SWIG_AsVal_int(obj2, &val3);
14068 if (!SWIG_IsOK(ecode3)) {
14069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14070 }
14071 arg3 = static_cast< int >(val3);
14072 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14073 if (!SWIG_IsOK(ecode4)) {
14074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14075 }
14076 arg4 = static_cast< byte >(val4);
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 (arg1)->SetAlpha(arg2,arg3,arg4);
14080 wxPyEndAllowThreads(__tstate);
14081 if (PyErr_Occurred()) SWIG_fail;
14082 }
14083 resultobj = SWIG_Py_Void();
14084 return resultobj;
14085 fail:
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj = 0;
14092 wxImage *arg1 = (wxImage *) 0 ;
14093 int arg2 ;
14094 int arg3 ;
14095 byte result;
14096 void *argp1 = 0 ;
14097 int res1 = 0 ;
14098 int val2 ;
14099 int ecode2 = 0 ;
14100 int val3 ;
14101 int ecode3 = 0 ;
14102 PyObject * obj0 = 0 ;
14103 PyObject * obj1 = 0 ;
14104 PyObject * obj2 = 0 ;
14105 char * kwnames[] = {
14106 (char *) "self",(char *) "x",(char *) "y", NULL
14107 };
14108
14109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14111 if (!SWIG_IsOK(res1)) {
14112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14113 }
14114 arg1 = reinterpret_cast< wxImage * >(argp1);
14115 ecode2 = SWIG_AsVal_int(obj1, &val2);
14116 if (!SWIG_IsOK(ecode2)) {
14117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14118 }
14119 arg2 = static_cast< int >(val2);
14120 ecode3 = SWIG_AsVal_int(obj2, &val3);
14121 if (!SWIG_IsOK(ecode3)) {
14122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14123 }
14124 arg3 = static_cast< int >(val3);
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14132 return resultobj;
14133 fail:
14134 return NULL;
14135 }
14136
14137
14138 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14139 PyObject *resultobj = 0;
14140 wxImage *arg1 = (wxImage *) 0 ;
14141 bool result;
14142 void *argp1 = 0 ;
14143 int res1 = 0 ;
14144 PyObject *swig_obj[1] ;
14145
14146 if (!args) SWIG_fail;
14147 swig_obj[0] = args;
14148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14149 if (!SWIG_IsOK(res1)) {
14150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14151 }
14152 arg1 = reinterpret_cast< wxImage * >(argp1);
14153 {
14154 PyThreadState* __tstate = wxPyBeginAllowThreads();
14155 result = (bool)(arg1)->HasAlpha();
14156 wxPyEndAllowThreads(__tstate);
14157 if (PyErr_Occurred()) SWIG_fail;
14158 }
14159 {
14160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14161 }
14162 return resultobj;
14163 fail:
14164 return NULL;
14165 }
14166
14167
14168 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14169 PyObject *resultobj = 0;
14170 wxImage *arg1 = (wxImage *) 0 ;
14171 void *argp1 = 0 ;
14172 int res1 = 0 ;
14173 PyObject *swig_obj[1] ;
14174
14175 if (!args) SWIG_fail;
14176 swig_obj[0] = args;
14177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14178 if (!SWIG_IsOK(res1)) {
14179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14180 }
14181 arg1 = reinterpret_cast< wxImage * >(argp1);
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 (arg1)->InitAlpha();
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 resultobj = SWIG_Py_Void();
14189 return resultobj;
14190 fail:
14191 return NULL;
14192 }
14193
14194
14195 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14196 PyObject *resultobj = 0;
14197 wxImage *arg1 = (wxImage *) 0 ;
14198 int arg2 ;
14199 int arg3 ;
14200 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14201 bool result;
14202 void *argp1 = 0 ;
14203 int res1 = 0 ;
14204 int val2 ;
14205 int ecode2 = 0 ;
14206 int val3 ;
14207 int ecode3 = 0 ;
14208 unsigned char val4 ;
14209 int ecode4 = 0 ;
14210 PyObject * obj0 = 0 ;
14211 PyObject * obj1 = 0 ;
14212 PyObject * obj2 = 0 ;
14213 PyObject * obj3 = 0 ;
14214 char * kwnames[] = {
14215 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14216 };
14217
14218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14220 if (!SWIG_IsOK(res1)) {
14221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14222 }
14223 arg1 = reinterpret_cast< wxImage * >(argp1);
14224 ecode2 = SWIG_AsVal_int(obj1, &val2);
14225 if (!SWIG_IsOK(ecode2)) {
14226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14227 }
14228 arg2 = static_cast< int >(val2);
14229 ecode3 = SWIG_AsVal_int(obj2, &val3);
14230 if (!SWIG_IsOK(ecode3)) {
14231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14232 }
14233 arg3 = static_cast< int >(val3);
14234 if (obj3) {
14235 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14236 if (!SWIG_IsOK(ecode4)) {
14237 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14238 }
14239 arg4 = static_cast< byte >(val4);
14240 }
14241 {
14242 PyThreadState* __tstate = wxPyBeginAllowThreads();
14243 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 {
14248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14249 }
14250 return resultobj;
14251 fail:
14252 return NULL;
14253 }
14254
14255
14256 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14257 PyObject *resultobj = 0;
14258 wxImage *arg1 = (wxImage *) 0 ;
14259 byte *arg2 = (byte *) 0 ;
14260 byte *arg3 = (byte *) 0 ;
14261 byte *arg4 = (byte *) 0 ;
14262 byte arg5 = (byte) 0 ;
14263 byte arg6 = (byte) 0 ;
14264 byte arg7 = (byte) 0 ;
14265 bool result;
14266 void *argp1 = 0 ;
14267 int res1 = 0 ;
14268 byte temp2 ;
14269 int res2 = SWIG_TMPOBJ ;
14270 byte temp3 ;
14271 int res3 = SWIG_TMPOBJ ;
14272 byte temp4 ;
14273 int res4 = SWIG_TMPOBJ ;
14274 unsigned char val5 ;
14275 int ecode5 = 0 ;
14276 unsigned char val6 ;
14277 int ecode6 = 0 ;
14278 unsigned char val7 ;
14279 int ecode7 = 0 ;
14280 PyObject * obj0 = 0 ;
14281 PyObject * obj1 = 0 ;
14282 PyObject * obj2 = 0 ;
14283 PyObject * obj3 = 0 ;
14284 char * kwnames[] = {
14285 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14286 };
14287
14288 arg2 = &temp2;
14289 arg3 = &temp3;
14290 arg4 = &temp4;
14291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14293 if (!SWIG_IsOK(res1)) {
14294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14295 }
14296 arg1 = reinterpret_cast< wxImage * >(argp1);
14297 if (obj1) {
14298 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14299 if (!SWIG_IsOK(ecode5)) {
14300 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14301 }
14302 arg5 = static_cast< byte >(val5);
14303 }
14304 if (obj2) {
14305 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14306 if (!SWIG_IsOK(ecode6)) {
14307 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14308 }
14309 arg6 = static_cast< byte >(val6);
14310 }
14311 if (obj3) {
14312 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14313 if (!SWIG_IsOK(ecode7)) {
14314 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14315 }
14316 arg7 = static_cast< byte >(val7);
14317 }
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 {
14325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14326 }
14327 if (SWIG_IsTmpObj(res2)) {
14328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14329 } else {
14330 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14332 }
14333 if (SWIG_IsTmpObj(res3)) {
14334 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14335 } else {
14336 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14337 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14338 }
14339 if (SWIG_IsTmpObj(res4)) {
14340 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14341 } else {
14342 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14344 }
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14352 PyObject *resultobj = 0;
14353 wxImage *arg1 = (wxImage *) 0 ;
14354 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14355 bool result;
14356 void *argp1 = 0 ;
14357 int res1 = 0 ;
14358 unsigned char val2 ;
14359 int ecode2 = 0 ;
14360 PyObject * obj0 = 0 ;
14361 PyObject * obj1 = 0 ;
14362 char * kwnames[] = {
14363 (char *) "self",(char *) "threshold", NULL
14364 };
14365
14366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14368 if (!SWIG_IsOK(res1)) {
14369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14370 }
14371 arg1 = reinterpret_cast< wxImage * >(argp1);
14372 if (obj1) {
14373 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14374 if (!SWIG_IsOK(ecode2)) {
14375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14376 }
14377 arg2 = static_cast< byte >(val2);
14378 }
14379 {
14380 PyThreadState* __tstate = wxPyBeginAllowThreads();
14381 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 {
14386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14387 }
14388 return resultobj;
14389 fail:
14390 return NULL;
14391 }
14392
14393
14394 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14395 PyObject *resultobj = 0;
14396 wxImage *arg1 = (wxImage *) 0 ;
14397 byte arg2 ;
14398 byte arg3 ;
14399 byte arg4 ;
14400 bool result;
14401 void *argp1 = 0 ;
14402 int res1 = 0 ;
14403 unsigned char val2 ;
14404 int ecode2 = 0 ;
14405 unsigned char val3 ;
14406 int ecode3 = 0 ;
14407 unsigned char val4 ;
14408 int ecode4 = 0 ;
14409 PyObject * obj0 = 0 ;
14410 PyObject * obj1 = 0 ;
14411 PyObject * obj2 = 0 ;
14412 PyObject * obj3 = 0 ;
14413 char * kwnames[] = {
14414 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14415 };
14416
14417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14419 if (!SWIG_IsOK(res1)) {
14420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14421 }
14422 arg1 = reinterpret_cast< wxImage * >(argp1);
14423 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14424 if (!SWIG_IsOK(ecode2)) {
14425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14426 }
14427 arg2 = static_cast< byte >(val2);
14428 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14429 if (!SWIG_IsOK(ecode3)) {
14430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14431 }
14432 arg3 = static_cast< byte >(val3);
14433 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14434 if (!SWIG_IsOK(ecode4)) {
14435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14436 }
14437 arg4 = static_cast< byte >(val4);
14438 {
14439 PyThreadState* __tstate = wxPyBeginAllowThreads();
14440 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14441 wxPyEndAllowThreads(__tstate);
14442 if (PyErr_Occurred()) SWIG_fail;
14443 }
14444 {
14445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14446 }
14447 return resultobj;
14448 fail:
14449 return NULL;
14450 }
14451
14452
14453 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14454 PyObject *resultobj = 0;
14455 wxImage *arg1 = (wxImage *) 0 ;
14456 wxImage *arg2 = 0 ;
14457 byte arg3 ;
14458 byte arg4 ;
14459 byte arg5 ;
14460 bool result;
14461 void *argp1 = 0 ;
14462 int res1 = 0 ;
14463 void *argp2 = 0 ;
14464 int res2 = 0 ;
14465 unsigned char val3 ;
14466 int ecode3 = 0 ;
14467 unsigned char val4 ;
14468 int ecode4 = 0 ;
14469 unsigned char val5 ;
14470 int ecode5 = 0 ;
14471 PyObject * obj0 = 0 ;
14472 PyObject * obj1 = 0 ;
14473 PyObject * obj2 = 0 ;
14474 PyObject * obj3 = 0 ;
14475 PyObject * obj4 = 0 ;
14476 char * kwnames[] = {
14477 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14478 };
14479
14480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14482 if (!SWIG_IsOK(res1)) {
14483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14484 }
14485 arg1 = reinterpret_cast< wxImage * >(argp1);
14486 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14487 if (!SWIG_IsOK(res2)) {
14488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14489 }
14490 if (!argp2) {
14491 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14492 }
14493 arg2 = reinterpret_cast< wxImage * >(argp2);
14494 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14495 if (!SWIG_IsOK(ecode3)) {
14496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14497 }
14498 arg3 = static_cast< byte >(val3);
14499 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14500 if (!SWIG_IsOK(ecode4)) {
14501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14502 }
14503 arg4 = static_cast< byte >(val4);
14504 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14505 if (!SWIG_IsOK(ecode5)) {
14506 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14507 }
14508 arg5 = static_cast< byte >(val5);
14509 {
14510 PyThreadState* __tstate = wxPyBeginAllowThreads();
14511 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14512 wxPyEndAllowThreads(__tstate);
14513 if (PyErr_Occurred()) SWIG_fail;
14514 }
14515 {
14516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14517 }
14518 return resultobj;
14519 fail:
14520 return NULL;
14521 }
14522
14523
14524 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14525 PyObject *resultobj = 0;
14526 wxString *arg1 = 0 ;
14527 bool result;
14528 bool temp1 = false ;
14529 PyObject * obj0 = 0 ;
14530 char * kwnames[] = {
14531 (char *) "filename", NULL
14532 };
14533
14534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14535 {
14536 arg1 = wxString_in_helper(obj0);
14537 if (arg1 == NULL) SWIG_fail;
14538 temp1 = true;
14539 }
14540 {
14541 PyThreadState* __tstate = wxPyBeginAllowThreads();
14542 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14543 wxPyEndAllowThreads(__tstate);
14544 if (PyErr_Occurred()) SWIG_fail;
14545 }
14546 {
14547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14548 }
14549 {
14550 if (temp1)
14551 delete arg1;
14552 }
14553 return resultobj;
14554 fail:
14555 {
14556 if (temp1)
14557 delete arg1;
14558 }
14559 return NULL;
14560 }
14561
14562
14563 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14564 PyObject *resultobj = 0;
14565 wxString *arg1 = 0 ;
14566 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14567 int result;
14568 bool temp1 = false ;
14569 long val2 ;
14570 int ecode2 = 0 ;
14571 PyObject * obj0 = 0 ;
14572 PyObject * obj1 = 0 ;
14573 char * kwnames[] = {
14574 (char *) "filename",(char *) "type", NULL
14575 };
14576
14577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14578 {
14579 arg1 = wxString_in_helper(obj0);
14580 if (arg1 == NULL) SWIG_fail;
14581 temp1 = true;
14582 }
14583 if (obj1) {
14584 ecode2 = SWIG_AsVal_long(obj1, &val2);
14585 if (!SWIG_IsOK(ecode2)) {
14586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14587 }
14588 arg2 = static_cast< long >(val2);
14589 }
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 resultobj = SWIG_From_int(static_cast< int >(result));
14597 {
14598 if (temp1)
14599 delete arg1;
14600 }
14601 return resultobj;
14602 fail:
14603 {
14604 if (temp1)
14605 delete arg1;
14606 }
14607 return NULL;
14608 }
14609
14610
14611 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14612 PyObject *resultobj = 0;
14613 wxImage *arg1 = (wxImage *) 0 ;
14614 wxString *arg2 = 0 ;
14615 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14616 int arg4 = (int) -1 ;
14617 bool result;
14618 void *argp1 = 0 ;
14619 int res1 = 0 ;
14620 bool temp2 = false ;
14621 long val3 ;
14622 int ecode3 = 0 ;
14623 int val4 ;
14624 int ecode4 = 0 ;
14625 PyObject * obj0 = 0 ;
14626 PyObject * obj1 = 0 ;
14627 PyObject * obj2 = 0 ;
14628 PyObject * obj3 = 0 ;
14629 char * kwnames[] = {
14630 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14631 };
14632
14633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14635 if (!SWIG_IsOK(res1)) {
14636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14637 }
14638 arg1 = reinterpret_cast< wxImage * >(argp1);
14639 {
14640 arg2 = wxString_in_helper(obj1);
14641 if (arg2 == NULL) SWIG_fail;
14642 temp2 = true;
14643 }
14644 if (obj2) {
14645 ecode3 = SWIG_AsVal_long(obj2, &val3);
14646 if (!SWIG_IsOK(ecode3)) {
14647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14648 }
14649 arg3 = static_cast< long >(val3);
14650 }
14651 if (obj3) {
14652 ecode4 = SWIG_AsVal_int(obj3, &val4);
14653 if (!SWIG_IsOK(ecode4)) {
14654 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14655 }
14656 arg4 = static_cast< int >(val4);
14657 }
14658 {
14659 PyThreadState* __tstate = wxPyBeginAllowThreads();
14660 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14661 wxPyEndAllowThreads(__tstate);
14662 if (PyErr_Occurred()) SWIG_fail;
14663 }
14664 {
14665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14666 }
14667 {
14668 if (temp2)
14669 delete arg2;
14670 }
14671 return resultobj;
14672 fail:
14673 {
14674 if (temp2)
14675 delete arg2;
14676 }
14677 return NULL;
14678 }
14679
14680
14681 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14682 PyObject *resultobj = 0;
14683 wxImage *arg1 = (wxImage *) 0 ;
14684 wxString *arg2 = 0 ;
14685 wxString *arg3 = 0 ;
14686 int arg4 = (int) -1 ;
14687 bool result;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 bool temp2 = false ;
14691 bool temp3 = false ;
14692 int val4 ;
14693 int ecode4 = 0 ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 PyObject * obj2 = 0 ;
14697 PyObject * obj3 = 0 ;
14698 char * kwnames[] = {
14699 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14700 };
14701
14702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14704 if (!SWIG_IsOK(res1)) {
14705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14706 }
14707 arg1 = reinterpret_cast< wxImage * >(argp1);
14708 {
14709 arg2 = wxString_in_helper(obj1);
14710 if (arg2 == NULL) SWIG_fail;
14711 temp2 = true;
14712 }
14713 {
14714 arg3 = wxString_in_helper(obj2);
14715 if (arg3 == NULL) SWIG_fail;
14716 temp3 = true;
14717 }
14718 if (obj3) {
14719 ecode4 = SWIG_AsVal_int(obj3, &val4);
14720 if (!SWIG_IsOK(ecode4)) {
14721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14722 }
14723 arg4 = static_cast< int >(val4);
14724 }
14725 {
14726 PyThreadState* __tstate = wxPyBeginAllowThreads();
14727 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 {
14732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14733 }
14734 {
14735 if (temp2)
14736 delete arg2;
14737 }
14738 {
14739 if (temp3)
14740 delete arg3;
14741 }
14742 return resultobj;
14743 fail:
14744 {
14745 if (temp2)
14746 delete arg2;
14747 }
14748 {
14749 if (temp3)
14750 delete arg3;
14751 }
14752 return NULL;
14753 }
14754
14755
14756 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14757 PyObject *resultobj = 0;
14758 wxImage *arg1 = (wxImage *) 0 ;
14759 wxString *arg2 = 0 ;
14760 int arg3 ;
14761 bool result;
14762 void *argp1 = 0 ;
14763 int res1 = 0 ;
14764 bool temp2 = false ;
14765 int val3 ;
14766 int ecode3 = 0 ;
14767 PyObject * obj0 = 0 ;
14768 PyObject * obj1 = 0 ;
14769 PyObject * obj2 = 0 ;
14770 char * kwnames[] = {
14771 (char *) "self",(char *) "name",(char *) "type", NULL
14772 };
14773
14774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14776 if (!SWIG_IsOK(res1)) {
14777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14778 }
14779 arg1 = reinterpret_cast< wxImage * >(argp1);
14780 {
14781 arg2 = wxString_in_helper(obj1);
14782 if (arg2 == NULL) SWIG_fail;
14783 temp2 = true;
14784 }
14785 ecode3 = SWIG_AsVal_int(obj2, &val3);
14786 if (!SWIG_IsOK(ecode3)) {
14787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14788 }
14789 arg3 = static_cast< int >(val3);
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
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 return resultobj;
14804 fail:
14805 {
14806 if (temp2)
14807 delete arg2;
14808 }
14809 return NULL;
14810 }
14811
14812
14813 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14814 PyObject *resultobj = 0;
14815 wxImage *arg1 = (wxImage *) 0 ;
14816 wxString *arg2 = 0 ;
14817 wxString *arg3 = 0 ;
14818 bool result;
14819 void *argp1 = 0 ;
14820 int res1 = 0 ;
14821 bool temp2 = false ;
14822 bool temp3 = false ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 PyObject * obj2 = 0 ;
14826 char * kwnames[] = {
14827 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14828 };
14829
14830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14832 if (!SWIG_IsOK(res1)) {
14833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14834 }
14835 arg1 = reinterpret_cast< wxImage * >(argp1);
14836 {
14837 arg2 = wxString_in_helper(obj1);
14838 if (arg2 == NULL) SWIG_fail;
14839 temp2 = true;
14840 }
14841 {
14842 arg3 = wxString_in_helper(obj2);
14843 if (arg3 == NULL) SWIG_fail;
14844 temp3 = true;
14845 }
14846 {
14847 PyThreadState* __tstate = wxPyBeginAllowThreads();
14848 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14849 wxPyEndAllowThreads(__tstate);
14850 if (PyErr_Occurred()) SWIG_fail;
14851 }
14852 {
14853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14854 }
14855 {
14856 if (temp2)
14857 delete arg2;
14858 }
14859 {
14860 if (temp3)
14861 delete arg3;
14862 }
14863 return resultobj;
14864 fail:
14865 {
14866 if (temp2)
14867 delete arg2;
14868 }
14869 {
14870 if (temp3)
14871 delete arg3;
14872 }
14873 return NULL;
14874 }
14875
14876
14877 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14878 PyObject *resultobj = 0;
14879 wxInputStream *arg1 = 0 ;
14880 bool result;
14881 wxPyInputStream *temp1 ;
14882 bool created1 ;
14883 PyObject * obj0 = 0 ;
14884 char * kwnames[] = {
14885 (char *) "stream", NULL
14886 };
14887
14888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14889 {
14890 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14891 arg1 = temp1->m_wxis;
14892 created1 = false;
14893 } else {
14894 PyErr_Clear(); // clear the failure of the wxPyConvert above
14895 arg1 = wxPyCBInputStream_create(obj0, false);
14896 if (arg1 == NULL) {
14897 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14898 SWIG_fail;
14899 }
14900 created1 = true;
14901 }
14902 }
14903 {
14904 PyThreadState* __tstate = wxPyBeginAllowThreads();
14905 result = (bool)wxImage::CanRead(*arg1);
14906 wxPyEndAllowThreads(__tstate);
14907 if (PyErr_Occurred()) SWIG_fail;
14908 }
14909 {
14910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14911 }
14912 {
14913 if (created1) delete arg1;
14914 }
14915 return resultobj;
14916 fail:
14917 {
14918 if (created1) delete arg1;
14919 }
14920 return NULL;
14921 }
14922
14923
14924 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14925 PyObject *resultobj = 0;
14926 wxImage *arg1 = (wxImage *) 0 ;
14927 wxInputStream *arg2 = 0 ;
14928 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14929 int arg4 = (int) -1 ;
14930 bool result;
14931 void *argp1 = 0 ;
14932 int res1 = 0 ;
14933 wxPyInputStream *temp2 ;
14934 bool created2 ;
14935 long val3 ;
14936 int ecode3 = 0 ;
14937 int val4 ;
14938 int ecode4 = 0 ;
14939 PyObject * obj0 = 0 ;
14940 PyObject * obj1 = 0 ;
14941 PyObject * obj2 = 0 ;
14942 PyObject * obj3 = 0 ;
14943 char * kwnames[] = {
14944 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14945 };
14946
14947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14949 if (!SWIG_IsOK(res1)) {
14950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14951 }
14952 arg1 = reinterpret_cast< wxImage * >(argp1);
14953 {
14954 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14955 arg2 = temp2->m_wxis;
14956 created2 = false;
14957 } else {
14958 PyErr_Clear(); // clear the failure of the wxPyConvert above
14959 arg2 = wxPyCBInputStream_create(obj1, false);
14960 if (arg2 == NULL) {
14961 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14962 SWIG_fail;
14963 }
14964 created2 = true;
14965 }
14966 }
14967 if (obj2) {
14968 ecode3 = SWIG_AsVal_long(obj2, &val3);
14969 if (!SWIG_IsOK(ecode3)) {
14970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14971 }
14972 arg3 = static_cast< long >(val3);
14973 }
14974 if (obj3) {
14975 ecode4 = SWIG_AsVal_int(obj3, &val4);
14976 if (!SWIG_IsOK(ecode4)) {
14977 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14978 }
14979 arg4 = static_cast< int >(val4);
14980 }
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14984 wxPyEndAllowThreads(__tstate);
14985 if (PyErr_Occurred()) SWIG_fail;
14986 }
14987 {
14988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14989 }
14990 {
14991 if (created2) delete arg2;
14992 }
14993 return resultobj;
14994 fail:
14995 {
14996 if (created2) delete arg2;
14997 }
14998 return NULL;
14999 }
15000
15001
15002 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15003 PyObject *resultobj = 0;
15004 wxImage *arg1 = (wxImage *) 0 ;
15005 wxInputStream *arg2 = 0 ;
15006 wxString *arg3 = 0 ;
15007 int arg4 = (int) -1 ;
15008 bool result;
15009 void *argp1 = 0 ;
15010 int res1 = 0 ;
15011 wxPyInputStream *temp2 ;
15012 bool created2 ;
15013 bool temp3 = false ;
15014 int val4 ;
15015 int ecode4 = 0 ;
15016 PyObject * obj0 = 0 ;
15017 PyObject * obj1 = 0 ;
15018 PyObject * obj2 = 0 ;
15019 PyObject * obj3 = 0 ;
15020 char * kwnames[] = {
15021 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15022 };
15023
15024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15026 if (!SWIG_IsOK(res1)) {
15027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15028 }
15029 arg1 = reinterpret_cast< wxImage * >(argp1);
15030 {
15031 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15032 arg2 = temp2->m_wxis;
15033 created2 = false;
15034 } else {
15035 PyErr_Clear(); // clear the failure of the wxPyConvert above
15036 arg2 = wxPyCBInputStream_create(obj1, false);
15037 if (arg2 == NULL) {
15038 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15039 SWIG_fail;
15040 }
15041 created2 = true;
15042 }
15043 }
15044 {
15045 arg3 = wxString_in_helper(obj2);
15046 if (arg3 == NULL) SWIG_fail;
15047 temp3 = true;
15048 }
15049 if (obj3) {
15050 ecode4 = SWIG_AsVal_int(obj3, &val4);
15051 if (!SWIG_IsOK(ecode4)) {
15052 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15053 }
15054 arg4 = static_cast< int >(val4);
15055 }
15056 {
15057 PyThreadState* __tstate = wxPyBeginAllowThreads();
15058 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15059 wxPyEndAllowThreads(__tstate);
15060 if (PyErr_Occurred()) SWIG_fail;
15061 }
15062 {
15063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15064 }
15065 {
15066 if (created2) delete arg2;
15067 }
15068 {
15069 if (temp3)
15070 delete arg3;
15071 }
15072 return resultobj;
15073 fail:
15074 {
15075 if (created2) delete arg2;
15076 }
15077 {
15078 if (temp3)
15079 delete arg3;
15080 }
15081 return NULL;
15082 }
15083
15084
15085 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15086 PyObject *resultobj = 0;
15087 wxImage *arg1 = (wxImage *) 0 ;
15088 bool result;
15089 void *argp1 = 0 ;
15090 int res1 = 0 ;
15091 PyObject *swig_obj[1] ;
15092
15093 if (!args) SWIG_fail;
15094 swig_obj[0] = args;
15095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15096 if (!SWIG_IsOK(res1)) {
15097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15098 }
15099 arg1 = reinterpret_cast< wxImage * >(argp1);
15100 {
15101 PyThreadState* __tstate = wxPyBeginAllowThreads();
15102 result = (bool)(arg1)->Ok();
15103 wxPyEndAllowThreads(__tstate);
15104 if (PyErr_Occurred()) SWIG_fail;
15105 }
15106 {
15107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15108 }
15109 return resultobj;
15110 fail:
15111 return NULL;
15112 }
15113
15114
15115 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15116 PyObject *resultobj = 0;
15117 wxImage *arg1 = (wxImage *) 0 ;
15118 int result;
15119 void *argp1 = 0 ;
15120 int res1 = 0 ;
15121 PyObject *swig_obj[1] ;
15122
15123 if (!args) SWIG_fail;
15124 swig_obj[0] = args;
15125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15126 if (!SWIG_IsOK(res1)) {
15127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15128 }
15129 arg1 = reinterpret_cast< wxImage * >(argp1);
15130 {
15131 PyThreadState* __tstate = wxPyBeginAllowThreads();
15132 result = (int)(arg1)->GetWidth();
15133 wxPyEndAllowThreads(__tstate);
15134 if (PyErr_Occurred()) SWIG_fail;
15135 }
15136 resultobj = SWIG_From_int(static_cast< int >(result));
15137 return resultobj;
15138 fail:
15139 return NULL;
15140 }
15141
15142
15143 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15144 PyObject *resultobj = 0;
15145 wxImage *arg1 = (wxImage *) 0 ;
15146 int result;
15147 void *argp1 = 0 ;
15148 int res1 = 0 ;
15149 PyObject *swig_obj[1] ;
15150
15151 if (!args) SWIG_fail;
15152 swig_obj[0] = args;
15153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15154 if (!SWIG_IsOK(res1)) {
15155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15156 }
15157 arg1 = reinterpret_cast< wxImage * >(argp1);
15158 {
15159 PyThreadState* __tstate = wxPyBeginAllowThreads();
15160 result = (int)(arg1)->GetHeight();
15161 wxPyEndAllowThreads(__tstate);
15162 if (PyErr_Occurred()) SWIG_fail;
15163 }
15164 resultobj = SWIG_From_int(static_cast< int >(result));
15165 return resultobj;
15166 fail:
15167 return NULL;
15168 }
15169
15170
15171 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15172 PyObject *resultobj = 0;
15173 wxImage *arg1 = (wxImage *) 0 ;
15174 wxSize result;
15175 void *argp1 = 0 ;
15176 int res1 = 0 ;
15177 PyObject *swig_obj[1] ;
15178
15179 if (!args) SWIG_fail;
15180 swig_obj[0] = args;
15181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15182 if (!SWIG_IsOK(res1)) {
15183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15184 }
15185 arg1 = reinterpret_cast< wxImage * >(argp1);
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 result = wxImage_GetSize(arg1);
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15200 PyObject *resultobj = 0;
15201 wxImage *arg1 = (wxImage *) 0 ;
15202 wxRect *arg2 = 0 ;
15203 SwigValueWrapper<wxImage > result;
15204 void *argp1 = 0 ;
15205 int res1 = 0 ;
15206 wxRect temp2 ;
15207 PyObject * obj0 = 0 ;
15208 PyObject * obj1 = 0 ;
15209 char * kwnames[] = {
15210 (char *) "self",(char *) "rect", NULL
15211 };
15212
15213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15215 if (!SWIG_IsOK(res1)) {
15216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15217 }
15218 arg1 = reinterpret_cast< wxImage * >(argp1);
15219 {
15220 arg2 = &temp2;
15221 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15222 }
15223 {
15224 PyThreadState* __tstate = wxPyBeginAllowThreads();
15225 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15226 wxPyEndAllowThreads(__tstate);
15227 if (PyErr_Occurred()) SWIG_fail;
15228 }
15229 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15230 return resultobj;
15231 fail:
15232 return NULL;
15233 }
15234
15235
15236 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj = 0;
15238 wxImage *arg1 = (wxImage *) 0 ;
15239 wxSize *arg2 = 0 ;
15240 wxPoint *arg3 = 0 ;
15241 int arg4 = (int) -1 ;
15242 int arg5 = (int) -1 ;
15243 int arg6 = (int) -1 ;
15244 SwigValueWrapper<wxImage > result;
15245 void *argp1 = 0 ;
15246 int res1 = 0 ;
15247 wxSize temp2 ;
15248 wxPoint temp3 ;
15249 int val4 ;
15250 int ecode4 = 0 ;
15251 int val5 ;
15252 int ecode5 = 0 ;
15253 int val6 ;
15254 int ecode6 = 0 ;
15255 PyObject * obj0 = 0 ;
15256 PyObject * obj1 = 0 ;
15257 PyObject * obj2 = 0 ;
15258 PyObject * obj3 = 0 ;
15259 PyObject * obj4 = 0 ;
15260 PyObject * obj5 = 0 ;
15261 char * kwnames[] = {
15262 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15263 };
15264
15265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15267 if (!SWIG_IsOK(res1)) {
15268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15269 }
15270 arg1 = reinterpret_cast< wxImage * >(argp1);
15271 {
15272 arg2 = &temp2;
15273 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15274 }
15275 {
15276 arg3 = &temp3;
15277 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15278 }
15279 if (obj3) {
15280 ecode4 = SWIG_AsVal_int(obj3, &val4);
15281 if (!SWIG_IsOK(ecode4)) {
15282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15283 }
15284 arg4 = static_cast< int >(val4);
15285 }
15286 if (obj4) {
15287 ecode5 = SWIG_AsVal_int(obj4, &val5);
15288 if (!SWIG_IsOK(ecode5)) {
15289 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15290 }
15291 arg5 = static_cast< int >(val5);
15292 }
15293 if (obj5) {
15294 ecode6 = SWIG_AsVal_int(obj5, &val6);
15295 if (!SWIG_IsOK(ecode6)) {
15296 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15297 }
15298 arg6 = static_cast< int >(val6);
15299 }
15300 {
15301 PyThreadState* __tstate = wxPyBeginAllowThreads();
15302 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15307 return resultobj;
15308 fail:
15309 return NULL;
15310 }
15311
15312
15313 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15314 PyObject *resultobj = 0;
15315 wxImage *arg1 = (wxImage *) 0 ;
15316 SwigValueWrapper<wxImage > result;
15317 void *argp1 = 0 ;
15318 int res1 = 0 ;
15319 PyObject *swig_obj[1] ;
15320
15321 if (!args) SWIG_fail;
15322 swig_obj[0] = args;
15323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15324 if (!SWIG_IsOK(res1)) {
15325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15326 }
15327 arg1 = reinterpret_cast< wxImage * >(argp1);
15328 {
15329 PyThreadState* __tstate = wxPyBeginAllowThreads();
15330 result = (arg1)->Copy();
15331 wxPyEndAllowThreads(__tstate);
15332 if (PyErr_Occurred()) SWIG_fail;
15333 }
15334 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15335 return resultobj;
15336 fail:
15337 return NULL;
15338 }
15339
15340
15341 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15342 PyObject *resultobj = 0;
15343 wxImage *arg1 = (wxImage *) 0 ;
15344 wxImage *arg2 = 0 ;
15345 int arg3 ;
15346 int arg4 ;
15347 void *argp1 = 0 ;
15348 int res1 = 0 ;
15349 void *argp2 = 0 ;
15350 int res2 = 0 ;
15351 int val3 ;
15352 int ecode3 = 0 ;
15353 int val4 ;
15354 int ecode4 = 0 ;
15355 PyObject * obj0 = 0 ;
15356 PyObject * obj1 = 0 ;
15357 PyObject * obj2 = 0 ;
15358 PyObject * obj3 = 0 ;
15359 char * kwnames[] = {
15360 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15361 };
15362
15363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15365 if (!SWIG_IsOK(res1)) {
15366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15367 }
15368 arg1 = reinterpret_cast< wxImage * >(argp1);
15369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15370 if (!SWIG_IsOK(res2)) {
15371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15372 }
15373 if (!argp2) {
15374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15375 }
15376 arg2 = reinterpret_cast< wxImage * >(argp2);
15377 ecode3 = SWIG_AsVal_int(obj2, &val3);
15378 if (!SWIG_IsOK(ecode3)) {
15379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15380 }
15381 arg3 = static_cast< int >(val3);
15382 ecode4 = SWIG_AsVal_int(obj3, &val4);
15383 if (!SWIG_IsOK(ecode4)) {
15384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15385 }
15386 arg4 = static_cast< int >(val4);
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15390 wxPyEndAllowThreads(__tstate);
15391 if (PyErr_Occurred()) SWIG_fail;
15392 }
15393 resultobj = SWIG_Py_Void();
15394 return resultobj;
15395 fail:
15396 return NULL;
15397 }
15398
15399
15400 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15401 PyObject *resultobj = 0;
15402 wxImage *arg1 = (wxImage *) 0 ;
15403 PyObject *result = 0 ;
15404 void *argp1 = 0 ;
15405 int res1 = 0 ;
15406 PyObject *swig_obj[1] ;
15407
15408 if (!args) SWIG_fail;
15409 swig_obj[0] = args;
15410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15411 if (!SWIG_IsOK(res1)) {
15412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15413 }
15414 arg1 = reinterpret_cast< wxImage * >(argp1);
15415 {
15416 PyThreadState* __tstate = wxPyBeginAllowThreads();
15417 result = (PyObject *)wxImage_GetData(arg1);
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 resultobj = result;
15422 return resultobj;
15423 fail:
15424 return NULL;
15425 }
15426
15427
15428 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15429 PyObject *resultobj = 0;
15430 wxImage *arg1 = (wxImage *) 0 ;
15431 buffer arg2 ;
15432 int arg3 ;
15433 void *argp1 = 0 ;
15434 int res1 = 0 ;
15435 PyObject * obj0 = 0 ;
15436 PyObject * obj1 = 0 ;
15437 char * kwnames[] = {
15438 (char *) "self",(char *) "data", NULL
15439 };
15440
15441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15443 if (!SWIG_IsOK(res1)) {
15444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15445 }
15446 arg1 = reinterpret_cast< wxImage * >(argp1);
15447 {
15448 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15449 }
15450 {
15451 PyThreadState* __tstate = wxPyBeginAllowThreads();
15452 wxImage_SetData(arg1,arg2,arg3);
15453 wxPyEndAllowThreads(__tstate);
15454 if (PyErr_Occurred()) SWIG_fail;
15455 }
15456 resultobj = SWIG_Py_Void();
15457 return resultobj;
15458 fail:
15459 return NULL;
15460 }
15461
15462
15463 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15464 PyObject *resultobj = 0;
15465 wxImage *arg1 = (wxImage *) 0 ;
15466 PyObject *result = 0 ;
15467 void *argp1 = 0 ;
15468 int res1 = 0 ;
15469 PyObject *swig_obj[1] ;
15470
15471 if (!args) SWIG_fail;
15472 swig_obj[0] = args;
15473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15474 if (!SWIG_IsOK(res1)) {
15475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15476 }
15477 arg1 = reinterpret_cast< wxImage * >(argp1);
15478 {
15479 PyThreadState* __tstate = wxPyBeginAllowThreads();
15480 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15481 wxPyEndAllowThreads(__tstate);
15482 if (PyErr_Occurred()) SWIG_fail;
15483 }
15484 resultobj = result;
15485 return resultobj;
15486 fail:
15487 return NULL;
15488 }
15489
15490
15491 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15492 PyObject *resultobj = 0;
15493 wxImage *arg1 = (wxImage *) 0 ;
15494 buffer arg2 ;
15495 int arg3 ;
15496 void *argp1 = 0 ;
15497 int res1 = 0 ;
15498 PyObject * obj0 = 0 ;
15499 PyObject * obj1 = 0 ;
15500 char * kwnames[] = {
15501 (char *) "self",(char *) "data", NULL
15502 };
15503
15504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15506 if (!SWIG_IsOK(res1)) {
15507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15508 }
15509 arg1 = reinterpret_cast< wxImage * >(argp1);
15510 {
15511 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15512 }
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 wxImage_SetDataBuffer(arg1,arg2,arg3);
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 resultobj = SWIG_Py_Void();
15520 return resultobj;
15521 fail:
15522 return NULL;
15523 }
15524
15525
15526 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15527 PyObject *resultobj = 0;
15528 wxImage *arg1 = (wxImage *) 0 ;
15529 PyObject *result = 0 ;
15530 void *argp1 = 0 ;
15531 int res1 = 0 ;
15532 PyObject *swig_obj[1] ;
15533
15534 if (!args) SWIG_fail;
15535 swig_obj[0] = args;
15536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15537 if (!SWIG_IsOK(res1)) {
15538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15539 }
15540 arg1 = reinterpret_cast< wxImage * >(argp1);
15541 {
15542 PyThreadState* __tstate = wxPyBeginAllowThreads();
15543 result = (PyObject *)wxImage_GetAlphaData(arg1);
15544 wxPyEndAllowThreads(__tstate);
15545 if (PyErr_Occurred()) SWIG_fail;
15546 }
15547 resultobj = result;
15548 return resultobj;
15549 fail:
15550 return NULL;
15551 }
15552
15553
15554 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15555 PyObject *resultobj = 0;
15556 wxImage *arg1 = (wxImage *) 0 ;
15557 buffer arg2 ;
15558 int arg3 ;
15559 void *argp1 = 0 ;
15560 int res1 = 0 ;
15561 PyObject * obj0 = 0 ;
15562 PyObject * obj1 = 0 ;
15563 char * kwnames[] = {
15564 (char *) "self",(char *) "alpha", NULL
15565 };
15566
15567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15569 if (!SWIG_IsOK(res1)) {
15570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15571 }
15572 arg1 = reinterpret_cast< wxImage * >(argp1);
15573 {
15574 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15575 }
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 wxImage_SetAlphaData(arg1,arg2,arg3);
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 resultobj = SWIG_Py_Void();
15583 return resultobj;
15584 fail:
15585 return NULL;
15586 }
15587
15588
15589 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15590 PyObject *resultobj = 0;
15591 wxImage *arg1 = (wxImage *) 0 ;
15592 PyObject *result = 0 ;
15593 void *argp1 = 0 ;
15594 int res1 = 0 ;
15595 PyObject *swig_obj[1] ;
15596
15597 if (!args) SWIG_fail;
15598 swig_obj[0] = args;
15599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15600 if (!SWIG_IsOK(res1)) {
15601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15602 }
15603 arg1 = reinterpret_cast< wxImage * >(argp1);
15604 {
15605 PyThreadState* __tstate = wxPyBeginAllowThreads();
15606 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15607 wxPyEndAllowThreads(__tstate);
15608 if (PyErr_Occurred()) SWIG_fail;
15609 }
15610 resultobj = result;
15611 return resultobj;
15612 fail:
15613 return NULL;
15614 }
15615
15616
15617 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15618 PyObject *resultobj = 0;
15619 wxImage *arg1 = (wxImage *) 0 ;
15620 buffer arg2 ;
15621 int arg3 ;
15622 void *argp1 = 0 ;
15623 int res1 = 0 ;
15624 PyObject * obj0 = 0 ;
15625 PyObject * obj1 = 0 ;
15626 char * kwnames[] = {
15627 (char *) "self",(char *) "alpha", NULL
15628 };
15629
15630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15632 if (!SWIG_IsOK(res1)) {
15633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15634 }
15635 arg1 = reinterpret_cast< wxImage * >(argp1);
15636 {
15637 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15638 }
15639 {
15640 PyThreadState* __tstate = wxPyBeginAllowThreads();
15641 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15642 wxPyEndAllowThreads(__tstate);
15643 if (PyErr_Occurred()) SWIG_fail;
15644 }
15645 resultobj = SWIG_Py_Void();
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15653 PyObject *resultobj = 0;
15654 wxImage *arg1 = (wxImage *) 0 ;
15655 byte arg2 ;
15656 byte arg3 ;
15657 byte arg4 ;
15658 void *argp1 = 0 ;
15659 int res1 = 0 ;
15660 unsigned char val2 ;
15661 int ecode2 = 0 ;
15662 unsigned char val3 ;
15663 int ecode3 = 0 ;
15664 unsigned char val4 ;
15665 int ecode4 = 0 ;
15666 PyObject * obj0 = 0 ;
15667 PyObject * obj1 = 0 ;
15668 PyObject * obj2 = 0 ;
15669 PyObject * obj3 = 0 ;
15670 char * kwnames[] = {
15671 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15672 };
15673
15674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15676 if (!SWIG_IsOK(res1)) {
15677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15678 }
15679 arg1 = reinterpret_cast< wxImage * >(argp1);
15680 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15681 if (!SWIG_IsOK(ecode2)) {
15682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15683 }
15684 arg2 = static_cast< byte >(val2);
15685 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15686 if (!SWIG_IsOK(ecode3)) {
15687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15688 }
15689 arg3 = static_cast< byte >(val3);
15690 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15691 if (!SWIG_IsOK(ecode4)) {
15692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15693 }
15694 arg4 = static_cast< byte >(val4);
15695 {
15696 PyThreadState* __tstate = wxPyBeginAllowThreads();
15697 (arg1)->SetMaskColour(arg2,arg3,arg4);
15698 wxPyEndAllowThreads(__tstate);
15699 if (PyErr_Occurred()) SWIG_fail;
15700 }
15701 resultobj = SWIG_Py_Void();
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15709 PyObject *resultobj = 0;
15710 wxImage *arg1 = (wxImage *) 0 ;
15711 byte *arg2 = (byte *) 0 ;
15712 byte *arg3 = (byte *) 0 ;
15713 byte *arg4 = (byte *) 0 ;
15714 void *argp1 = 0 ;
15715 int res1 = 0 ;
15716 byte temp2 ;
15717 int res2 = SWIG_TMPOBJ ;
15718 byte temp3 ;
15719 int res3 = SWIG_TMPOBJ ;
15720 byte temp4 ;
15721 int res4 = SWIG_TMPOBJ ;
15722 PyObject *swig_obj[1] ;
15723
15724 arg2 = &temp2;
15725 arg3 = &temp3;
15726 arg4 = &temp4;
15727 if (!args) SWIG_fail;
15728 swig_obj[0] = args;
15729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15730 if (!SWIG_IsOK(res1)) {
15731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15732 }
15733 arg1 = reinterpret_cast< wxImage * >(argp1);
15734 {
15735 PyThreadState* __tstate = wxPyBeginAllowThreads();
15736 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15737 wxPyEndAllowThreads(__tstate);
15738 if (PyErr_Occurred()) SWIG_fail;
15739 }
15740 resultobj = SWIG_Py_Void();
15741 if (SWIG_IsTmpObj(res2)) {
15742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15743 } else {
15744 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15746 }
15747 if (SWIG_IsTmpObj(res3)) {
15748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15749 } else {
15750 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15752 }
15753 if (SWIG_IsTmpObj(res4)) {
15754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15755 } else {
15756 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15758 }
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxImage *arg1 = (wxImage *) 0 ;
15768 byte result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15778 }
15779 arg1 = reinterpret_cast< wxImage * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = (byte)(arg1)->GetMaskRed();
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15794 PyObject *resultobj = 0;
15795 wxImage *arg1 = (wxImage *) 0 ;
15796 byte result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 PyObject *swig_obj[1] ;
15800
15801 if (!args) SWIG_fail;
15802 swig_obj[0] = args;
15803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15804 if (!SWIG_IsOK(res1)) {
15805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15806 }
15807 arg1 = reinterpret_cast< wxImage * >(argp1);
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (byte)(arg1)->GetMaskGreen();
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxImage *arg1 = (wxImage *) 0 ;
15824 byte result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15834 }
15835 arg1 = reinterpret_cast< wxImage * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (byte)(arg1)->GetMaskBlue();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15850 PyObject *resultobj = 0;
15851 wxImage *arg1 = (wxImage *) 0 ;
15852 bool arg2 = (bool) true ;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 bool val2 ;
15856 int ecode2 = 0 ;
15857 PyObject * obj0 = 0 ;
15858 PyObject * obj1 = 0 ;
15859 char * kwnames[] = {
15860 (char *) "self",(char *) "mask", NULL
15861 };
15862
15863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15865 if (!SWIG_IsOK(res1)) {
15866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15867 }
15868 arg1 = reinterpret_cast< wxImage * >(argp1);
15869 if (obj1) {
15870 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15871 if (!SWIG_IsOK(ecode2)) {
15872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15873 }
15874 arg2 = static_cast< bool >(val2);
15875 }
15876 {
15877 PyThreadState* __tstate = wxPyBeginAllowThreads();
15878 (arg1)->SetMask(arg2);
15879 wxPyEndAllowThreads(__tstate);
15880 if (PyErr_Occurred()) SWIG_fail;
15881 }
15882 resultobj = SWIG_Py_Void();
15883 return resultobj;
15884 fail:
15885 return NULL;
15886 }
15887
15888
15889 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15890 PyObject *resultobj = 0;
15891 wxImage *arg1 = (wxImage *) 0 ;
15892 bool result;
15893 void *argp1 = 0 ;
15894 int res1 = 0 ;
15895 PyObject *swig_obj[1] ;
15896
15897 if (!args) SWIG_fail;
15898 swig_obj[0] = args;
15899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15900 if (!SWIG_IsOK(res1)) {
15901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15902 }
15903 arg1 = reinterpret_cast< wxImage * >(argp1);
15904 {
15905 PyThreadState* __tstate = wxPyBeginAllowThreads();
15906 result = (bool)(arg1)->HasMask();
15907 wxPyEndAllowThreads(__tstate);
15908 if (PyErr_Occurred()) SWIG_fail;
15909 }
15910 {
15911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15912 }
15913 return resultobj;
15914 fail:
15915 return NULL;
15916 }
15917
15918
15919 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15920 PyObject *resultobj = 0;
15921 wxImage *arg1 = (wxImage *) 0 ;
15922 double arg2 ;
15923 wxPoint *arg3 = 0 ;
15924 bool arg4 = (bool) true ;
15925 wxPoint *arg5 = (wxPoint *) NULL ;
15926 SwigValueWrapper<wxImage > result;
15927 void *argp1 = 0 ;
15928 int res1 = 0 ;
15929 double val2 ;
15930 int ecode2 = 0 ;
15931 wxPoint temp3 ;
15932 bool val4 ;
15933 int ecode4 = 0 ;
15934 void *argp5 = 0 ;
15935 int res5 = 0 ;
15936 PyObject * obj0 = 0 ;
15937 PyObject * obj1 = 0 ;
15938 PyObject * obj2 = 0 ;
15939 PyObject * obj3 = 0 ;
15940 PyObject * obj4 = 0 ;
15941 char * kwnames[] = {
15942 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15943 };
15944
15945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15947 if (!SWIG_IsOK(res1)) {
15948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15949 }
15950 arg1 = reinterpret_cast< wxImage * >(argp1);
15951 ecode2 = SWIG_AsVal_double(obj1, &val2);
15952 if (!SWIG_IsOK(ecode2)) {
15953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15954 }
15955 arg2 = static_cast< double >(val2);
15956 {
15957 arg3 = &temp3;
15958 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15959 }
15960 if (obj3) {
15961 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15962 if (!SWIG_IsOK(ecode4)) {
15963 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15964 }
15965 arg4 = static_cast< bool >(val4);
15966 }
15967 if (obj4) {
15968 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15969 if (!SWIG_IsOK(res5)) {
15970 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15971 }
15972 arg5 = reinterpret_cast< wxPoint * >(argp5);
15973 }
15974 {
15975 PyThreadState* __tstate = wxPyBeginAllowThreads();
15976 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15977 wxPyEndAllowThreads(__tstate);
15978 if (PyErr_Occurred()) SWIG_fail;
15979 }
15980 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15981 return resultobj;
15982 fail:
15983 return NULL;
15984 }
15985
15986
15987 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15988 PyObject *resultobj = 0;
15989 wxImage *arg1 = (wxImage *) 0 ;
15990 bool arg2 = (bool) true ;
15991 SwigValueWrapper<wxImage > result;
15992 void *argp1 = 0 ;
15993 int res1 = 0 ;
15994 bool val2 ;
15995 int ecode2 = 0 ;
15996 PyObject * obj0 = 0 ;
15997 PyObject * obj1 = 0 ;
15998 char * kwnames[] = {
15999 (char *) "self",(char *) "clockwise", NULL
16000 };
16001
16002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16004 if (!SWIG_IsOK(res1)) {
16005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16006 }
16007 arg1 = reinterpret_cast< wxImage * >(argp1);
16008 if (obj1) {
16009 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16010 if (!SWIG_IsOK(ecode2)) {
16011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16012 }
16013 arg2 = static_cast< bool >(val2);
16014 }
16015 {
16016 PyThreadState* __tstate = wxPyBeginAllowThreads();
16017 result = (arg1)->Rotate90(arg2);
16018 wxPyEndAllowThreads(__tstate);
16019 if (PyErr_Occurred()) SWIG_fail;
16020 }
16021 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16022 return resultobj;
16023 fail:
16024 return NULL;
16025 }
16026
16027
16028 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16029 PyObject *resultobj = 0;
16030 wxImage *arg1 = (wxImage *) 0 ;
16031 bool arg2 = (bool) true ;
16032 SwigValueWrapper<wxImage > result;
16033 void *argp1 = 0 ;
16034 int res1 = 0 ;
16035 bool val2 ;
16036 int ecode2 = 0 ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 char * kwnames[] = {
16040 (char *) "self",(char *) "horizontally", NULL
16041 };
16042
16043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16045 if (!SWIG_IsOK(res1)) {
16046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16047 }
16048 arg1 = reinterpret_cast< wxImage * >(argp1);
16049 if (obj1) {
16050 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16051 if (!SWIG_IsOK(ecode2)) {
16052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16053 }
16054 arg2 = static_cast< bool >(val2);
16055 }
16056 {
16057 PyThreadState* __tstate = wxPyBeginAllowThreads();
16058 result = (arg1)->Mirror(arg2);
16059 wxPyEndAllowThreads(__tstate);
16060 if (PyErr_Occurred()) SWIG_fail;
16061 }
16062 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16063 return resultobj;
16064 fail:
16065 return NULL;
16066 }
16067
16068
16069 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16070 PyObject *resultobj = 0;
16071 wxImage *arg1 = (wxImage *) 0 ;
16072 byte arg2 ;
16073 byte arg3 ;
16074 byte arg4 ;
16075 byte arg5 ;
16076 byte arg6 ;
16077 byte arg7 ;
16078 void *argp1 = 0 ;
16079 int res1 = 0 ;
16080 unsigned char val2 ;
16081 int ecode2 = 0 ;
16082 unsigned char val3 ;
16083 int ecode3 = 0 ;
16084 unsigned char val4 ;
16085 int ecode4 = 0 ;
16086 unsigned char val5 ;
16087 int ecode5 = 0 ;
16088 unsigned char val6 ;
16089 int ecode6 = 0 ;
16090 unsigned char val7 ;
16091 int ecode7 = 0 ;
16092 PyObject * obj0 = 0 ;
16093 PyObject * obj1 = 0 ;
16094 PyObject * obj2 = 0 ;
16095 PyObject * obj3 = 0 ;
16096 PyObject * obj4 = 0 ;
16097 PyObject * obj5 = 0 ;
16098 PyObject * obj6 = 0 ;
16099 char * kwnames[] = {
16100 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16101 };
16102
16103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16105 if (!SWIG_IsOK(res1)) {
16106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16107 }
16108 arg1 = reinterpret_cast< wxImage * >(argp1);
16109 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16110 if (!SWIG_IsOK(ecode2)) {
16111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16112 }
16113 arg2 = static_cast< byte >(val2);
16114 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16115 if (!SWIG_IsOK(ecode3)) {
16116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16117 }
16118 arg3 = static_cast< byte >(val3);
16119 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16120 if (!SWIG_IsOK(ecode4)) {
16121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16122 }
16123 arg4 = static_cast< byte >(val4);
16124 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16125 if (!SWIG_IsOK(ecode5)) {
16126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16127 }
16128 arg5 = static_cast< byte >(val5);
16129 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16130 if (!SWIG_IsOK(ecode6)) {
16131 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16132 }
16133 arg6 = static_cast< byte >(val6);
16134 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16135 if (!SWIG_IsOK(ecode7)) {
16136 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16137 }
16138 arg7 = static_cast< byte >(val7);
16139 {
16140 PyThreadState* __tstate = wxPyBeginAllowThreads();
16141 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 resultobj = SWIG_Py_Void();
16146 return resultobj;
16147 fail:
16148 return NULL;
16149 }
16150
16151
16152 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16153 PyObject *resultobj = 0;
16154 wxImage *arg1 = (wxImage *) 0 ;
16155 double arg2 = (double) 0.299 ;
16156 double arg3 = (double) 0.587 ;
16157 double arg4 = (double) 0.114 ;
16158 SwigValueWrapper<wxImage > result;
16159 void *argp1 = 0 ;
16160 int res1 = 0 ;
16161 double val2 ;
16162 int ecode2 = 0 ;
16163 double val3 ;
16164 int ecode3 = 0 ;
16165 double val4 ;
16166 int ecode4 = 0 ;
16167 PyObject * obj0 = 0 ;
16168 PyObject * obj1 = 0 ;
16169 PyObject * obj2 = 0 ;
16170 PyObject * obj3 = 0 ;
16171 char * kwnames[] = {
16172 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16173 };
16174
16175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16177 if (!SWIG_IsOK(res1)) {
16178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16179 }
16180 arg1 = reinterpret_cast< wxImage * >(argp1);
16181 if (obj1) {
16182 ecode2 = SWIG_AsVal_double(obj1, &val2);
16183 if (!SWIG_IsOK(ecode2)) {
16184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16185 }
16186 arg2 = static_cast< double >(val2);
16187 }
16188 if (obj2) {
16189 ecode3 = SWIG_AsVal_double(obj2, &val3);
16190 if (!SWIG_IsOK(ecode3)) {
16191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16192 }
16193 arg3 = static_cast< double >(val3);
16194 }
16195 if (obj3) {
16196 ecode4 = SWIG_AsVal_double(obj3, &val4);
16197 if (!SWIG_IsOK(ecode4)) {
16198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16199 }
16200 arg4 = static_cast< double >(val4);
16201 }
16202 {
16203 PyThreadState* __tstate = wxPyBeginAllowThreads();
16204 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16216 PyObject *resultobj = 0;
16217 wxImage *arg1 = (wxImage *) 0 ;
16218 byte arg2 ;
16219 byte arg3 ;
16220 byte arg4 ;
16221 SwigValueWrapper<wxImage > result;
16222 void *argp1 = 0 ;
16223 int res1 = 0 ;
16224 unsigned char val2 ;
16225 int ecode2 = 0 ;
16226 unsigned char val3 ;
16227 int ecode3 = 0 ;
16228 unsigned char val4 ;
16229 int ecode4 = 0 ;
16230 PyObject * obj0 = 0 ;
16231 PyObject * obj1 = 0 ;
16232 PyObject * obj2 = 0 ;
16233 PyObject * obj3 = 0 ;
16234 char * kwnames[] = {
16235 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16236 };
16237
16238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16240 if (!SWIG_IsOK(res1)) {
16241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16242 }
16243 arg1 = reinterpret_cast< wxImage * >(argp1);
16244 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16245 if (!SWIG_IsOK(ecode2)) {
16246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16247 }
16248 arg2 = static_cast< byte >(val2);
16249 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16250 if (!SWIG_IsOK(ecode3)) {
16251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16252 }
16253 arg3 = static_cast< byte >(val3);
16254 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16255 if (!SWIG_IsOK(ecode4)) {
16256 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16257 }
16258 arg4 = static_cast< byte >(val4);
16259 {
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16273 PyObject *resultobj = 0;
16274 wxImage *arg1 = (wxImage *) 0 ;
16275 wxString *arg2 = 0 ;
16276 wxString *arg3 = 0 ;
16277 void *argp1 = 0 ;
16278 int res1 = 0 ;
16279 bool temp2 = false ;
16280 bool temp3 = false ;
16281 PyObject * obj0 = 0 ;
16282 PyObject * obj1 = 0 ;
16283 PyObject * obj2 = 0 ;
16284 char * kwnames[] = {
16285 (char *) "self",(char *) "name",(char *) "value", NULL
16286 };
16287
16288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16290 if (!SWIG_IsOK(res1)) {
16291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16292 }
16293 arg1 = reinterpret_cast< wxImage * >(argp1);
16294 {
16295 arg2 = wxString_in_helper(obj1);
16296 if (arg2 == NULL) SWIG_fail;
16297 temp2 = true;
16298 }
16299 {
16300 arg3 = wxString_in_helper(obj2);
16301 if (arg3 == NULL) SWIG_fail;
16302 temp3 = true;
16303 }
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 resultobj = SWIG_Py_Void();
16311 {
16312 if (temp2)
16313 delete arg2;
16314 }
16315 {
16316 if (temp3)
16317 delete arg3;
16318 }
16319 return resultobj;
16320 fail:
16321 {
16322 if (temp2)
16323 delete arg2;
16324 }
16325 {
16326 if (temp3)
16327 delete arg3;
16328 }
16329 return NULL;
16330 }
16331
16332
16333 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16334 PyObject *resultobj = 0;
16335 wxImage *arg1 = (wxImage *) 0 ;
16336 wxString *arg2 = 0 ;
16337 int arg3 ;
16338 void *argp1 = 0 ;
16339 int res1 = 0 ;
16340 bool temp2 = false ;
16341 int val3 ;
16342 int ecode3 = 0 ;
16343 PyObject * obj0 = 0 ;
16344 PyObject * obj1 = 0 ;
16345 PyObject * obj2 = 0 ;
16346 char * kwnames[] = {
16347 (char *) "self",(char *) "name",(char *) "value", NULL
16348 };
16349
16350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16352 if (!SWIG_IsOK(res1)) {
16353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16354 }
16355 arg1 = reinterpret_cast< wxImage * >(argp1);
16356 {
16357 arg2 = wxString_in_helper(obj1);
16358 if (arg2 == NULL) SWIG_fail;
16359 temp2 = true;
16360 }
16361 ecode3 = SWIG_AsVal_int(obj2, &val3);
16362 if (!SWIG_IsOK(ecode3)) {
16363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16364 }
16365 arg3 = static_cast< int >(val3);
16366 {
16367 PyThreadState* __tstate = wxPyBeginAllowThreads();
16368 (arg1)->SetOption((wxString const &)*arg2,arg3);
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 resultobj = SWIG_Py_Void();
16373 {
16374 if (temp2)
16375 delete arg2;
16376 }
16377 return resultobj;
16378 fail:
16379 {
16380 if (temp2)
16381 delete arg2;
16382 }
16383 return NULL;
16384 }
16385
16386
16387 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16388 PyObject *resultobj = 0;
16389 wxImage *arg1 = (wxImage *) 0 ;
16390 wxString *arg2 = 0 ;
16391 wxString result;
16392 void *argp1 = 0 ;
16393 int res1 = 0 ;
16394 bool temp2 = false ;
16395 PyObject * obj0 = 0 ;
16396 PyObject * obj1 = 0 ;
16397 char * kwnames[] = {
16398 (char *) "self",(char *) "name", NULL
16399 };
16400
16401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16403 if (!SWIG_IsOK(res1)) {
16404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16405 }
16406 arg1 = reinterpret_cast< wxImage * >(argp1);
16407 {
16408 arg2 = wxString_in_helper(obj1);
16409 if (arg2 == NULL) SWIG_fail;
16410 temp2 = true;
16411 }
16412 {
16413 PyThreadState* __tstate = wxPyBeginAllowThreads();
16414 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16415 wxPyEndAllowThreads(__tstate);
16416 if (PyErr_Occurred()) SWIG_fail;
16417 }
16418 {
16419 #if wxUSE_UNICODE
16420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16421 #else
16422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16423 #endif
16424 }
16425 {
16426 if (temp2)
16427 delete arg2;
16428 }
16429 return resultobj;
16430 fail:
16431 {
16432 if (temp2)
16433 delete arg2;
16434 }
16435 return NULL;
16436 }
16437
16438
16439 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16440 PyObject *resultobj = 0;
16441 wxImage *arg1 = (wxImage *) 0 ;
16442 wxString *arg2 = 0 ;
16443 int result;
16444 void *argp1 = 0 ;
16445 int res1 = 0 ;
16446 bool temp2 = false ;
16447 PyObject * obj0 = 0 ;
16448 PyObject * obj1 = 0 ;
16449 char * kwnames[] = {
16450 (char *) "self",(char *) "name", NULL
16451 };
16452
16453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16455 if (!SWIG_IsOK(res1)) {
16456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16457 }
16458 arg1 = reinterpret_cast< wxImage * >(argp1);
16459 {
16460 arg2 = wxString_in_helper(obj1);
16461 if (arg2 == NULL) SWIG_fail;
16462 temp2 = true;
16463 }
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 resultobj = SWIG_From_int(static_cast< int >(result));
16471 {
16472 if (temp2)
16473 delete arg2;
16474 }
16475 return resultobj;
16476 fail:
16477 {
16478 if (temp2)
16479 delete arg2;
16480 }
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16486 PyObject *resultobj = 0;
16487 wxImage *arg1 = (wxImage *) 0 ;
16488 wxString *arg2 = 0 ;
16489 bool result;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 bool temp2 = false ;
16493 PyObject * obj0 = 0 ;
16494 PyObject * obj1 = 0 ;
16495 char * kwnames[] = {
16496 (char *) "self",(char *) "name", NULL
16497 };
16498
16499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16501 if (!SWIG_IsOK(res1)) {
16502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16503 }
16504 arg1 = reinterpret_cast< wxImage * >(argp1);
16505 {
16506 arg2 = wxString_in_helper(obj1);
16507 if (arg2 == NULL) SWIG_fail;
16508 temp2 = true;
16509 }
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 {
16517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16518 }
16519 {
16520 if (temp2)
16521 delete arg2;
16522 }
16523 return resultobj;
16524 fail:
16525 {
16526 if (temp2)
16527 delete arg2;
16528 }
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxImage *arg1 = (wxImage *) 0 ;
16536 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16537 unsigned long result;
16538 void *argp1 = 0 ;
16539 int res1 = 0 ;
16540 unsigned long val2 ;
16541 int ecode2 = 0 ;
16542 PyObject * obj0 = 0 ;
16543 PyObject * obj1 = 0 ;
16544 char * kwnames[] = {
16545 (char *) "self",(char *) "stopafter", NULL
16546 };
16547
16548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16550 if (!SWIG_IsOK(res1)) {
16551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16552 }
16553 arg1 = reinterpret_cast< wxImage * >(argp1);
16554 if (obj1) {
16555 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16556 if (!SWIG_IsOK(ecode2)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16558 }
16559 arg2 = static_cast< unsigned long >(val2);
16560 }
16561 {
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 result = (unsigned long)(arg1)->CountColours(arg2);
16564 wxPyEndAllowThreads(__tstate);
16565 if (PyErr_Occurred()) SWIG_fail;
16566 }
16567 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16568 return resultobj;
16569 fail:
16570 return NULL;
16571 }
16572
16573
16574 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj = 0;
16576 wxImage *arg1 = (wxImage *) 0 ;
16577 wxImageHistogram *arg2 = 0 ;
16578 unsigned long result;
16579 void *argp1 = 0 ;
16580 int res1 = 0 ;
16581 void *argp2 = 0 ;
16582 int res2 = 0 ;
16583 PyObject * obj0 = 0 ;
16584 PyObject * obj1 = 0 ;
16585 char * kwnames[] = {
16586 (char *) "self",(char *) "h", NULL
16587 };
16588
16589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16591 if (!SWIG_IsOK(res1)) {
16592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16593 }
16594 arg1 = reinterpret_cast< wxImage * >(argp1);
16595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16596 if (!SWIG_IsOK(res2)) {
16597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16598 }
16599 if (!argp2) {
16600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16601 }
16602 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16603 {
16604 PyThreadState* __tstate = wxPyBeginAllowThreads();
16605 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16606 wxPyEndAllowThreads(__tstate);
16607 if (PyErr_Occurred()) SWIG_fail;
16608 }
16609 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16617 PyObject *resultobj = 0;
16618 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16619 void *argp1 = 0 ;
16620 int res1 = 0 ;
16621 PyObject * obj0 = 0 ;
16622 char * kwnames[] = {
16623 (char *) "handler", NULL
16624 };
16625
16626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16628 if (!SWIG_IsOK(res1)) {
16629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16630 }
16631 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16632 {
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 wxImage::AddHandler(arg1);
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 resultobj = SWIG_Py_Void();
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj = 0;
16647 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16648 void *argp1 = 0 ;
16649 int res1 = 0 ;
16650 PyObject * obj0 = 0 ;
16651 char * kwnames[] = {
16652 (char *) "handler", NULL
16653 };
16654
16655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16657 if (!SWIG_IsOK(res1)) {
16658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16659 }
16660 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16661 {
16662 PyThreadState* __tstate = wxPyBeginAllowThreads();
16663 wxImage::InsertHandler(arg1);
16664 wxPyEndAllowThreads(__tstate);
16665 if (PyErr_Occurred()) SWIG_fail;
16666 }
16667 resultobj = SWIG_Py_Void();
16668 return resultobj;
16669 fail:
16670 return NULL;
16671 }
16672
16673
16674 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16675 PyObject *resultobj = 0;
16676 wxString *arg1 = 0 ;
16677 bool result;
16678 bool temp1 = false ;
16679 PyObject * obj0 = 0 ;
16680 char * kwnames[] = {
16681 (char *) "name", NULL
16682 };
16683
16684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16685 {
16686 arg1 = wxString_in_helper(obj0);
16687 if (arg1 == NULL) SWIG_fail;
16688 temp1 = true;
16689 }
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16693 wxPyEndAllowThreads(__tstate);
16694 if (PyErr_Occurred()) SWIG_fail;
16695 }
16696 {
16697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16698 }
16699 {
16700 if (temp1)
16701 delete arg1;
16702 }
16703 return resultobj;
16704 fail:
16705 {
16706 if (temp1)
16707 delete arg1;
16708 }
16709 return NULL;
16710 }
16711
16712
16713 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16714 PyObject *resultobj = 0;
16715 PyObject *result = 0 ;
16716
16717 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = (PyObject *)wxImage_GetHandlers();
16721 wxPyEndAllowThreads(__tstate);
16722 if (PyErr_Occurred()) SWIG_fail;
16723 }
16724 resultobj = result;
16725 return resultobj;
16726 fail:
16727 return NULL;
16728 }
16729
16730
16731 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16732 PyObject *resultobj = 0;
16733 wxString result;
16734
16735 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = wxImage::GetImageExtWildcard();
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 {
16743 #if wxUSE_UNICODE
16744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16745 #else
16746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16747 #endif
16748 }
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj = 0;
16757 wxImage *arg1 = (wxImage *) 0 ;
16758 int arg2 = (int) -1 ;
16759 wxBitmap result;
16760 void *argp1 = 0 ;
16761 int res1 = 0 ;
16762 int val2 ;
16763 int ecode2 = 0 ;
16764 PyObject * obj0 = 0 ;
16765 PyObject * obj1 = 0 ;
16766 char * kwnames[] = {
16767 (char *) "self",(char *) "depth", NULL
16768 };
16769
16770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16772 if (!SWIG_IsOK(res1)) {
16773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16774 }
16775 arg1 = reinterpret_cast< wxImage * >(argp1);
16776 if (obj1) {
16777 ecode2 = SWIG_AsVal_int(obj1, &val2);
16778 if (!SWIG_IsOK(ecode2)) {
16779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16780 }
16781 arg2 = static_cast< int >(val2);
16782 }
16783 {
16784 if (!wxPyCheckForApp()) SWIG_fail;
16785 PyThreadState* __tstate = wxPyBeginAllowThreads();
16786 result = wxImage_ConvertToBitmap(arg1,arg2);
16787 wxPyEndAllowThreads(__tstate);
16788 if (PyErr_Occurred()) SWIG_fail;
16789 }
16790 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16791 return resultobj;
16792 fail:
16793 return NULL;
16794 }
16795
16796
16797 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16798 PyObject *resultobj = 0;
16799 wxImage *arg1 = (wxImage *) 0 ;
16800 byte arg2 ;
16801 byte arg3 ;
16802 byte arg4 ;
16803 wxBitmap result;
16804 void *argp1 = 0 ;
16805 int res1 = 0 ;
16806 unsigned char val2 ;
16807 int ecode2 = 0 ;
16808 unsigned char val3 ;
16809 int ecode3 = 0 ;
16810 unsigned char val4 ;
16811 int ecode4 = 0 ;
16812 PyObject * obj0 = 0 ;
16813 PyObject * obj1 = 0 ;
16814 PyObject * obj2 = 0 ;
16815 PyObject * obj3 = 0 ;
16816 char * kwnames[] = {
16817 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16818 };
16819
16820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16822 if (!SWIG_IsOK(res1)) {
16823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16824 }
16825 arg1 = reinterpret_cast< wxImage * >(argp1);
16826 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16827 if (!SWIG_IsOK(ecode2)) {
16828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16829 }
16830 arg2 = static_cast< byte >(val2);
16831 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16832 if (!SWIG_IsOK(ecode3)) {
16833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16834 }
16835 arg3 = static_cast< byte >(val3);
16836 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16837 if (!SWIG_IsOK(ecode4)) {
16838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16839 }
16840 arg4 = static_cast< byte >(val4);
16841 {
16842 if (!wxPyCheckForApp()) SWIG_fail;
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16856 PyObject *resultobj = 0;
16857 wxImage *arg1 = (wxImage *) 0 ;
16858 double arg2 ;
16859 void *argp1 = 0 ;
16860 int res1 = 0 ;
16861 double val2 ;
16862 int ecode2 = 0 ;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 char * kwnames[] = {
16866 (char *) "self",(char *) "angle", NULL
16867 };
16868
16869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16871 if (!SWIG_IsOK(res1)) {
16872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16873 }
16874 arg1 = reinterpret_cast< wxImage * >(argp1);
16875 ecode2 = SWIG_AsVal_double(obj1, &val2);
16876 if (!SWIG_IsOK(ecode2)) {
16877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16878 }
16879 arg2 = static_cast< double >(val2);
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 (arg1)->RotateHue(arg2);
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 resultobj = SWIG_Py_Void();
16887 return resultobj;
16888 fail:
16889 return NULL;
16890 }
16891
16892
16893 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16894 PyObject *resultobj = 0;
16895 wxImage_RGBValue arg1 ;
16896 wxImage_HSVValue result;
16897 void *argp1 ;
16898 int res1 = 0 ;
16899 PyObject * obj0 = 0 ;
16900 char * kwnames[] = {
16901 (char *) "rgb", NULL
16902 };
16903
16904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16905 {
16906 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16907 if (!SWIG_IsOK(res1)) {
16908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16909 }
16910 if (!argp1) {
16911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16912 } else {
16913 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16914 arg1 = *temp;
16915 if (SWIG_IsNewObj(res1)) delete temp;
16916 }
16917 }
16918 {
16919 PyThreadState* __tstate = wxPyBeginAllowThreads();
16920 result = wxImage::RGBtoHSV(arg1);
16921 wxPyEndAllowThreads(__tstate);
16922 if (PyErr_Occurred()) SWIG_fail;
16923 }
16924 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16925 return resultobj;
16926 fail:
16927 return NULL;
16928 }
16929
16930
16931 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16932 PyObject *resultobj = 0;
16933 wxImage_HSVValue arg1 ;
16934 wxImage_RGBValue result;
16935 void *argp1 ;
16936 int res1 = 0 ;
16937 PyObject * obj0 = 0 ;
16938 char * kwnames[] = {
16939 (char *) "hsv", NULL
16940 };
16941
16942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16943 {
16944 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16945 if (!SWIG_IsOK(res1)) {
16946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16947 }
16948 if (!argp1) {
16949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16950 } else {
16951 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16952 arg1 = *temp;
16953 if (SWIG_IsNewObj(res1)) delete temp;
16954 }
16955 }
16956 {
16957 PyThreadState* __tstate = wxPyBeginAllowThreads();
16958 result = wxImage::HSVtoRGB(arg1);
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16970 PyObject *obj;
16971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16972 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16973 return SWIG_Py_Void();
16974 }
16975
16976 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16977 return SWIG_Python_InitShadowInstance(args);
16978 }
16979
16980 SWIGINTERN int NullImage_set(PyObject *) {
16981 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16982 return 1;
16983 }
16984
16985
16986 SWIGINTERN PyObject *NullImage_get(void) {
16987 PyObject *pyobj = 0;
16988
16989 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16990 return pyobj;
16991 }
16992
16993
16994 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16995 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16996 return 1;
16997 }
16998
16999
17000 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17001 PyObject *pyobj = 0;
17002
17003 {
17004 #if wxUSE_UNICODE
17005 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17006 #else
17007 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17008 #endif
17009 }
17010 return pyobj;
17011 }
17012
17013
17014 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17015 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17016 return 1;
17017 }
17018
17019
17020 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17021 PyObject *pyobj = 0;
17022
17023 {
17024 #if wxUSE_UNICODE
17025 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17026 #else
17027 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17028 #endif
17029 }
17030 return pyobj;
17031 }
17032
17033
17034 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17035 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17036 return 1;
17037 }
17038
17039
17040 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17041 PyObject *pyobj = 0;
17042
17043 {
17044 #if wxUSE_UNICODE
17045 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17046 #else
17047 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17048 #endif
17049 }
17050 return pyobj;
17051 }
17052
17053
17054 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17055 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17056 return 1;
17057 }
17058
17059
17060 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17061 PyObject *pyobj = 0;
17062
17063 {
17064 #if wxUSE_UNICODE
17065 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17066 #else
17067 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17068 #endif
17069 }
17070 return pyobj;
17071 }
17072
17073
17074 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17075 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17076 return 1;
17077 }
17078
17079
17080 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17081 PyObject *pyobj = 0;
17082
17083 {
17084 #if wxUSE_UNICODE
17085 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17086 #else
17087 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17088 #endif
17089 }
17090 return pyobj;
17091 }
17092
17093
17094 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17095 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17096 return 1;
17097 }
17098
17099
17100 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17101 PyObject *pyobj = 0;
17102
17103 {
17104 #if wxUSE_UNICODE
17105 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17106 #else
17107 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17108 #endif
17109 }
17110 return pyobj;
17111 }
17112
17113
17114 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17115 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17116 return 1;
17117 }
17118
17119
17120 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17121 PyObject *pyobj = 0;
17122
17123 {
17124 #if wxUSE_UNICODE
17125 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17126 #else
17127 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17128 #endif
17129 }
17130 return pyobj;
17131 }
17132
17133
17134 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17135 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17136 return 1;
17137 }
17138
17139
17140 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17141 PyObject *pyobj = 0;
17142
17143 {
17144 #if wxUSE_UNICODE
17145 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17146 #else
17147 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17148 #endif
17149 }
17150 return pyobj;
17151 }
17152
17153
17154 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17155 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17156 return 1;
17157 }
17158
17159
17160 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17161 PyObject *pyobj = 0;
17162
17163 {
17164 #if wxUSE_UNICODE
17165 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17166 #else
17167 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17168 #endif
17169 }
17170 return pyobj;
17171 }
17172
17173
17174 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17175 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17176 return 1;
17177 }
17178
17179
17180 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17181 PyObject *pyobj = 0;
17182
17183 {
17184 #if wxUSE_UNICODE
17185 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17186 #else
17187 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17188 #endif
17189 }
17190 return pyobj;
17191 }
17192
17193
17194 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17195 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17196 return 1;
17197 }
17198
17199
17200 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17201 PyObject *pyobj = 0;
17202
17203 {
17204 #if wxUSE_UNICODE
17205 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17206 #else
17207 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17208 #endif
17209 }
17210 return pyobj;
17211 }
17212
17213
17214 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17215 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17216 return 1;
17217 }
17218
17219
17220 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17221 PyObject *pyobj = 0;
17222
17223 {
17224 #if wxUSE_UNICODE
17225 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17226 #else
17227 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17228 #endif
17229 }
17230 return pyobj;
17231 }
17232
17233
17234 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17235 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17236 return 1;
17237 }
17238
17239
17240 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17241 PyObject *pyobj = 0;
17242
17243 {
17244 #if wxUSE_UNICODE
17245 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17246 #else
17247 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17248 #endif
17249 }
17250 return pyobj;
17251 }
17252
17253
17254 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17255 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17256 return 1;
17257 }
17258
17259
17260 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17261 PyObject *pyobj = 0;
17262
17263 {
17264 #if wxUSE_UNICODE
17265 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17266 #else
17267 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17268 #endif
17269 }
17270 return pyobj;
17271 }
17272
17273
17274 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17275 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17276 return 1;
17277 }
17278
17279
17280 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17281 PyObject *pyobj = 0;
17282
17283 {
17284 #if wxUSE_UNICODE
17285 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17286 #else
17287 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17288 #endif
17289 }
17290 return pyobj;
17291 }
17292
17293
17294 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17295 PyObject *resultobj = 0;
17296 wxBMPHandler *result = 0 ;
17297
17298 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17299 {
17300 PyThreadState* __tstate = wxPyBeginAllowThreads();
17301 result = (wxBMPHandler *)new wxBMPHandler();
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17306 return resultobj;
17307 fail:
17308 return NULL;
17309 }
17310
17311
17312 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17313 PyObject *obj;
17314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17315 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17316 return SWIG_Py_Void();
17317 }
17318
17319 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320 return SWIG_Python_InitShadowInstance(args);
17321 }
17322
17323 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17324 PyObject *resultobj = 0;
17325 wxICOHandler *result = 0 ;
17326
17327 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17328 {
17329 PyThreadState* __tstate = wxPyBeginAllowThreads();
17330 result = (wxICOHandler *)new wxICOHandler();
17331 wxPyEndAllowThreads(__tstate);
17332 if (PyErr_Occurred()) SWIG_fail;
17333 }
17334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17335 return resultobj;
17336 fail:
17337 return NULL;
17338 }
17339
17340
17341 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17342 PyObject *obj;
17343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17344 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17345 return SWIG_Py_Void();
17346 }
17347
17348 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17349 return SWIG_Python_InitShadowInstance(args);
17350 }
17351
17352 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17353 PyObject *resultobj = 0;
17354 wxCURHandler *result = 0 ;
17355
17356 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = (wxCURHandler *)new wxCURHandler();
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17364 return resultobj;
17365 fail:
17366 return NULL;
17367 }
17368
17369
17370 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17371 PyObject *obj;
17372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17373 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17374 return SWIG_Py_Void();
17375 }
17376
17377 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17378 return SWIG_Python_InitShadowInstance(args);
17379 }
17380
17381 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17382 PyObject *resultobj = 0;
17383 wxANIHandler *result = 0 ;
17384
17385 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17386 {
17387 PyThreadState* __tstate = wxPyBeginAllowThreads();
17388 result = (wxANIHandler *)new wxANIHandler();
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17393 return resultobj;
17394 fail:
17395 return NULL;
17396 }
17397
17398
17399 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17400 PyObject *obj;
17401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17402 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17403 return SWIG_Py_Void();
17404 }
17405
17406 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17407 return SWIG_Python_InitShadowInstance(args);
17408 }
17409
17410 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17411 PyObject *resultobj = 0;
17412 wxPNGHandler *result = 0 ;
17413
17414 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 result = (wxPNGHandler *)new wxPNGHandler();
17418 wxPyEndAllowThreads(__tstate);
17419 if (PyErr_Occurred()) SWIG_fail;
17420 }
17421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17429 PyObject *obj;
17430 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17431 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17432 return SWIG_Py_Void();
17433 }
17434
17435 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17436 return SWIG_Python_InitShadowInstance(args);
17437 }
17438
17439 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17440 PyObject *resultobj = 0;
17441 wxGIFHandler *result = 0 ;
17442
17443 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17444 {
17445 PyThreadState* __tstate = wxPyBeginAllowThreads();
17446 result = (wxGIFHandler *)new wxGIFHandler();
17447 wxPyEndAllowThreads(__tstate);
17448 if (PyErr_Occurred()) SWIG_fail;
17449 }
17450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17458 PyObject *obj;
17459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17460 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17461 return SWIG_Py_Void();
17462 }
17463
17464 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17465 return SWIG_Python_InitShadowInstance(args);
17466 }
17467
17468 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 PyObject *resultobj = 0;
17470 wxPCXHandler *result = 0 ;
17471
17472 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17473 {
17474 PyThreadState* __tstate = wxPyBeginAllowThreads();
17475 result = (wxPCXHandler *)new wxPCXHandler();
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17480 return resultobj;
17481 fail:
17482 return NULL;
17483 }
17484
17485
17486 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 PyObject *obj;
17488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17489 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17490 return SWIG_Py_Void();
17491 }
17492
17493 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17494 return SWIG_Python_InitShadowInstance(args);
17495 }
17496
17497 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17498 PyObject *resultobj = 0;
17499 wxJPEGHandler *result = 0 ;
17500
17501 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17502 {
17503 PyThreadState* __tstate = wxPyBeginAllowThreads();
17504 result = (wxJPEGHandler *)new wxJPEGHandler();
17505 wxPyEndAllowThreads(__tstate);
17506 if (PyErr_Occurred()) SWIG_fail;
17507 }
17508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17516 PyObject *obj;
17517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17518 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17519 return SWIG_Py_Void();
17520 }
17521
17522 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17523 return SWIG_Python_InitShadowInstance(args);
17524 }
17525
17526 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17527 PyObject *resultobj = 0;
17528 wxPNMHandler *result = 0 ;
17529
17530 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17531 {
17532 PyThreadState* __tstate = wxPyBeginAllowThreads();
17533 result = (wxPNMHandler *)new wxPNMHandler();
17534 wxPyEndAllowThreads(__tstate);
17535 if (PyErr_Occurred()) SWIG_fail;
17536 }
17537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17538 return resultobj;
17539 fail:
17540 return NULL;
17541 }
17542
17543
17544 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17545 PyObject *obj;
17546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17547 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17548 return SWIG_Py_Void();
17549 }
17550
17551 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17552 return SWIG_Python_InitShadowInstance(args);
17553 }
17554
17555 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17556 PyObject *resultobj = 0;
17557 wxXPMHandler *result = 0 ;
17558
17559 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17560 {
17561 PyThreadState* __tstate = wxPyBeginAllowThreads();
17562 result = (wxXPMHandler *)new wxXPMHandler();
17563 wxPyEndAllowThreads(__tstate);
17564 if (PyErr_Occurred()) SWIG_fail;
17565 }
17566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17567 return resultobj;
17568 fail:
17569 return NULL;
17570 }
17571
17572
17573 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 PyObject *obj;
17575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17576 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17577 return SWIG_Py_Void();
17578 }
17579
17580 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17581 return SWIG_Python_InitShadowInstance(args);
17582 }
17583
17584 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17585 PyObject *resultobj = 0;
17586 wxTIFFHandler *result = 0 ;
17587
17588 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17589 {
17590 PyThreadState* __tstate = wxPyBeginAllowThreads();
17591 result = (wxTIFFHandler *)new wxTIFFHandler();
17592 wxPyEndAllowThreads(__tstate);
17593 if (PyErr_Occurred()) SWIG_fail;
17594 }
17595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17596 return resultobj;
17597 fail:
17598 return NULL;
17599 }
17600
17601
17602 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17603 PyObject *obj;
17604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17605 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17606 return SWIG_Py_Void();
17607 }
17608
17609 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17610 return SWIG_Python_InitShadowInstance(args);
17611 }
17612
17613 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17614 PyObject *resultobj = 0;
17615 wxImage *arg1 = 0 ;
17616 wxImage *arg2 = 0 ;
17617 int arg3 = (int) 236 ;
17618 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17619 bool result;
17620 void *argp1 = 0 ;
17621 int res1 = 0 ;
17622 void *argp2 = 0 ;
17623 int res2 = 0 ;
17624 int val3 ;
17625 int ecode3 = 0 ;
17626 int val4 ;
17627 int ecode4 = 0 ;
17628 PyObject * obj0 = 0 ;
17629 PyObject * obj1 = 0 ;
17630 PyObject * obj2 = 0 ;
17631 PyObject * obj3 = 0 ;
17632 char * kwnames[] = {
17633 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17634 };
17635
17636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17637 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17638 if (!SWIG_IsOK(res1)) {
17639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17640 }
17641 if (!argp1) {
17642 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17643 }
17644 arg1 = reinterpret_cast< wxImage * >(argp1);
17645 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17646 if (!SWIG_IsOK(res2)) {
17647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17648 }
17649 if (!argp2) {
17650 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17651 }
17652 arg2 = reinterpret_cast< wxImage * >(argp2);
17653 if (obj2) {
17654 ecode3 = SWIG_AsVal_int(obj2, &val3);
17655 if (!SWIG_IsOK(ecode3)) {
17656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17657 }
17658 arg3 = static_cast< int >(val3);
17659 }
17660 if (obj3) {
17661 ecode4 = SWIG_AsVal_int(obj3, &val4);
17662 if (!SWIG_IsOK(ecode4)) {
17663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17664 }
17665 arg4 = static_cast< int >(val4);
17666 }
17667 {
17668 PyThreadState* __tstate = wxPyBeginAllowThreads();
17669 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17670 wxPyEndAllowThreads(__tstate);
17671 if (PyErr_Occurred()) SWIG_fail;
17672 }
17673 {
17674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17675 }
17676 return resultobj;
17677 fail:
17678 return NULL;
17679 }
17680
17681
17682 SWIGINTERN PyObject *Quantize_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_wxQuantize, SWIG_NewClientData(obj));
17686 return SWIG_Py_Void();
17687 }
17688
17689 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17690 PyObject *resultobj = 0;
17691 wxEvtHandler *result = 0 ;
17692
17693 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17694 {
17695 PyThreadState* __tstate = wxPyBeginAllowThreads();
17696 result = (wxEvtHandler *)new wxEvtHandler();
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17701 return resultobj;
17702 fail:
17703 return NULL;
17704 }
17705
17706
17707 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17708 PyObject *resultobj = 0;
17709 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17710 wxEvtHandler *result = 0 ;
17711 void *argp1 = 0 ;
17712 int res1 = 0 ;
17713 PyObject *swig_obj[1] ;
17714
17715 if (!args) SWIG_fail;
17716 swig_obj[0] = args;
17717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17718 if (!SWIG_IsOK(res1)) {
17719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17720 }
17721 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17722 {
17723 PyThreadState* __tstate = wxPyBeginAllowThreads();
17724 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17725 wxPyEndAllowThreads(__tstate);
17726 if (PyErr_Occurred()) SWIG_fail;
17727 }
17728 {
17729 resultobj = wxPyMake_wxObject(result, 0);
17730 }
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17738 PyObject *resultobj = 0;
17739 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17740 wxEvtHandler *result = 0 ;
17741 void *argp1 = 0 ;
17742 int res1 = 0 ;
17743 PyObject *swig_obj[1] ;
17744
17745 if (!args) SWIG_fail;
17746 swig_obj[0] = args;
17747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17748 if (!SWIG_IsOK(res1)) {
17749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17750 }
17751 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17755 wxPyEndAllowThreads(__tstate);
17756 if (PyErr_Occurred()) SWIG_fail;
17757 }
17758 {
17759 resultobj = wxPyMake_wxObject(result, 0);
17760 }
17761 return resultobj;
17762 fail:
17763 return NULL;
17764 }
17765
17766
17767 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj = 0;
17769 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17770 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 void *argp2 = 0 ;
17774 int res2 = 0 ;
17775 PyObject * obj0 = 0 ;
17776 PyObject * obj1 = 0 ;
17777 char * kwnames[] = {
17778 (char *) "self",(char *) "handler", NULL
17779 };
17780
17781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17783 if (!SWIG_IsOK(res1)) {
17784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17785 }
17786 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17788 if (!SWIG_IsOK(res2)) {
17789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17790 }
17791 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17792 {
17793 PyThreadState* __tstate = wxPyBeginAllowThreads();
17794 (arg1)->SetNextHandler(arg2);
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 resultobj = SWIG_Py_Void();
17799 return resultobj;
17800 fail:
17801 return NULL;
17802 }
17803
17804
17805 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17806 PyObject *resultobj = 0;
17807 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17808 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17809 void *argp1 = 0 ;
17810 int res1 = 0 ;
17811 void *argp2 = 0 ;
17812 int res2 = 0 ;
17813 PyObject * obj0 = 0 ;
17814 PyObject * obj1 = 0 ;
17815 char * kwnames[] = {
17816 (char *) "self",(char *) "handler", NULL
17817 };
17818
17819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17821 if (!SWIG_IsOK(res1)) {
17822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17823 }
17824 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17826 if (!SWIG_IsOK(res2)) {
17827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17828 }
17829 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17830 {
17831 PyThreadState* __tstate = wxPyBeginAllowThreads();
17832 (arg1)->SetPreviousHandler(arg2);
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 resultobj = SWIG_Py_Void();
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17844 PyObject *resultobj = 0;
17845 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17846 bool result;
17847 void *argp1 = 0 ;
17848 int res1 = 0 ;
17849 PyObject *swig_obj[1] ;
17850
17851 if (!args) SWIG_fail;
17852 swig_obj[0] = args;
17853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17854 if (!SWIG_IsOK(res1)) {
17855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17856 }
17857 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17858 {
17859 PyThreadState* __tstate = wxPyBeginAllowThreads();
17860 result = (bool)(arg1)->GetEvtHandlerEnabled();
17861 wxPyEndAllowThreads(__tstate);
17862 if (PyErr_Occurred()) SWIG_fail;
17863 }
17864 {
17865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17866 }
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj = 0;
17875 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17876 bool arg2 ;
17877 void *argp1 = 0 ;
17878 int res1 = 0 ;
17879 bool val2 ;
17880 int ecode2 = 0 ;
17881 PyObject * obj0 = 0 ;
17882 PyObject * obj1 = 0 ;
17883 char * kwnames[] = {
17884 (char *) "self",(char *) "enabled", NULL
17885 };
17886
17887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17889 if (!SWIG_IsOK(res1)) {
17890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17891 }
17892 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17893 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17894 if (!SWIG_IsOK(ecode2)) {
17895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17896 }
17897 arg2 = static_cast< bool >(val2);
17898 {
17899 PyThreadState* __tstate = wxPyBeginAllowThreads();
17900 (arg1)->SetEvtHandlerEnabled(arg2);
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 resultobj = SWIG_Py_Void();
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj = 0;
17913 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17914 wxEvent *arg2 = 0 ;
17915 bool result;
17916 void *argp1 = 0 ;
17917 int res1 = 0 ;
17918 void *argp2 = 0 ;
17919 int res2 = 0 ;
17920 PyObject * obj0 = 0 ;
17921 PyObject * obj1 = 0 ;
17922 char * kwnames[] = {
17923 (char *) "self",(char *) "event", NULL
17924 };
17925
17926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17930 }
17931 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17932 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17933 if (!SWIG_IsOK(res2)) {
17934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17935 }
17936 if (!argp2) {
17937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17938 }
17939 arg2 = reinterpret_cast< wxEvent * >(argp2);
17940 {
17941 PyThreadState* __tstate = wxPyBeginAllowThreads();
17942 result = (bool)(arg1)->ProcessEvent(*arg2);
17943 wxPyEndAllowThreads(__tstate);
17944 if (PyErr_Occurred()) SWIG_fail;
17945 }
17946 {
17947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17948 }
17949 return resultobj;
17950 fail:
17951 return NULL;
17952 }
17953
17954
17955 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17956 PyObject *resultobj = 0;
17957 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17958 wxEvent *arg2 = 0 ;
17959 void *argp1 = 0 ;
17960 int res1 = 0 ;
17961 void *argp2 = 0 ;
17962 int res2 = 0 ;
17963 PyObject * obj0 = 0 ;
17964 PyObject * obj1 = 0 ;
17965 char * kwnames[] = {
17966 (char *) "self",(char *) "event", NULL
17967 };
17968
17969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17971 if (!SWIG_IsOK(res1)) {
17972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17973 }
17974 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17975 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17976 if (!SWIG_IsOK(res2)) {
17977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17978 }
17979 if (!argp2) {
17980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17981 }
17982 arg2 = reinterpret_cast< wxEvent * >(argp2);
17983 {
17984 PyThreadState* __tstate = wxPyBeginAllowThreads();
17985 (arg1)->AddPendingEvent(*arg2);
17986 wxPyEndAllowThreads(__tstate);
17987 if (PyErr_Occurred()) SWIG_fail;
17988 }
17989 resultobj = SWIG_Py_Void();
17990 return resultobj;
17991 fail:
17992 return NULL;
17993 }
17994
17995
17996 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17997 PyObject *resultobj = 0;
17998 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17999 void *argp1 = 0 ;
18000 int res1 = 0 ;
18001 PyObject *swig_obj[1] ;
18002
18003 if (!args) SWIG_fail;
18004 swig_obj[0] = args;
18005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18006 if (!SWIG_IsOK(res1)) {
18007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18008 }
18009 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 (arg1)->ProcessPendingEvents();
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 resultobj = SWIG_Py_Void();
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj = 0;
18025 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18026 int arg2 ;
18027 int arg3 ;
18028 int arg4 ;
18029 PyObject *arg5 = (PyObject *) 0 ;
18030 void *argp1 = 0 ;
18031 int res1 = 0 ;
18032 int val2 ;
18033 int ecode2 = 0 ;
18034 int val3 ;
18035 int ecode3 = 0 ;
18036 int val4 ;
18037 int ecode4 = 0 ;
18038 PyObject * obj0 = 0 ;
18039 PyObject * obj1 = 0 ;
18040 PyObject * obj2 = 0 ;
18041 PyObject * obj3 = 0 ;
18042 PyObject * obj4 = 0 ;
18043 char * kwnames[] = {
18044 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18045 };
18046
18047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18049 if (!SWIG_IsOK(res1)) {
18050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18051 }
18052 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18053 ecode2 = SWIG_AsVal_int(obj1, &val2);
18054 if (!SWIG_IsOK(ecode2)) {
18055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18056 }
18057 arg2 = static_cast< int >(val2);
18058 ecode3 = SWIG_AsVal_int(obj2, &val3);
18059 if (!SWIG_IsOK(ecode3)) {
18060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18061 }
18062 arg3 = static_cast< int >(val3);
18063 ecode4 = SWIG_AsVal_int(obj3, &val4);
18064 if (!SWIG_IsOK(ecode4)) {
18065 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18066 }
18067 arg4 = static_cast< int >(val4);
18068 arg5 = obj4;
18069 {
18070 PyThreadState* __tstate = wxPyBeginAllowThreads();
18071 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18072 wxPyEndAllowThreads(__tstate);
18073 if (PyErr_Occurred()) SWIG_fail;
18074 }
18075 resultobj = SWIG_Py_Void();
18076 return resultobj;
18077 fail:
18078 return NULL;
18079 }
18080
18081
18082 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18083 PyObject *resultobj = 0;
18084 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18085 int arg2 ;
18086 int arg3 = (int) -1 ;
18087 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18088 bool result;
18089 void *argp1 = 0 ;
18090 int res1 = 0 ;
18091 int val2 ;
18092 int ecode2 = 0 ;
18093 int val3 ;
18094 int ecode3 = 0 ;
18095 int val4 ;
18096 int ecode4 = 0 ;
18097 PyObject * obj0 = 0 ;
18098 PyObject * obj1 = 0 ;
18099 PyObject * obj2 = 0 ;
18100 PyObject * obj3 = 0 ;
18101 char * kwnames[] = {
18102 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18103 };
18104
18105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18107 if (!SWIG_IsOK(res1)) {
18108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18109 }
18110 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18111 ecode2 = SWIG_AsVal_int(obj1, &val2);
18112 if (!SWIG_IsOK(ecode2)) {
18113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18114 }
18115 arg2 = static_cast< int >(val2);
18116 if (obj2) {
18117 ecode3 = SWIG_AsVal_int(obj2, &val3);
18118 if (!SWIG_IsOK(ecode3)) {
18119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18120 }
18121 arg3 = static_cast< int >(val3);
18122 }
18123 if (obj3) {
18124 ecode4 = SWIG_AsVal_int(obj3, &val4);
18125 if (!SWIG_IsOK(ecode4)) {
18126 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18127 }
18128 arg4 = static_cast< wxEventType >(val4);
18129 }
18130 {
18131 PyThreadState* __tstate = wxPyBeginAllowThreads();
18132 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18133 wxPyEndAllowThreads(__tstate);
18134 if (PyErr_Occurred()) SWIG_fail;
18135 }
18136 {
18137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18138 }
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18146 PyObject *resultobj = 0;
18147 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18148 PyObject *arg2 = (PyObject *) 0 ;
18149 bool arg3 = (bool) true ;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 bool val3 ;
18153 int ecode3 = 0 ;
18154 PyObject * obj0 = 0 ;
18155 PyObject * obj1 = 0 ;
18156 PyObject * obj2 = 0 ;
18157 char * kwnames[] = {
18158 (char *) "self",(char *) "_self",(char *) "incref", NULL
18159 };
18160
18161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18163 if (!SWIG_IsOK(res1)) {
18164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18165 }
18166 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18167 arg2 = obj1;
18168 if (obj2) {
18169 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18170 if (!SWIG_IsOK(ecode3)) {
18171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18172 }
18173 arg3 = static_cast< bool >(val3);
18174 }
18175 {
18176 PyThreadState* __tstate = wxPyBeginAllowThreads();
18177 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18178 wxPyEndAllowThreads(__tstate);
18179 if (PyErr_Occurred()) SWIG_fail;
18180 }
18181 resultobj = SWIG_Py_Void();
18182 return resultobj;
18183 fail:
18184 return NULL;
18185 }
18186
18187
18188 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18189 PyObject *obj;
18190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18191 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18192 return SWIG_Py_Void();
18193 }
18194
18195 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18196 return SWIG_Python_InitShadowInstance(args);
18197 }
18198
18199 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18200 PyObject *resultobj = 0;
18201 wxEventType result;
18202
18203 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 result = (wxEventType)wxNewEventType();
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 resultobj = SWIG_From_int(static_cast< int >(result));
18211 return resultobj;
18212 fail:
18213 return NULL;
18214 }
18215
18216
18217 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18218 PyObject *resultobj = 0;
18219 wxEvent *arg1 = (wxEvent *) 0 ;
18220 void *argp1 = 0 ;
18221 int res1 = 0 ;
18222 PyObject *swig_obj[1] ;
18223
18224 if (!args) SWIG_fail;
18225 swig_obj[0] = args;
18226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18227 if (!SWIG_IsOK(res1)) {
18228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18229 }
18230 arg1 = reinterpret_cast< wxEvent * >(argp1);
18231 {
18232 PyThreadState* __tstate = wxPyBeginAllowThreads();
18233 delete arg1;
18234
18235 wxPyEndAllowThreads(__tstate);
18236 if (PyErr_Occurred()) SWIG_fail;
18237 }
18238 resultobj = SWIG_Py_Void();
18239 return resultobj;
18240 fail:
18241 return NULL;
18242 }
18243
18244
18245 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18246 PyObject *resultobj = 0;
18247 wxEvent *arg1 = (wxEvent *) 0 ;
18248 wxEventType arg2 ;
18249 void *argp1 = 0 ;
18250 int res1 = 0 ;
18251 int val2 ;
18252 int ecode2 = 0 ;
18253 PyObject * obj0 = 0 ;
18254 PyObject * obj1 = 0 ;
18255 char * kwnames[] = {
18256 (char *) "self",(char *) "typ", NULL
18257 };
18258
18259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18261 if (!SWIG_IsOK(res1)) {
18262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18263 }
18264 arg1 = reinterpret_cast< wxEvent * >(argp1);
18265 ecode2 = SWIG_AsVal_int(obj1, &val2);
18266 if (!SWIG_IsOK(ecode2)) {
18267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18268 }
18269 arg2 = static_cast< wxEventType >(val2);
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 (arg1)->SetEventType(arg2);
18273 wxPyEndAllowThreads(__tstate);
18274 if (PyErr_Occurred()) SWIG_fail;
18275 }
18276 resultobj = SWIG_Py_Void();
18277 return resultobj;
18278 fail:
18279 return NULL;
18280 }
18281
18282
18283 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18284 PyObject *resultobj = 0;
18285 wxEvent *arg1 = (wxEvent *) 0 ;
18286 wxEventType result;
18287 void *argp1 = 0 ;
18288 int res1 = 0 ;
18289 PyObject *swig_obj[1] ;
18290
18291 if (!args) SWIG_fail;
18292 swig_obj[0] = args;
18293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18296 }
18297 arg1 = reinterpret_cast< wxEvent * >(argp1);
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18301 wxPyEndAllowThreads(__tstate);
18302 if (PyErr_Occurred()) SWIG_fail;
18303 }
18304 resultobj = SWIG_From_int(static_cast< int >(result));
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18312 PyObject *resultobj = 0;
18313 wxEvent *arg1 = (wxEvent *) 0 ;
18314 wxObject *result = 0 ;
18315 void *argp1 = 0 ;
18316 int res1 = 0 ;
18317 PyObject *swig_obj[1] ;
18318
18319 if (!args) SWIG_fail;
18320 swig_obj[0] = args;
18321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18322 if (!SWIG_IsOK(res1)) {
18323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18324 }
18325 arg1 = reinterpret_cast< wxEvent * >(argp1);
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 {
18333 resultobj = wxPyMake_wxObject(result, (bool)0);
18334 }
18335 return resultobj;
18336 fail:
18337 return NULL;
18338 }
18339
18340
18341 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18342 PyObject *resultobj = 0;
18343 wxEvent *arg1 = (wxEvent *) 0 ;
18344 wxObject *arg2 = (wxObject *) 0 ;
18345 void *argp1 = 0 ;
18346 int res1 = 0 ;
18347 void *argp2 = 0 ;
18348 int res2 = 0 ;
18349 PyObject * obj0 = 0 ;
18350 PyObject * obj1 = 0 ;
18351 char * kwnames[] = {
18352 (char *) "self",(char *) "obj", NULL
18353 };
18354
18355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18357 if (!SWIG_IsOK(res1)) {
18358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18359 }
18360 arg1 = reinterpret_cast< wxEvent * >(argp1);
18361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18362 if (!SWIG_IsOK(res2)) {
18363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18364 }
18365 arg2 = reinterpret_cast< wxObject * >(argp2);
18366 {
18367 PyThreadState* __tstate = wxPyBeginAllowThreads();
18368 (arg1)->SetEventObject(arg2);
18369 wxPyEndAllowThreads(__tstate);
18370 if (PyErr_Occurred()) SWIG_fail;
18371 }
18372 resultobj = SWIG_Py_Void();
18373 return resultobj;
18374 fail:
18375 return NULL;
18376 }
18377
18378
18379 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18380 PyObject *resultobj = 0;
18381 wxEvent *arg1 = (wxEvent *) 0 ;
18382 long result;
18383 void *argp1 = 0 ;
18384 int res1 = 0 ;
18385 PyObject *swig_obj[1] ;
18386
18387 if (!args) SWIG_fail;
18388 swig_obj[0] = args;
18389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18390 if (!SWIG_IsOK(res1)) {
18391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18392 }
18393 arg1 = reinterpret_cast< wxEvent * >(argp1);
18394 {
18395 PyThreadState* __tstate = wxPyBeginAllowThreads();
18396 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18397 wxPyEndAllowThreads(__tstate);
18398 if (PyErr_Occurred()) SWIG_fail;
18399 }
18400 resultobj = SWIG_From_long(static_cast< long >(result));
18401 return resultobj;
18402 fail:
18403 return NULL;
18404 }
18405
18406
18407 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18408 PyObject *resultobj = 0;
18409 wxEvent *arg1 = (wxEvent *) 0 ;
18410 long arg2 = (long) 0 ;
18411 void *argp1 = 0 ;
18412 int res1 = 0 ;
18413 long val2 ;
18414 int ecode2 = 0 ;
18415 PyObject * obj0 = 0 ;
18416 PyObject * obj1 = 0 ;
18417 char * kwnames[] = {
18418 (char *) "self",(char *) "ts", NULL
18419 };
18420
18421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18423 if (!SWIG_IsOK(res1)) {
18424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18425 }
18426 arg1 = reinterpret_cast< wxEvent * >(argp1);
18427 if (obj1) {
18428 ecode2 = SWIG_AsVal_long(obj1, &val2);
18429 if (!SWIG_IsOK(ecode2)) {
18430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18431 }
18432 arg2 = static_cast< long >(val2);
18433 }
18434 {
18435 PyThreadState* __tstate = wxPyBeginAllowThreads();
18436 (arg1)->SetTimestamp(arg2);
18437 wxPyEndAllowThreads(__tstate);
18438 if (PyErr_Occurred()) SWIG_fail;
18439 }
18440 resultobj = SWIG_Py_Void();
18441 return resultobj;
18442 fail:
18443 return NULL;
18444 }
18445
18446
18447 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18448 PyObject *resultobj = 0;
18449 wxEvent *arg1 = (wxEvent *) 0 ;
18450 int result;
18451 void *argp1 = 0 ;
18452 int res1 = 0 ;
18453 PyObject *swig_obj[1] ;
18454
18455 if (!args) SWIG_fail;
18456 swig_obj[0] = args;
18457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18458 if (!SWIG_IsOK(res1)) {
18459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18460 }
18461 arg1 = reinterpret_cast< wxEvent * >(argp1);
18462 {
18463 PyThreadState* __tstate = wxPyBeginAllowThreads();
18464 result = (int)((wxEvent const *)arg1)->GetId();
18465 wxPyEndAllowThreads(__tstate);
18466 if (PyErr_Occurred()) SWIG_fail;
18467 }
18468 resultobj = SWIG_From_int(static_cast< int >(result));
18469 return resultobj;
18470 fail:
18471 return NULL;
18472 }
18473
18474
18475 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18476 PyObject *resultobj = 0;
18477 wxEvent *arg1 = (wxEvent *) 0 ;
18478 int arg2 ;
18479 void *argp1 = 0 ;
18480 int res1 = 0 ;
18481 int val2 ;
18482 int ecode2 = 0 ;
18483 PyObject * obj0 = 0 ;
18484 PyObject * obj1 = 0 ;
18485 char * kwnames[] = {
18486 (char *) "self",(char *) "Id", NULL
18487 };
18488
18489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18491 if (!SWIG_IsOK(res1)) {
18492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18493 }
18494 arg1 = reinterpret_cast< wxEvent * >(argp1);
18495 ecode2 = SWIG_AsVal_int(obj1, &val2);
18496 if (!SWIG_IsOK(ecode2)) {
18497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18498 }
18499 arg2 = static_cast< int >(val2);
18500 {
18501 PyThreadState* __tstate = wxPyBeginAllowThreads();
18502 (arg1)->SetId(arg2);
18503 wxPyEndAllowThreads(__tstate);
18504 if (PyErr_Occurred()) SWIG_fail;
18505 }
18506 resultobj = SWIG_Py_Void();
18507 return resultobj;
18508 fail:
18509 return NULL;
18510 }
18511
18512
18513 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18514 PyObject *resultobj = 0;
18515 wxEvent *arg1 = (wxEvent *) 0 ;
18516 bool result;
18517 void *argp1 = 0 ;
18518 int res1 = 0 ;
18519 PyObject *swig_obj[1] ;
18520
18521 if (!args) SWIG_fail;
18522 swig_obj[0] = args;
18523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18524 if (!SWIG_IsOK(res1)) {
18525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18526 }
18527 arg1 = reinterpret_cast< wxEvent * >(argp1);
18528 {
18529 PyThreadState* __tstate = wxPyBeginAllowThreads();
18530 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18531 wxPyEndAllowThreads(__tstate);
18532 if (PyErr_Occurred()) SWIG_fail;
18533 }
18534 {
18535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18536 }
18537 return resultobj;
18538 fail:
18539 return NULL;
18540 }
18541
18542
18543 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18544 PyObject *resultobj = 0;
18545 wxEvent *arg1 = (wxEvent *) 0 ;
18546 bool arg2 = (bool) true ;
18547 void *argp1 = 0 ;
18548 int res1 = 0 ;
18549 bool val2 ;
18550 int ecode2 = 0 ;
18551 PyObject * obj0 = 0 ;
18552 PyObject * obj1 = 0 ;
18553 char * kwnames[] = {
18554 (char *) "self",(char *) "skip", NULL
18555 };
18556
18557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18559 if (!SWIG_IsOK(res1)) {
18560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18561 }
18562 arg1 = reinterpret_cast< wxEvent * >(argp1);
18563 if (obj1) {
18564 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18565 if (!SWIG_IsOK(ecode2)) {
18566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18567 }
18568 arg2 = static_cast< bool >(val2);
18569 }
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 (arg1)->Skip(arg2);
18573 wxPyEndAllowThreads(__tstate);
18574 if (PyErr_Occurred()) SWIG_fail;
18575 }
18576 resultobj = SWIG_Py_Void();
18577 return resultobj;
18578 fail:
18579 return NULL;
18580 }
18581
18582
18583 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18584 PyObject *resultobj = 0;
18585 wxEvent *arg1 = (wxEvent *) 0 ;
18586 bool result;
18587 void *argp1 = 0 ;
18588 int res1 = 0 ;
18589 PyObject *swig_obj[1] ;
18590
18591 if (!args) SWIG_fail;
18592 swig_obj[0] = args;
18593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18594 if (!SWIG_IsOK(res1)) {
18595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18596 }
18597 arg1 = reinterpret_cast< wxEvent * >(argp1);
18598 {
18599 PyThreadState* __tstate = wxPyBeginAllowThreads();
18600 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18601 wxPyEndAllowThreads(__tstate);
18602 if (PyErr_Occurred()) SWIG_fail;
18603 }
18604 {
18605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18606 }
18607 return resultobj;
18608 fail:
18609 return NULL;
18610 }
18611
18612
18613 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18614 PyObject *resultobj = 0;
18615 wxEvent *arg1 = (wxEvent *) 0 ;
18616 bool result;
18617 void *argp1 = 0 ;
18618 int res1 = 0 ;
18619 PyObject *swig_obj[1] ;
18620
18621 if (!args) SWIG_fail;
18622 swig_obj[0] = args;
18623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18624 if (!SWIG_IsOK(res1)) {
18625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18626 }
18627 arg1 = reinterpret_cast< wxEvent * >(argp1);
18628 {
18629 PyThreadState* __tstate = wxPyBeginAllowThreads();
18630 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18631 wxPyEndAllowThreads(__tstate);
18632 if (PyErr_Occurred()) SWIG_fail;
18633 }
18634 {
18635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18636 }
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxEvent *arg1 = (wxEvent *) 0 ;
18646 int result;
18647 void *argp1 = 0 ;
18648 int res1 = 0 ;
18649 PyObject *swig_obj[1] ;
18650
18651 if (!args) SWIG_fail;
18652 swig_obj[0] = args;
18653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18656 }
18657 arg1 = reinterpret_cast< wxEvent * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (int)(arg1)->StopPropagation();
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 resultobj = SWIG_From_int(static_cast< int >(result));
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18672 PyObject *resultobj = 0;
18673 wxEvent *arg1 = (wxEvent *) 0 ;
18674 int arg2 ;
18675 void *argp1 = 0 ;
18676 int res1 = 0 ;
18677 int val2 ;
18678 int ecode2 = 0 ;
18679 PyObject * obj0 = 0 ;
18680 PyObject * obj1 = 0 ;
18681 char * kwnames[] = {
18682 (char *) "self",(char *) "propagationLevel", NULL
18683 };
18684
18685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18687 if (!SWIG_IsOK(res1)) {
18688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18689 }
18690 arg1 = reinterpret_cast< wxEvent * >(argp1);
18691 ecode2 = SWIG_AsVal_int(obj1, &val2);
18692 if (!SWIG_IsOK(ecode2)) {
18693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18694 }
18695 arg2 = static_cast< int >(val2);
18696 {
18697 PyThreadState* __tstate = wxPyBeginAllowThreads();
18698 (arg1)->ResumePropagation(arg2);
18699 wxPyEndAllowThreads(__tstate);
18700 if (PyErr_Occurred()) SWIG_fail;
18701 }
18702 resultobj = SWIG_Py_Void();
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18710 PyObject *resultobj = 0;
18711 wxEvent *arg1 = (wxEvent *) 0 ;
18712 wxEvent *result = 0 ;
18713 void *argp1 = 0 ;
18714 int res1 = 0 ;
18715 PyObject *swig_obj[1] ;
18716
18717 if (!args) SWIG_fail;
18718 swig_obj[0] = args;
18719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18720 if (!SWIG_IsOK(res1)) {
18721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18722 }
18723 arg1 = reinterpret_cast< wxEvent * >(argp1);
18724 {
18725 PyThreadState* __tstate = wxPyBeginAllowThreads();
18726 result = (wxEvent *)(arg1)->Clone();
18727 wxPyEndAllowThreads(__tstate);
18728 if (PyErr_Occurred()) SWIG_fail;
18729 }
18730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18731 return resultobj;
18732 fail:
18733 return NULL;
18734 }
18735
18736
18737 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18738 PyObject *obj;
18739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18740 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18741 return SWIG_Py_Void();
18742 }
18743
18744 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18745 PyObject *resultobj = 0;
18746 wxEvent *arg1 = 0 ;
18747 wxPropagationDisabler *result = 0 ;
18748 void *argp1 = 0 ;
18749 int res1 = 0 ;
18750 PyObject * obj0 = 0 ;
18751 char * kwnames[] = {
18752 (char *) "event", NULL
18753 };
18754
18755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18756 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18757 if (!SWIG_IsOK(res1)) {
18758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18759 }
18760 if (!argp1) {
18761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18762 }
18763 arg1 = reinterpret_cast< wxEvent * >(argp1);
18764 {
18765 PyThreadState* __tstate = wxPyBeginAllowThreads();
18766 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18767 wxPyEndAllowThreads(__tstate);
18768 if (PyErr_Occurred()) SWIG_fail;
18769 }
18770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18771 return resultobj;
18772 fail:
18773 return NULL;
18774 }
18775
18776
18777 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18778 PyObject *resultobj = 0;
18779 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18780 void *argp1 = 0 ;
18781 int res1 = 0 ;
18782 PyObject *swig_obj[1] ;
18783
18784 if (!args) SWIG_fail;
18785 swig_obj[0] = args;
18786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18787 if (!SWIG_IsOK(res1)) {
18788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18789 }
18790 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18791 {
18792 PyThreadState* __tstate = wxPyBeginAllowThreads();
18793 delete arg1;
18794
18795 wxPyEndAllowThreads(__tstate);
18796 if (PyErr_Occurred()) SWIG_fail;
18797 }
18798 resultobj = SWIG_Py_Void();
18799 return resultobj;
18800 fail:
18801 return NULL;
18802 }
18803
18804
18805 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18806 PyObject *obj;
18807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18808 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18809 return SWIG_Py_Void();
18810 }
18811
18812 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18813 return SWIG_Python_InitShadowInstance(args);
18814 }
18815
18816 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18817 PyObject *resultobj = 0;
18818 wxEvent *arg1 = 0 ;
18819 wxPropagateOnce *result = 0 ;
18820 void *argp1 = 0 ;
18821 int res1 = 0 ;
18822 PyObject * obj0 = 0 ;
18823 char * kwnames[] = {
18824 (char *) "event", NULL
18825 };
18826
18827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18828 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18829 if (!SWIG_IsOK(res1)) {
18830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18831 }
18832 if (!argp1) {
18833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18834 }
18835 arg1 = reinterpret_cast< wxEvent * >(argp1);
18836 {
18837 PyThreadState* __tstate = wxPyBeginAllowThreads();
18838 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18839 wxPyEndAllowThreads(__tstate);
18840 if (PyErr_Occurred()) SWIG_fail;
18841 }
18842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18843 return resultobj;
18844 fail:
18845 return NULL;
18846 }
18847
18848
18849 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18850 PyObject *resultobj = 0;
18851 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 PyObject *swig_obj[1] ;
18855
18856 if (!args) SWIG_fail;
18857 swig_obj[0] = args;
18858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18859 if (!SWIG_IsOK(res1)) {
18860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18861 }
18862 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18863 {
18864 PyThreadState* __tstate = wxPyBeginAllowThreads();
18865 delete arg1;
18866
18867 wxPyEndAllowThreads(__tstate);
18868 if (PyErr_Occurred()) SWIG_fail;
18869 }
18870 resultobj = SWIG_Py_Void();
18871 return resultobj;
18872 fail:
18873 return NULL;
18874 }
18875
18876
18877 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18878 PyObject *obj;
18879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18880 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18881 return SWIG_Py_Void();
18882 }
18883
18884 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18885 return SWIG_Python_InitShadowInstance(args);
18886 }
18887
18888 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18889 PyObject *resultobj = 0;
18890 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18891 int arg2 = (int) 0 ;
18892 wxCommandEvent *result = 0 ;
18893 int val1 ;
18894 int ecode1 = 0 ;
18895 int val2 ;
18896 int ecode2 = 0 ;
18897 PyObject * obj0 = 0 ;
18898 PyObject * obj1 = 0 ;
18899 char * kwnames[] = {
18900 (char *) "commandType",(char *) "winid", NULL
18901 };
18902
18903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18904 if (obj0) {
18905 ecode1 = SWIG_AsVal_int(obj0, &val1);
18906 if (!SWIG_IsOK(ecode1)) {
18907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18908 }
18909 arg1 = static_cast< wxEventType >(val1);
18910 }
18911 if (obj1) {
18912 ecode2 = SWIG_AsVal_int(obj1, &val2);
18913 if (!SWIG_IsOK(ecode2)) {
18914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18915 }
18916 arg2 = static_cast< int >(val2);
18917 }
18918 {
18919 PyThreadState* __tstate = wxPyBeginAllowThreads();
18920 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18921 wxPyEndAllowThreads(__tstate);
18922 if (PyErr_Occurred()) SWIG_fail;
18923 }
18924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18925 return resultobj;
18926 fail:
18927 return NULL;
18928 }
18929
18930
18931 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18932 PyObject *resultobj = 0;
18933 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18934 int result;
18935 void *argp1 = 0 ;
18936 int res1 = 0 ;
18937 PyObject *swig_obj[1] ;
18938
18939 if (!args) SWIG_fail;
18940 swig_obj[0] = args;
18941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18942 if (!SWIG_IsOK(res1)) {
18943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18944 }
18945 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18946 {
18947 PyThreadState* __tstate = wxPyBeginAllowThreads();
18948 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18949 wxPyEndAllowThreads(__tstate);
18950 if (PyErr_Occurred()) SWIG_fail;
18951 }
18952 resultobj = SWIG_From_int(static_cast< int >(result));
18953 return resultobj;
18954 fail:
18955 return NULL;
18956 }
18957
18958
18959 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18960 PyObject *resultobj = 0;
18961 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18962 wxString *arg2 = 0 ;
18963 void *argp1 = 0 ;
18964 int res1 = 0 ;
18965 bool temp2 = false ;
18966 PyObject * obj0 = 0 ;
18967 PyObject * obj1 = 0 ;
18968 char * kwnames[] = {
18969 (char *) "self",(char *) "s", NULL
18970 };
18971
18972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18974 if (!SWIG_IsOK(res1)) {
18975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18976 }
18977 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18978 {
18979 arg2 = wxString_in_helper(obj1);
18980 if (arg2 == NULL) SWIG_fail;
18981 temp2 = true;
18982 }
18983 {
18984 PyThreadState* __tstate = wxPyBeginAllowThreads();
18985 (arg1)->SetString((wxString const &)*arg2);
18986 wxPyEndAllowThreads(__tstate);
18987 if (PyErr_Occurred()) SWIG_fail;
18988 }
18989 resultobj = SWIG_Py_Void();
18990 {
18991 if (temp2)
18992 delete arg2;
18993 }
18994 return resultobj;
18995 fail:
18996 {
18997 if (temp2)
18998 delete arg2;
18999 }
19000 return NULL;
19001 }
19002
19003
19004 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19005 PyObject *resultobj = 0;
19006 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19007 wxString result;
19008 void *argp1 = 0 ;
19009 int res1 = 0 ;
19010 PyObject *swig_obj[1] ;
19011
19012 if (!args) SWIG_fail;
19013 swig_obj[0] = args;
19014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19015 if (!SWIG_IsOK(res1)) {
19016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19017 }
19018 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 result = ((wxCommandEvent const *)arg1)->GetString();
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 {
19026 #if wxUSE_UNICODE
19027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19028 #else
19029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19030 #endif
19031 }
19032 return resultobj;
19033 fail:
19034 return NULL;
19035 }
19036
19037
19038 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19039 PyObject *resultobj = 0;
19040 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19041 bool result;
19042 void *argp1 = 0 ;
19043 int res1 = 0 ;
19044 PyObject *swig_obj[1] ;
19045
19046 if (!args) SWIG_fail;
19047 swig_obj[0] = args;
19048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19049 if (!SWIG_IsOK(res1)) {
19050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19051 }
19052 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19053 {
19054 PyThreadState* __tstate = wxPyBeginAllowThreads();
19055 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19056 wxPyEndAllowThreads(__tstate);
19057 if (PyErr_Occurred()) SWIG_fail;
19058 }
19059 {
19060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19061 }
19062 return resultobj;
19063 fail:
19064 return NULL;
19065 }
19066
19067
19068 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19069 PyObject *resultobj = 0;
19070 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19071 bool result;
19072 void *argp1 = 0 ;
19073 int res1 = 0 ;
19074 PyObject *swig_obj[1] ;
19075
19076 if (!args) SWIG_fail;
19077 swig_obj[0] = args;
19078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19079 if (!SWIG_IsOK(res1)) {
19080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19081 }
19082 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19083 {
19084 PyThreadState* __tstate = wxPyBeginAllowThreads();
19085 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19086 wxPyEndAllowThreads(__tstate);
19087 if (PyErr_Occurred()) SWIG_fail;
19088 }
19089 {
19090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19091 }
19092 return resultobj;
19093 fail:
19094 return NULL;
19095 }
19096
19097
19098 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19099 PyObject *resultobj = 0;
19100 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19101 long arg2 ;
19102 void *argp1 = 0 ;
19103 int res1 = 0 ;
19104 long val2 ;
19105 int ecode2 = 0 ;
19106 PyObject * obj0 = 0 ;
19107 PyObject * obj1 = 0 ;
19108 char * kwnames[] = {
19109 (char *) "self",(char *) "extraLong", NULL
19110 };
19111
19112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19114 if (!SWIG_IsOK(res1)) {
19115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19116 }
19117 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19118 ecode2 = SWIG_AsVal_long(obj1, &val2);
19119 if (!SWIG_IsOK(ecode2)) {
19120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19121 }
19122 arg2 = static_cast< long >(val2);
19123 {
19124 PyThreadState* __tstate = wxPyBeginAllowThreads();
19125 (arg1)->SetExtraLong(arg2);
19126 wxPyEndAllowThreads(__tstate);
19127 if (PyErr_Occurred()) SWIG_fail;
19128 }
19129 resultobj = SWIG_Py_Void();
19130 return resultobj;
19131 fail:
19132 return NULL;
19133 }
19134
19135
19136 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19137 PyObject *resultobj = 0;
19138 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19139 long result;
19140 void *argp1 = 0 ;
19141 int res1 = 0 ;
19142 PyObject *swig_obj[1] ;
19143
19144 if (!args) SWIG_fail;
19145 swig_obj[0] = args;
19146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19147 if (!SWIG_IsOK(res1)) {
19148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19149 }
19150 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19151 {
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19154 wxPyEndAllowThreads(__tstate);
19155 if (PyErr_Occurred()) SWIG_fail;
19156 }
19157 resultobj = SWIG_From_long(static_cast< long >(result));
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19165 PyObject *resultobj = 0;
19166 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19167 int arg2 ;
19168 void *argp1 = 0 ;
19169 int res1 = 0 ;
19170 int val2 ;
19171 int ecode2 = 0 ;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 char * kwnames[] = {
19175 (char *) "self",(char *) "i", NULL
19176 };
19177
19178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19180 if (!SWIG_IsOK(res1)) {
19181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19182 }
19183 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19184 ecode2 = SWIG_AsVal_int(obj1, &val2);
19185 if (!SWIG_IsOK(ecode2)) {
19186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19187 }
19188 arg2 = static_cast< int >(val2);
19189 {
19190 PyThreadState* __tstate = wxPyBeginAllowThreads();
19191 (arg1)->SetInt(arg2);
19192 wxPyEndAllowThreads(__tstate);
19193 if (PyErr_Occurred()) SWIG_fail;
19194 }
19195 resultobj = SWIG_Py_Void();
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19203 PyObject *resultobj = 0;
19204 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19205 int result;
19206 void *argp1 = 0 ;
19207 int res1 = 0 ;
19208 PyObject *swig_obj[1] ;
19209
19210 if (!args) SWIG_fail;
19211 swig_obj[0] = args;
19212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19213 if (!SWIG_IsOK(res1)) {
19214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19215 }
19216 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19217 {
19218 PyThreadState* __tstate = wxPyBeginAllowThreads();
19219 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 resultobj = SWIG_From_int(static_cast< int >(result));
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19231 PyObject *resultobj = 0;
19232 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19233 PyObject *result = 0 ;
19234 void *argp1 = 0 ;
19235 int res1 = 0 ;
19236 PyObject *swig_obj[1] ;
19237
19238 if (!args) SWIG_fail;
19239 swig_obj[0] = args;
19240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19241 if (!SWIG_IsOK(res1)) {
19242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19243 }
19244 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19245 {
19246 PyThreadState* __tstate = wxPyBeginAllowThreads();
19247 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19248 wxPyEndAllowThreads(__tstate);
19249 if (PyErr_Occurred()) SWIG_fail;
19250 }
19251 resultobj = result;
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj = 0;
19260 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19261 PyObject *arg2 = (PyObject *) 0 ;
19262 void *argp1 = 0 ;
19263 int res1 = 0 ;
19264 PyObject * obj0 = 0 ;
19265 PyObject * obj1 = 0 ;
19266 char * kwnames[] = {
19267 (char *) "self",(char *) "clientData", NULL
19268 };
19269
19270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19272 if (!SWIG_IsOK(res1)) {
19273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19274 }
19275 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19276 arg2 = obj1;
19277 {
19278 PyThreadState* __tstate = wxPyBeginAllowThreads();
19279 wxCommandEvent_SetClientData(arg1,arg2);
19280 wxPyEndAllowThreads(__tstate);
19281 if (PyErr_Occurred()) SWIG_fail;
19282 }
19283 resultobj = SWIG_Py_Void();
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19291 PyObject *resultobj = 0;
19292 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19293 wxEvent *result = 0 ;
19294 void *argp1 = 0 ;
19295 int res1 = 0 ;
19296 PyObject *swig_obj[1] ;
19297
19298 if (!args) SWIG_fail;
19299 swig_obj[0] = args;
19300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19301 if (!SWIG_IsOK(res1)) {
19302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19303 }
19304 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19305 {
19306 PyThreadState* __tstate = wxPyBeginAllowThreads();
19307 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19308 wxPyEndAllowThreads(__tstate);
19309 if (PyErr_Occurred()) SWIG_fail;
19310 }
19311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19312 return resultobj;
19313 fail:
19314 return NULL;
19315 }
19316
19317
19318 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19319 PyObject *obj;
19320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19321 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19322 return SWIG_Py_Void();
19323 }
19324
19325 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19326 return SWIG_Python_InitShadowInstance(args);
19327 }
19328
19329 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19330 PyObject *resultobj = 0;
19331 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19332 int arg2 = (int) 0 ;
19333 wxNotifyEvent *result = 0 ;
19334 int val1 ;
19335 int ecode1 = 0 ;
19336 int val2 ;
19337 int ecode2 = 0 ;
19338 PyObject * obj0 = 0 ;
19339 PyObject * obj1 = 0 ;
19340 char * kwnames[] = {
19341 (char *) "commandType",(char *) "winid", NULL
19342 };
19343
19344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19345 if (obj0) {
19346 ecode1 = SWIG_AsVal_int(obj0, &val1);
19347 if (!SWIG_IsOK(ecode1)) {
19348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19349 }
19350 arg1 = static_cast< wxEventType >(val1);
19351 }
19352 if (obj1) {
19353 ecode2 = SWIG_AsVal_int(obj1, &val2);
19354 if (!SWIG_IsOK(ecode2)) {
19355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19356 }
19357 arg2 = static_cast< int >(val2);
19358 }
19359 {
19360 PyThreadState* __tstate = wxPyBeginAllowThreads();
19361 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19362 wxPyEndAllowThreads(__tstate);
19363 if (PyErr_Occurred()) SWIG_fail;
19364 }
19365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19366 return resultobj;
19367 fail:
19368 return NULL;
19369 }
19370
19371
19372 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19373 PyObject *resultobj = 0;
19374 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19375 void *argp1 = 0 ;
19376 int res1 = 0 ;
19377 PyObject *swig_obj[1] ;
19378
19379 if (!args) SWIG_fail;
19380 swig_obj[0] = args;
19381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19382 if (!SWIG_IsOK(res1)) {
19383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19384 }
19385 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 (arg1)->Veto();
19389 wxPyEndAllowThreads(__tstate);
19390 if (PyErr_Occurred()) SWIG_fail;
19391 }
19392 resultobj = SWIG_Py_Void();
19393 return resultobj;
19394 fail:
19395 return NULL;
19396 }
19397
19398
19399 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19400 PyObject *resultobj = 0;
19401 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19402 void *argp1 = 0 ;
19403 int res1 = 0 ;
19404 PyObject *swig_obj[1] ;
19405
19406 if (!args) SWIG_fail;
19407 swig_obj[0] = args;
19408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19409 if (!SWIG_IsOK(res1)) {
19410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19411 }
19412 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19413 {
19414 PyThreadState* __tstate = wxPyBeginAllowThreads();
19415 (arg1)->Allow();
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 resultobj = SWIG_Py_Void();
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19427 PyObject *resultobj = 0;
19428 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19429 bool result;
19430 void *argp1 = 0 ;
19431 int res1 = 0 ;
19432 PyObject *swig_obj[1] ;
19433
19434 if (!args) SWIG_fail;
19435 swig_obj[0] = args;
19436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19437 if (!SWIG_IsOK(res1)) {
19438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19439 }
19440 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (bool)(arg1)->IsAllowed();
19444 wxPyEndAllowThreads(__tstate);
19445 if (PyErr_Occurred()) SWIG_fail;
19446 }
19447 {
19448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19449 }
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 SWIGINTERN PyObject *NotifyEvent_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_wxNotifyEvent, SWIG_NewClientData(obj));
19460 return SWIG_Py_Void();
19461 }
19462
19463 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19464 return SWIG_Python_InitShadowInstance(args);
19465 }
19466
19467 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj = 0;
19469 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19470 int arg2 = (int) 0 ;
19471 int arg3 = (int) 0 ;
19472 int arg4 = (int) 0 ;
19473 wxScrollEvent *result = 0 ;
19474 int val1 ;
19475 int ecode1 = 0 ;
19476 int val2 ;
19477 int ecode2 = 0 ;
19478 int val3 ;
19479 int ecode3 = 0 ;
19480 int val4 ;
19481 int ecode4 = 0 ;
19482 PyObject * obj0 = 0 ;
19483 PyObject * obj1 = 0 ;
19484 PyObject * obj2 = 0 ;
19485 PyObject * obj3 = 0 ;
19486 char * kwnames[] = {
19487 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19488 };
19489
19490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19491 if (obj0) {
19492 ecode1 = SWIG_AsVal_int(obj0, &val1);
19493 if (!SWIG_IsOK(ecode1)) {
19494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19495 }
19496 arg1 = static_cast< wxEventType >(val1);
19497 }
19498 if (obj1) {
19499 ecode2 = SWIG_AsVal_int(obj1, &val2);
19500 if (!SWIG_IsOK(ecode2)) {
19501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19502 }
19503 arg2 = static_cast< int >(val2);
19504 }
19505 if (obj2) {
19506 ecode3 = SWIG_AsVal_int(obj2, &val3);
19507 if (!SWIG_IsOK(ecode3)) {
19508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19509 }
19510 arg3 = static_cast< int >(val3);
19511 }
19512 if (obj3) {
19513 ecode4 = SWIG_AsVal_int(obj3, &val4);
19514 if (!SWIG_IsOK(ecode4)) {
19515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19516 }
19517 arg4 = static_cast< int >(val4);
19518 }
19519 {
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19522 wxPyEndAllowThreads(__tstate);
19523 if (PyErr_Occurred()) SWIG_fail;
19524 }
19525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19526 return resultobj;
19527 fail:
19528 return NULL;
19529 }
19530
19531
19532 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19533 PyObject *resultobj = 0;
19534 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19535 int result;
19536 void *argp1 = 0 ;
19537 int res1 = 0 ;
19538 PyObject *swig_obj[1] ;
19539
19540 if (!args) SWIG_fail;
19541 swig_obj[0] = args;
19542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19543 if (!SWIG_IsOK(res1)) {
19544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19545 }
19546 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = SWIG_From_int(static_cast< int >(result));
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19561 PyObject *resultobj = 0;
19562 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19563 int result;
19564 void *argp1 = 0 ;
19565 int res1 = 0 ;
19566 PyObject *swig_obj[1] ;
19567
19568 if (!args) SWIG_fail;
19569 swig_obj[0] = args;
19570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19571 if (!SWIG_IsOK(res1)) {
19572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19573 }
19574 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19575 {
19576 PyThreadState* __tstate = wxPyBeginAllowThreads();
19577 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19578 wxPyEndAllowThreads(__tstate);
19579 if (PyErr_Occurred()) SWIG_fail;
19580 }
19581 resultobj = SWIG_From_int(static_cast< int >(result));
19582 return resultobj;
19583 fail:
19584 return NULL;
19585 }
19586
19587
19588 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19589 PyObject *resultobj = 0;
19590 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19591 int arg2 ;
19592 void *argp1 = 0 ;
19593 int res1 = 0 ;
19594 int val2 ;
19595 int ecode2 = 0 ;
19596 PyObject * obj0 = 0 ;
19597 PyObject * obj1 = 0 ;
19598 char * kwnames[] = {
19599 (char *) "self",(char *) "orient", NULL
19600 };
19601
19602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19604 if (!SWIG_IsOK(res1)) {
19605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19606 }
19607 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19608 ecode2 = SWIG_AsVal_int(obj1, &val2);
19609 if (!SWIG_IsOK(ecode2)) {
19610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19611 }
19612 arg2 = static_cast< int >(val2);
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 (arg1)->SetOrientation(arg2);
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_Py_Void();
19620 return resultobj;
19621 fail:
19622 return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19627 PyObject *resultobj = 0;
19628 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19629 int arg2 ;
19630 void *argp1 = 0 ;
19631 int res1 = 0 ;
19632 int val2 ;
19633 int ecode2 = 0 ;
19634 PyObject * obj0 = 0 ;
19635 PyObject * obj1 = 0 ;
19636 char * kwnames[] = {
19637 (char *) "self",(char *) "pos", NULL
19638 };
19639
19640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19642 if (!SWIG_IsOK(res1)) {
19643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19644 }
19645 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19646 ecode2 = SWIG_AsVal_int(obj1, &val2);
19647 if (!SWIG_IsOK(ecode2)) {
19648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19649 }
19650 arg2 = static_cast< int >(val2);
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 (arg1)->SetPosition(arg2);
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 resultobj = SWIG_Py_Void();
19658 return resultobj;
19659 fail:
19660 return NULL;
19661 }
19662
19663
19664 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19665 PyObject *obj;
19666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19667 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19668 return SWIG_Py_Void();
19669 }
19670
19671 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19672 return SWIG_Python_InitShadowInstance(args);
19673 }
19674
19675 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19676 PyObject *resultobj = 0;
19677 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19678 int arg2 = (int) 0 ;
19679 int arg3 = (int) 0 ;
19680 wxScrollWinEvent *result = 0 ;
19681 int val1 ;
19682 int ecode1 = 0 ;
19683 int val2 ;
19684 int ecode2 = 0 ;
19685 int val3 ;
19686 int ecode3 = 0 ;
19687 PyObject * obj0 = 0 ;
19688 PyObject * obj1 = 0 ;
19689 PyObject * obj2 = 0 ;
19690 char * kwnames[] = {
19691 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19692 };
19693
19694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19695 if (obj0) {
19696 ecode1 = SWIG_AsVal_int(obj0, &val1);
19697 if (!SWIG_IsOK(ecode1)) {
19698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19699 }
19700 arg1 = static_cast< wxEventType >(val1);
19701 }
19702 if (obj1) {
19703 ecode2 = SWIG_AsVal_int(obj1, &val2);
19704 if (!SWIG_IsOK(ecode2)) {
19705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19706 }
19707 arg2 = static_cast< int >(val2);
19708 }
19709 if (obj2) {
19710 ecode3 = SWIG_AsVal_int(obj2, &val3);
19711 if (!SWIG_IsOK(ecode3)) {
19712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19713 }
19714 arg3 = static_cast< int >(val3);
19715 }
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19719 wxPyEndAllowThreads(__tstate);
19720 if (PyErr_Occurred()) SWIG_fail;
19721 }
19722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19723 return resultobj;
19724 fail:
19725 return NULL;
19726 }
19727
19728
19729 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19730 PyObject *resultobj = 0;
19731 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19732 int result;
19733 void *argp1 = 0 ;
19734 int res1 = 0 ;
19735 PyObject *swig_obj[1] ;
19736
19737 if (!args) SWIG_fail;
19738 swig_obj[0] = args;
19739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19740 if (!SWIG_IsOK(res1)) {
19741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19742 }
19743 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 resultobj = SWIG_From_int(static_cast< int >(result));
19751 return resultobj;
19752 fail:
19753 return NULL;
19754 }
19755
19756
19757 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19758 PyObject *resultobj = 0;
19759 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19760 int result;
19761 void *argp1 = 0 ;
19762 int res1 = 0 ;
19763 PyObject *swig_obj[1] ;
19764
19765 if (!args) SWIG_fail;
19766 swig_obj[0] = args;
19767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19768 if (!SWIG_IsOK(res1)) {
19769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19770 }
19771 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19772 {
19773 PyThreadState* __tstate = wxPyBeginAllowThreads();
19774 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19775 wxPyEndAllowThreads(__tstate);
19776 if (PyErr_Occurred()) SWIG_fail;
19777 }
19778 resultobj = SWIG_From_int(static_cast< int >(result));
19779 return resultobj;
19780 fail:
19781 return NULL;
19782 }
19783
19784
19785 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19786 PyObject *resultobj = 0;
19787 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19788 int arg2 ;
19789 void *argp1 = 0 ;
19790 int res1 = 0 ;
19791 int val2 ;
19792 int ecode2 = 0 ;
19793 PyObject * obj0 = 0 ;
19794 PyObject * obj1 = 0 ;
19795 char * kwnames[] = {
19796 (char *) "self",(char *) "orient", NULL
19797 };
19798
19799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19801 if (!SWIG_IsOK(res1)) {
19802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19803 }
19804 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19805 ecode2 = SWIG_AsVal_int(obj1, &val2);
19806 if (!SWIG_IsOK(ecode2)) {
19807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19808 }
19809 arg2 = static_cast< int >(val2);
19810 {
19811 PyThreadState* __tstate = wxPyBeginAllowThreads();
19812 (arg1)->SetOrientation(arg2);
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 resultobj = SWIG_Py_Void();
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj = 0;
19825 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19826 int arg2 ;
19827 void *argp1 = 0 ;
19828 int res1 = 0 ;
19829 int val2 ;
19830 int ecode2 = 0 ;
19831 PyObject * obj0 = 0 ;
19832 PyObject * obj1 = 0 ;
19833 char * kwnames[] = {
19834 (char *) "self",(char *) "pos", NULL
19835 };
19836
19837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19839 if (!SWIG_IsOK(res1)) {
19840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19841 }
19842 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19843 ecode2 = SWIG_AsVal_int(obj1, &val2);
19844 if (!SWIG_IsOK(ecode2)) {
19845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19846 }
19847 arg2 = static_cast< int >(val2);
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 (arg1)->SetPosition(arg2);
19851 wxPyEndAllowThreads(__tstate);
19852 if (PyErr_Occurred()) SWIG_fail;
19853 }
19854 resultobj = SWIG_Py_Void();
19855 return resultobj;
19856 fail:
19857 return NULL;
19858 }
19859
19860
19861 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19862 PyObject *obj;
19863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19864 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19865 return SWIG_Py_Void();
19866 }
19867
19868 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19869 return SWIG_Python_InitShadowInstance(args);
19870 }
19871
19872 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj = 0;
19874 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19875 wxMouseEvent *result = 0 ;
19876 int val1 ;
19877 int ecode1 = 0 ;
19878 PyObject * obj0 = 0 ;
19879 char * kwnames[] = {
19880 (char *) "mouseType", NULL
19881 };
19882
19883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19884 if (obj0) {
19885 ecode1 = SWIG_AsVal_int(obj0, &val1);
19886 if (!SWIG_IsOK(ecode1)) {
19887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19888 }
19889 arg1 = static_cast< wxEventType >(val1);
19890 }
19891 {
19892 PyThreadState* __tstate = wxPyBeginAllowThreads();
19893 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19894 wxPyEndAllowThreads(__tstate);
19895 if (PyErr_Occurred()) SWIG_fail;
19896 }
19897 {
19898 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19899 }
19900 return resultobj;
19901 fail:
19902 return NULL;
19903 }
19904
19905
19906 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19907 PyObject *resultobj = 0;
19908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19909 bool result;
19910 void *argp1 = 0 ;
19911 int res1 = 0 ;
19912 PyObject *swig_obj[1] ;
19913
19914 if (!args) SWIG_fail;
19915 swig_obj[0] = args;
19916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19917 if (!SWIG_IsOK(res1)) {
19918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19919 }
19920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19921 {
19922 PyThreadState* __tstate = wxPyBeginAllowThreads();
19923 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19924 wxPyEndAllowThreads(__tstate);
19925 if (PyErr_Occurred()) SWIG_fail;
19926 }
19927 {
19928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19929 }
19930 return resultobj;
19931 fail:
19932 return NULL;
19933 }
19934
19935
19936 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19937 PyObject *resultobj = 0;
19938 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19939 int arg2 = (int) wxMOUSE_BTN_ANY ;
19940 bool result;
19941 void *argp1 = 0 ;
19942 int res1 = 0 ;
19943 int val2 ;
19944 int ecode2 = 0 ;
19945 PyObject * obj0 = 0 ;
19946 PyObject * obj1 = 0 ;
19947 char * kwnames[] = {
19948 (char *) "self",(char *) "but", NULL
19949 };
19950
19951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19953 if (!SWIG_IsOK(res1)) {
19954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19955 }
19956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19957 if (obj1) {
19958 ecode2 = SWIG_AsVal_int(obj1, &val2);
19959 if (!SWIG_IsOK(ecode2)) {
19960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19961 }
19962 arg2 = static_cast< int >(val2);
19963 }
19964 {
19965 PyThreadState* __tstate = wxPyBeginAllowThreads();
19966 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19967 wxPyEndAllowThreads(__tstate);
19968 if (PyErr_Occurred()) SWIG_fail;
19969 }
19970 {
19971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19972 }
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19980 PyObject *resultobj = 0;
19981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19982 int arg2 = (int) wxMOUSE_BTN_ANY ;
19983 bool result;
19984 void *argp1 = 0 ;
19985 int res1 = 0 ;
19986 int val2 ;
19987 int ecode2 = 0 ;
19988 PyObject * obj0 = 0 ;
19989 PyObject * obj1 = 0 ;
19990 char * kwnames[] = {
19991 (char *) "self",(char *) "but", NULL
19992 };
19993
19994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19996 if (!SWIG_IsOK(res1)) {
19997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19998 }
19999 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20000 if (obj1) {
20001 ecode2 = SWIG_AsVal_int(obj1, &val2);
20002 if (!SWIG_IsOK(ecode2)) {
20003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20004 }
20005 arg2 = static_cast< int >(val2);
20006 }
20007 {
20008 PyThreadState* __tstate = wxPyBeginAllowThreads();
20009 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 {
20014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20015 }
20016 return resultobj;
20017 fail:
20018 return NULL;
20019 }
20020
20021
20022 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20023 PyObject *resultobj = 0;
20024 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20025 int arg2 = (int) wxMOUSE_BTN_ANY ;
20026 bool result;
20027 void *argp1 = 0 ;
20028 int res1 = 0 ;
20029 int val2 ;
20030 int ecode2 = 0 ;
20031 PyObject * obj0 = 0 ;
20032 PyObject * obj1 = 0 ;
20033 char * kwnames[] = {
20034 (char *) "self",(char *) "but", NULL
20035 };
20036
20037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20039 if (!SWIG_IsOK(res1)) {
20040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20041 }
20042 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20043 if (obj1) {
20044 ecode2 = SWIG_AsVal_int(obj1, &val2);
20045 if (!SWIG_IsOK(ecode2)) {
20046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20047 }
20048 arg2 = static_cast< int >(val2);
20049 }
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20053 wxPyEndAllowThreads(__tstate);
20054 if (PyErr_Occurred()) SWIG_fail;
20055 }
20056 {
20057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20058 }
20059 return resultobj;
20060 fail:
20061 return NULL;
20062 }
20063
20064
20065 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20066 PyObject *resultobj = 0;
20067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20068 int arg2 ;
20069 bool result;
20070 void *argp1 = 0 ;
20071 int res1 = 0 ;
20072 int val2 ;
20073 int ecode2 = 0 ;
20074 PyObject * obj0 = 0 ;
20075 PyObject * obj1 = 0 ;
20076 char * kwnames[] = {
20077 (char *) "self",(char *) "button", NULL
20078 };
20079
20080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20082 if (!SWIG_IsOK(res1)) {
20083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20084 }
20085 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20086 ecode2 = SWIG_AsVal_int(obj1, &val2);
20087 if (!SWIG_IsOK(ecode2)) {
20088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20089 }
20090 arg2 = static_cast< int >(val2);
20091 {
20092 PyThreadState* __tstate = wxPyBeginAllowThreads();
20093 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20094 wxPyEndAllowThreads(__tstate);
20095 if (PyErr_Occurred()) SWIG_fail;
20096 }
20097 {
20098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20099 }
20100 return resultobj;
20101 fail:
20102 return NULL;
20103 }
20104
20105
20106 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20107 PyObject *resultobj = 0;
20108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20109 int arg2 ;
20110 bool result;
20111 void *argp1 = 0 ;
20112 int res1 = 0 ;
20113 int val2 ;
20114 int ecode2 = 0 ;
20115 PyObject * obj0 = 0 ;
20116 PyObject * obj1 = 0 ;
20117 char * kwnames[] = {
20118 (char *) "self",(char *) "but", NULL
20119 };
20120
20121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20123 if (!SWIG_IsOK(res1)) {
20124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20125 }
20126 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20127 ecode2 = SWIG_AsVal_int(obj1, &val2);
20128 if (!SWIG_IsOK(ecode2)) {
20129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20130 }
20131 arg2 = static_cast< int >(val2);
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 {
20139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20140 }
20141 return resultobj;
20142 fail:
20143 return NULL;
20144 }
20145
20146
20147 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20148 PyObject *resultobj = 0;
20149 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20150 int result;
20151 void *argp1 = 0 ;
20152 int res1 = 0 ;
20153 PyObject *swig_obj[1] ;
20154
20155 if (!args) SWIG_fail;
20156 swig_obj[0] = args;
20157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20158 if (!SWIG_IsOK(res1)) {
20159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20160 }
20161 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20165 wxPyEndAllowThreads(__tstate);
20166 if (PyErr_Occurred()) SWIG_fail;
20167 }
20168 resultobj = SWIG_From_int(static_cast< int >(result));
20169 return resultobj;
20170 fail:
20171 return NULL;
20172 }
20173
20174
20175 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20176 PyObject *resultobj = 0;
20177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20178 bool result;
20179 void *argp1 = 0 ;
20180 int res1 = 0 ;
20181 PyObject *swig_obj[1] ;
20182
20183 if (!args) SWIG_fail;
20184 swig_obj[0] = args;
20185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20186 if (!SWIG_IsOK(res1)) {
20187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20188 }
20189 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20190 {
20191 PyThreadState* __tstate = wxPyBeginAllowThreads();
20192 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 {
20197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20198 }
20199 return resultobj;
20200 fail:
20201 return NULL;
20202 }
20203
20204
20205 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20206 PyObject *resultobj = 0;
20207 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20208 bool result;
20209 void *argp1 = 0 ;
20210 int res1 = 0 ;
20211 PyObject *swig_obj[1] ;
20212
20213 if (!args) SWIG_fail;
20214 swig_obj[0] = args;
20215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20216 if (!SWIG_IsOK(res1)) {
20217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20218 }
20219 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20220 {
20221 PyThreadState* __tstate = wxPyBeginAllowThreads();
20222 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 {
20227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20228 }
20229 return resultobj;
20230 fail:
20231 return NULL;
20232 }
20233
20234
20235 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20236 PyObject *resultobj = 0;
20237 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20238 bool result;
20239 void *argp1 = 0 ;
20240 int res1 = 0 ;
20241 PyObject *swig_obj[1] ;
20242
20243 if (!args) SWIG_fail;
20244 swig_obj[0] = args;
20245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20246 if (!SWIG_IsOK(res1)) {
20247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20248 }
20249 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20253 wxPyEndAllowThreads(__tstate);
20254 if (PyErr_Occurred()) SWIG_fail;
20255 }
20256 {
20257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20258 }
20259 return resultobj;
20260 fail:
20261 return NULL;
20262 }
20263
20264
20265 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20266 PyObject *resultobj = 0;
20267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20268 bool result;
20269 void *argp1 = 0 ;
20270 int res1 = 0 ;
20271 PyObject *swig_obj[1] ;
20272
20273 if (!args) SWIG_fail;
20274 swig_obj[0] = args;
20275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20276 if (!SWIG_IsOK(res1)) {
20277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20278 }
20279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20280 {
20281 PyThreadState* __tstate = wxPyBeginAllowThreads();
20282 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20283 wxPyEndAllowThreads(__tstate);
20284 if (PyErr_Occurred()) SWIG_fail;
20285 }
20286 {
20287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20288 }
20289 return resultobj;
20290 fail:
20291 return NULL;
20292 }
20293
20294
20295 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20296 PyObject *resultobj = 0;
20297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20298 bool result;
20299 void *argp1 = 0 ;
20300 int res1 = 0 ;
20301 PyObject *swig_obj[1] ;
20302
20303 if (!args) SWIG_fail;
20304 swig_obj[0] = args;
20305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20306 if (!SWIG_IsOK(res1)) {
20307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20308 }
20309 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20310 {
20311 PyThreadState* __tstate = wxPyBeginAllowThreads();
20312 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 {
20317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20318 }
20319 return resultobj;
20320 fail:
20321 return NULL;
20322 }
20323
20324
20325 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20326 PyObject *resultobj = 0;
20327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20328 bool result;
20329 void *argp1 = 0 ;
20330 int res1 = 0 ;
20331 PyObject *swig_obj[1] ;
20332
20333 if (!args) SWIG_fail;
20334 swig_obj[0] = args;
20335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20336 if (!SWIG_IsOK(res1)) {
20337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20338 }
20339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20340 {
20341 PyThreadState* __tstate = wxPyBeginAllowThreads();
20342 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20343 wxPyEndAllowThreads(__tstate);
20344 if (PyErr_Occurred()) SWIG_fail;
20345 }
20346 {
20347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20348 }
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20356 PyObject *resultobj = 0;
20357 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20358 bool result;
20359 void *argp1 = 0 ;
20360 int res1 = 0 ;
20361 PyObject *swig_obj[1] ;
20362
20363 if (!args) SWIG_fail;
20364 swig_obj[0] = args;
20365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20366 if (!SWIG_IsOK(res1)) {
20367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20368 }
20369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20373 wxPyEndAllowThreads(__tstate);
20374 if (PyErr_Occurred()) SWIG_fail;
20375 }
20376 {
20377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20378 }
20379 return resultobj;
20380 fail:
20381 return NULL;
20382 }
20383
20384
20385 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 PyObject *resultobj = 0;
20387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20388 bool result;
20389 void *argp1 = 0 ;
20390 int res1 = 0 ;
20391 PyObject *swig_obj[1] ;
20392
20393 if (!args) SWIG_fail;
20394 swig_obj[0] = args;
20395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20396 if (!SWIG_IsOK(res1)) {
20397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20398 }
20399 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20400 {
20401 PyThreadState* __tstate = wxPyBeginAllowThreads();
20402 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 {
20407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20408 }
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20416 PyObject *resultobj = 0;
20417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20418 bool result;
20419 void *argp1 = 0 ;
20420 int res1 = 0 ;
20421 PyObject *swig_obj[1] ;
20422
20423 if (!args) SWIG_fail;
20424 swig_obj[0] = args;
20425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20426 if (!SWIG_IsOK(res1)) {
20427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20428 }
20429 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 {
20437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20438 }
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20448 bool result;
20449 void *argp1 = 0 ;
20450 int res1 = 0 ;
20451 PyObject *swig_obj[1] ;
20452
20453 if (!args) SWIG_fail;
20454 swig_obj[0] = args;
20455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20456 if (!SWIG_IsOK(res1)) {
20457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20458 }
20459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20460 {
20461 PyThreadState* __tstate = wxPyBeginAllowThreads();
20462 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 {
20467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20468 }
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20476 PyObject *resultobj = 0;
20477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20478 bool result;
20479 void *argp1 = 0 ;
20480 int res1 = 0 ;
20481 PyObject *swig_obj[1] ;
20482
20483 if (!args) SWIG_fail;
20484 swig_obj[0] = args;
20485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20486 if (!SWIG_IsOK(res1)) {
20487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20488 }
20489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20490 {
20491 PyThreadState* __tstate = wxPyBeginAllowThreads();
20492 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 {
20497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20498 }
20499 return resultobj;
20500 fail:
20501 return NULL;
20502 }
20503
20504
20505 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20506 PyObject *resultobj = 0;
20507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20508 bool result;
20509 void *argp1 = 0 ;
20510 int res1 = 0 ;
20511 PyObject *swig_obj[1] ;
20512
20513 if (!args) SWIG_fail;
20514 swig_obj[0] = args;
20515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20516 if (!SWIG_IsOK(res1)) {
20517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20518 }
20519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20520 {
20521 PyThreadState* __tstate = wxPyBeginAllowThreads();
20522 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 {
20527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20528 }
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20536 PyObject *resultobj = 0;
20537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20538 bool result;
20539 void *argp1 = 0 ;
20540 int res1 = 0 ;
20541 PyObject *swig_obj[1] ;
20542
20543 if (!args) SWIG_fail;
20544 swig_obj[0] = args;
20545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20546 if (!SWIG_IsOK(res1)) {
20547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20548 }
20549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20550 {
20551 PyThreadState* __tstate = wxPyBeginAllowThreads();
20552 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 {
20557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20558 }
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20566 PyObject *resultobj = 0;
20567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20568 bool result;
20569 void *argp1 = 0 ;
20570 int res1 = 0 ;
20571 PyObject *swig_obj[1] ;
20572
20573 if (!args) SWIG_fail;
20574 swig_obj[0] = args;
20575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20576 if (!SWIG_IsOK(res1)) {
20577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20578 }
20579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20588 }
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20596 PyObject *resultobj = 0;
20597 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20598 bool result;
20599 void *argp1 = 0 ;
20600 int res1 = 0 ;
20601 PyObject *swig_obj[1] ;
20602
20603 if (!args) SWIG_fail;
20604 swig_obj[0] = args;
20605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20608 }
20609 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = (bool)(arg1)->LeftIsDown();
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 {
20617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20618 }
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20626 PyObject *resultobj = 0;
20627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20628 bool result;
20629 void *argp1 = 0 ;
20630 int res1 = 0 ;
20631 PyObject *swig_obj[1] ;
20632
20633 if (!args) SWIG_fail;
20634 swig_obj[0] = args;
20635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20636 if (!SWIG_IsOK(res1)) {
20637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20638 }
20639 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 result = (bool)(arg1)->MiddleIsDown();
20643 wxPyEndAllowThreads(__tstate);
20644 if (PyErr_Occurred()) SWIG_fail;
20645 }
20646 {
20647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20648 }
20649 return resultobj;
20650 fail:
20651 return NULL;
20652 }
20653
20654
20655 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20656 PyObject *resultobj = 0;
20657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20658 bool result;
20659 void *argp1 = 0 ;
20660 int res1 = 0 ;
20661 PyObject *swig_obj[1] ;
20662
20663 if (!args) SWIG_fail;
20664 swig_obj[0] = args;
20665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20666 if (!SWIG_IsOK(res1)) {
20667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20668 }
20669 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20670 {
20671 PyThreadState* __tstate = wxPyBeginAllowThreads();
20672 result = (bool)(arg1)->RightIsDown();
20673 wxPyEndAllowThreads(__tstate);
20674 if (PyErr_Occurred()) SWIG_fail;
20675 }
20676 {
20677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20678 }
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20686 PyObject *resultobj = 0;
20687 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20688 bool result;
20689 void *argp1 = 0 ;
20690 int res1 = 0 ;
20691 PyObject *swig_obj[1] ;
20692
20693 if (!args) SWIG_fail;
20694 swig_obj[0] = args;
20695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20696 if (!SWIG_IsOK(res1)) {
20697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20698 }
20699 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20703 wxPyEndAllowThreads(__tstate);
20704 if (PyErr_Occurred()) SWIG_fail;
20705 }
20706 {
20707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20708 }
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20716 PyObject *resultobj = 0;
20717 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20718 bool result;
20719 void *argp1 = 0 ;
20720 int res1 = 0 ;
20721 PyObject *swig_obj[1] ;
20722
20723 if (!args) SWIG_fail;
20724 swig_obj[0] = args;
20725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20726 if (!SWIG_IsOK(res1)) {
20727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20728 }
20729 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 {
20737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20738 }
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20746 PyObject *resultobj = 0;
20747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20748 bool result;
20749 void *argp1 = 0 ;
20750 int res1 = 0 ;
20751 PyObject *swig_obj[1] ;
20752
20753 if (!args) SWIG_fail;
20754 swig_obj[0] = args;
20755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20756 if (!SWIG_IsOK(res1)) {
20757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20758 }
20759 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 {
20767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20768 }
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20776 PyObject *resultobj = 0;
20777 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20778 bool result;
20779 void *argp1 = 0 ;
20780 int res1 = 0 ;
20781 PyObject *swig_obj[1] ;
20782
20783 if (!args) SWIG_fail;
20784 swig_obj[0] = args;
20785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20786 if (!SWIG_IsOK(res1)) {
20787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20788 }
20789 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20790 {
20791 PyThreadState* __tstate = wxPyBeginAllowThreads();
20792 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20793 wxPyEndAllowThreads(__tstate);
20794 if (PyErr_Occurred()) SWIG_fail;
20795 }
20796 {
20797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20798 }
20799 return resultobj;
20800 fail:
20801 return NULL;
20802 }
20803
20804
20805 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20806 PyObject *resultobj = 0;
20807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20808 wxPoint result;
20809 void *argp1 = 0 ;
20810 int res1 = 0 ;
20811 PyObject *swig_obj[1] ;
20812
20813 if (!args) SWIG_fail;
20814 swig_obj[0] = args;
20815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20816 if (!SWIG_IsOK(res1)) {
20817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20818 }
20819 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = (arg1)->GetPosition();
20823 wxPyEndAllowThreads(__tstate);
20824 if (PyErr_Occurred()) SWIG_fail;
20825 }
20826 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20827 return resultobj;
20828 fail:
20829 return NULL;
20830 }
20831
20832
20833 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20834 PyObject *resultobj = 0;
20835 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20836 long *arg2 = (long *) 0 ;
20837 long *arg3 = (long *) 0 ;
20838 void *argp1 = 0 ;
20839 int res1 = 0 ;
20840 long temp2 ;
20841 int res2 = SWIG_TMPOBJ ;
20842 long temp3 ;
20843 int res3 = SWIG_TMPOBJ ;
20844 PyObject *swig_obj[1] ;
20845
20846 arg2 = &temp2;
20847 arg3 = &temp3;
20848 if (!args) SWIG_fail;
20849 swig_obj[0] = args;
20850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20851 if (!SWIG_IsOK(res1)) {
20852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20853 }
20854 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20855 {
20856 PyThreadState* __tstate = wxPyBeginAllowThreads();
20857 (arg1)->GetPosition(arg2,arg3);
20858 wxPyEndAllowThreads(__tstate);
20859 if (PyErr_Occurred()) SWIG_fail;
20860 }
20861 resultobj = SWIG_Py_Void();
20862 if (SWIG_IsTmpObj(res2)) {
20863 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20864 } else {
20865 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20867 }
20868 if (SWIG_IsTmpObj(res3)) {
20869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20870 } else {
20871 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20873 }
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20881 PyObject *resultobj = 0;
20882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20883 wxDC *arg2 = 0 ;
20884 wxPoint result;
20885 void *argp1 = 0 ;
20886 int res1 = 0 ;
20887 void *argp2 = 0 ;
20888 int res2 = 0 ;
20889 PyObject * obj0 = 0 ;
20890 PyObject * obj1 = 0 ;
20891 char * kwnames[] = {
20892 (char *) "self",(char *) "dc", NULL
20893 };
20894
20895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20897 if (!SWIG_IsOK(res1)) {
20898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20899 }
20900 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20901 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20902 if (!SWIG_IsOK(res2)) {
20903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20904 }
20905 if (!argp2) {
20906 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20907 }
20908 arg2 = reinterpret_cast< wxDC * >(argp2);
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20912 wxPyEndAllowThreads(__tstate);
20913 if (PyErr_Occurred()) SWIG_fail;
20914 }
20915 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20916 return resultobj;
20917 fail:
20918 return NULL;
20919 }
20920
20921
20922 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20923 PyObject *resultobj = 0;
20924 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20925 int result;
20926 void *argp1 = 0 ;
20927 int res1 = 0 ;
20928 PyObject *swig_obj[1] ;
20929
20930 if (!args) SWIG_fail;
20931 swig_obj[0] = args;
20932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20933 if (!SWIG_IsOK(res1)) {
20934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20935 }
20936 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20937 {
20938 PyThreadState* __tstate = wxPyBeginAllowThreads();
20939 result = (int)((wxMouseEvent const *)arg1)->GetX();
20940 wxPyEndAllowThreads(__tstate);
20941 if (PyErr_Occurred()) SWIG_fail;
20942 }
20943 resultobj = SWIG_From_int(static_cast< int >(result));
20944 return resultobj;
20945 fail:
20946 return NULL;
20947 }
20948
20949
20950 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20951 PyObject *resultobj = 0;
20952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20953 int result;
20954 void *argp1 = 0 ;
20955 int res1 = 0 ;
20956 PyObject *swig_obj[1] ;
20957
20958 if (!args) SWIG_fail;
20959 swig_obj[0] = args;
20960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20961 if (!SWIG_IsOK(res1)) {
20962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20963 }
20964 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 result = (int)((wxMouseEvent const *)arg1)->GetY();
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 resultobj = SWIG_From_int(static_cast< int >(result));
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 PyObject *resultobj = 0;
20980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20981 int result;
20982 void *argp1 = 0 ;
20983 int res1 = 0 ;
20984 PyObject *swig_obj[1] ;
20985
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_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20991 }
20992 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 resultobj = SWIG_From_int(static_cast< int >(result));
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21007 PyObject *resultobj = 0;
21008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21009 int result;
21010 void *argp1 = 0 ;
21011 int res1 = 0 ;
21012 PyObject *swig_obj[1] ;
21013
21014 if (!args) SWIG_fail;
21015 swig_obj[0] = args;
21016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21017 if (!SWIG_IsOK(res1)) {
21018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21019 }
21020 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21024 wxPyEndAllowThreads(__tstate);
21025 if (PyErr_Occurred()) SWIG_fail;
21026 }
21027 resultobj = SWIG_From_int(static_cast< int >(result));
21028 return resultobj;
21029 fail:
21030 return NULL;
21031 }
21032
21033
21034 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21035 PyObject *resultobj = 0;
21036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21037 int result;
21038 void *argp1 = 0 ;
21039 int res1 = 0 ;
21040 PyObject *swig_obj[1] ;
21041
21042 if (!args) SWIG_fail;
21043 swig_obj[0] = args;
21044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21045 if (!SWIG_IsOK(res1)) {
21046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21047 }
21048 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21049 {
21050 PyThreadState* __tstate = wxPyBeginAllowThreads();
21051 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21052 wxPyEndAllowThreads(__tstate);
21053 if (PyErr_Occurred()) SWIG_fail;
21054 }
21055 resultobj = SWIG_From_int(static_cast< int >(result));
21056 return resultobj;
21057 fail:
21058 return NULL;
21059 }
21060
21061
21062 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21063 PyObject *resultobj = 0;
21064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21065 bool result;
21066 void *argp1 = 0 ;
21067 int res1 = 0 ;
21068 PyObject *swig_obj[1] ;
21069
21070 if (!args) SWIG_fail;
21071 swig_obj[0] = args;
21072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21073 if (!SWIG_IsOK(res1)) {
21074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21075 }
21076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21080 wxPyEndAllowThreads(__tstate);
21081 if (PyErr_Occurred()) SWIG_fail;
21082 }
21083 {
21084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21085 }
21086 return resultobj;
21087 fail:
21088 return NULL;
21089 }
21090
21091
21092 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21093 PyObject *resultobj = 0;
21094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21095 int arg2 ;
21096 void *argp1 = 0 ;
21097 int res1 = 0 ;
21098 int val2 ;
21099 int ecode2 = 0 ;
21100 PyObject *swig_obj[2] ;
21101
21102 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21104 if (!SWIG_IsOK(res1)) {
21105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21106 }
21107 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21108 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21109 if (!SWIG_IsOK(ecode2)) {
21110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21111 }
21112 arg2 = static_cast< int >(val2);
21113 if (arg1) (arg1)->m_x = arg2;
21114
21115 resultobj = SWIG_Py_Void();
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *resultobj = 0;
21124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21125 int result;
21126 void *argp1 = 0 ;
21127 int res1 = 0 ;
21128 PyObject *swig_obj[1] ;
21129
21130 if (!args) SWIG_fail;
21131 swig_obj[0] = args;
21132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21133 if (!SWIG_IsOK(res1)) {
21134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21135 }
21136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21137 result = (int) ((arg1)->m_x);
21138 resultobj = SWIG_From_int(static_cast< int >(result));
21139 return resultobj;
21140 fail:
21141 return NULL;
21142 }
21143
21144
21145 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21148 int arg2 ;
21149 void *argp1 = 0 ;
21150 int res1 = 0 ;
21151 int val2 ;
21152 int ecode2 = 0 ;
21153 PyObject *swig_obj[2] ;
21154
21155 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21159 }
21160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21161 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21162 if (!SWIG_IsOK(ecode2)) {
21163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21164 }
21165 arg2 = static_cast< int >(val2);
21166 if (arg1) (arg1)->m_y = arg2;
21167
21168 resultobj = SWIG_Py_Void();
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21176 PyObject *resultobj = 0;
21177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21178 int result;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 PyObject *swig_obj[1] ;
21182
21183 if (!args) SWIG_fail;
21184 swig_obj[0] = args;
21185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21188 }
21189 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21190 result = (int) ((arg1)->m_y);
21191 resultobj = SWIG_From_int(static_cast< int >(result));
21192 return resultobj;
21193 fail:
21194 return NULL;
21195 }
21196
21197
21198 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21199 PyObject *resultobj = 0;
21200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21201 bool arg2 ;
21202 void *argp1 = 0 ;
21203 int res1 = 0 ;
21204 bool val2 ;
21205 int ecode2 = 0 ;
21206 PyObject *swig_obj[2] ;
21207
21208 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21210 if (!SWIG_IsOK(res1)) {
21211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21212 }
21213 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21214 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21215 if (!SWIG_IsOK(ecode2)) {
21216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21217 }
21218 arg2 = static_cast< bool >(val2);
21219 if (arg1) (arg1)->m_leftDown = arg2;
21220
21221 resultobj = SWIG_Py_Void();
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21229 PyObject *resultobj = 0;
21230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21231 bool result;
21232 void *argp1 = 0 ;
21233 int res1 = 0 ;
21234 PyObject *swig_obj[1] ;
21235
21236 if (!args) SWIG_fail;
21237 swig_obj[0] = args;
21238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21239 if (!SWIG_IsOK(res1)) {
21240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21241 }
21242 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21243 result = (bool) ((arg1)->m_leftDown);
21244 {
21245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21246 }
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21254 PyObject *resultobj = 0;
21255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21256 bool arg2 ;
21257 void *argp1 = 0 ;
21258 int res1 = 0 ;
21259 bool val2 ;
21260 int ecode2 = 0 ;
21261 PyObject *swig_obj[2] ;
21262
21263 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21265 if (!SWIG_IsOK(res1)) {
21266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21267 }
21268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21269 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21270 if (!SWIG_IsOK(ecode2)) {
21271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21272 }
21273 arg2 = static_cast< bool >(val2);
21274 if (arg1) (arg1)->m_middleDown = arg2;
21275
21276 resultobj = SWIG_Py_Void();
21277 return resultobj;
21278 fail:
21279 return NULL;
21280 }
21281
21282
21283 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21284 PyObject *resultobj = 0;
21285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21286 bool result;
21287 void *argp1 = 0 ;
21288 int res1 = 0 ;
21289 PyObject *swig_obj[1] ;
21290
21291 if (!args) SWIG_fail;
21292 swig_obj[0] = args;
21293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21294 if (!SWIG_IsOK(res1)) {
21295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21296 }
21297 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21298 result = (bool) ((arg1)->m_middleDown);
21299 {
21300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21301 }
21302 return resultobj;
21303 fail:
21304 return NULL;
21305 }
21306
21307
21308 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21309 PyObject *resultobj = 0;
21310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21311 bool arg2 ;
21312 void *argp1 = 0 ;
21313 int res1 = 0 ;
21314 bool val2 ;
21315 int ecode2 = 0 ;
21316 PyObject *swig_obj[2] ;
21317
21318 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21320 if (!SWIG_IsOK(res1)) {
21321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21322 }
21323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21324 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21325 if (!SWIG_IsOK(ecode2)) {
21326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21327 }
21328 arg2 = static_cast< bool >(val2);
21329 if (arg1) (arg1)->m_rightDown = arg2;
21330
21331 resultobj = SWIG_Py_Void();
21332 return resultobj;
21333 fail:
21334 return NULL;
21335 }
21336
21337
21338 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21339 PyObject *resultobj = 0;
21340 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21341 bool result;
21342 void *argp1 = 0 ;
21343 int res1 = 0 ;
21344 PyObject *swig_obj[1] ;
21345
21346 if (!args) SWIG_fail;
21347 swig_obj[0] = args;
21348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21349 if (!SWIG_IsOK(res1)) {
21350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21351 }
21352 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21353 result = (bool) ((arg1)->m_rightDown);
21354 {
21355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21356 }
21357 return resultobj;
21358 fail:
21359 return NULL;
21360 }
21361
21362
21363 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21364 PyObject *resultobj = 0;
21365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21366 bool arg2 ;
21367 void *argp1 = 0 ;
21368 int res1 = 0 ;
21369 bool val2 ;
21370 int ecode2 = 0 ;
21371 PyObject *swig_obj[2] ;
21372
21373 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21375 if (!SWIG_IsOK(res1)) {
21376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21377 }
21378 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21379 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21380 if (!SWIG_IsOK(ecode2)) {
21381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21382 }
21383 arg2 = static_cast< bool >(val2);
21384 if (arg1) (arg1)->m_controlDown = arg2;
21385
21386 resultobj = SWIG_Py_Void();
21387 return resultobj;
21388 fail:
21389 return NULL;
21390 }
21391
21392
21393 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21394 PyObject *resultobj = 0;
21395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21396 bool result;
21397 void *argp1 = 0 ;
21398 int res1 = 0 ;
21399 PyObject *swig_obj[1] ;
21400
21401 if (!args) SWIG_fail;
21402 swig_obj[0] = args;
21403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21404 if (!SWIG_IsOK(res1)) {
21405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21406 }
21407 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21408 result = (bool) ((arg1)->m_controlDown);
21409 {
21410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21411 }
21412 return resultobj;
21413 fail:
21414 return NULL;
21415 }
21416
21417
21418 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21419 PyObject *resultobj = 0;
21420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21421 bool arg2 ;
21422 void *argp1 = 0 ;
21423 int res1 = 0 ;
21424 bool val2 ;
21425 int ecode2 = 0 ;
21426 PyObject *swig_obj[2] ;
21427
21428 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21430 if (!SWIG_IsOK(res1)) {
21431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21432 }
21433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21434 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21435 if (!SWIG_IsOK(ecode2)) {
21436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21437 }
21438 arg2 = static_cast< bool >(val2);
21439 if (arg1) (arg1)->m_shiftDown = arg2;
21440
21441 resultobj = SWIG_Py_Void();
21442 return resultobj;
21443 fail:
21444 return NULL;
21445 }
21446
21447
21448 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21449 PyObject *resultobj = 0;
21450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21451 bool result;
21452 void *argp1 = 0 ;
21453 int res1 = 0 ;
21454 PyObject *swig_obj[1] ;
21455
21456 if (!args) SWIG_fail;
21457 swig_obj[0] = args;
21458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21459 if (!SWIG_IsOK(res1)) {
21460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21461 }
21462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21463 result = (bool) ((arg1)->m_shiftDown);
21464 {
21465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21466 }
21467 return resultobj;
21468 fail:
21469 return NULL;
21470 }
21471
21472
21473 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21474 PyObject *resultobj = 0;
21475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21476 bool arg2 ;
21477 void *argp1 = 0 ;
21478 int res1 = 0 ;
21479 bool val2 ;
21480 int ecode2 = 0 ;
21481 PyObject *swig_obj[2] ;
21482
21483 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21485 if (!SWIG_IsOK(res1)) {
21486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21487 }
21488 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21489 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21490 if (!SWIG_IsOK(ecode2)) {
21491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21492 }
21493 arg2 = static_cast< bool >(val2);
21494 if (arg1) (arg1)->m_altDown = arg2;
21495
21496 resultobj = SWIG_Py_Void();
21497 return resultobj;
21498 fail:
21499 return NULL;
21500 }
21501
21502
21503 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21504 PyObject *resultobj = 0;
21505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21506 bool result;
21507 void *argp1 = 0 ;
21508 int res1 = 0 ;
21509 PyObject *swig_obj[1] ;
21510
21511 if (!args) SWIG_fail;
21512 swig_obj[0] = args;
21513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21514 if (!SWIG_IsOK(res1)) {
21515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21516 }
21517 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21518 result = (bool) ((arg1)->m_altDown);
21519 {
21520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21521 }
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21529 PyObject *resultobj = 0;
21530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21531 bool arg2 ;
21532 void *argp1 = 0 ;
21533 int res1 = 0 ;
21534 bool val2 ;
21535 int ecode2 = 0 ;
21536 PyObject *swig_obj[2] ;
21537
21538 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21540 if (!SWIG_IsOK(res1)) {
21541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21542 }
21543 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21544 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21545 if (!SWIG_IsOK(ecode2)) {
21546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21547 }
21548 arg2 = static_cast< bool >(val2);
21549 if (arg1) (arg1)->m_metaDown = arg2;
21550
21551 resultobj = SWIG_Py_Void();
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 PyObject *resultobj = 0;
21560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21561 bool result;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 PyObject *swig_obj[1] ;
21565
21566 if (!args) SWIG_fail;
21567 swig_obj[0] = args;
21568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21569 if (!SWIG_IsOK(res1)) {
21570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21571 }
21572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21573 result = (bool) ((arg1)->m_metaDown);
21574 {
21575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21576 }
21577 return resultobj;
21578 fail:
21579 return NULL;
21580 }
21581
21582
21583 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21584 PyObject *resultobj = 0;
21585 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21586 int arg2 ;
21587 void *argp1 = 0 ;
21588 int res1 = 0 ;
21589 int val2 ;
21590 int ecode2 = 0 ;
21591 PyObject *swig_obj[2] ;
21592
21593 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21595 if (!SWIG_IsOK(res1)) {
21596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21597 }
21598 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21599 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21600 if (!SWIG_IsOK(ecode2)) {
21601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21602 }
21603 arg2 = static_cast< int >(val2);
21604 if (arg1) (arg1)->m_wheelRotation = arg2;
21605
21606 resultobj = SWIG_Py_Void();
21607 return resultobj;
21608 fail:
21609 return NULL;
21610 }
21611
21612
21613 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21614 PyObject *resultobj = 0;
21615 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21616 int result;
21617 void *argp1 = 0 ;
21618 int res1 = 0 ;
21619 PyObject *swig_obj[1] ;
21620
21621 if (!args) SWIG_fail;
21622 swig_obj[0] = args;
21623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21624 if (!SWIG_IsOK(res1)) {
21625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21626 }
21627 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21628 result = (int) ((arg1)->m_wheelRotation);
21629 resultobj = SWIG_From_int(static_cast< int >(result));
21630 return resultobj;
21631 fail:
21632 return NULL;
21633 }
21634
21635
21636 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21637 PyObject *resultobj = 0;
21638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21639 int arg2 ;
21640 void *argp1 = 0 ;
21641 int res1 = 0 ;
21642 int val2 ;
21643 int ecode2 = 0 ;
21644 PyObject *swig_obj[2] ;
21645
21646 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21648 if (!SWIG_IsOK(res1)) {
21649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21650 }
21651 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21652 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21653 if (!SWIG_IsOK(ecode2)) {
21654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21655 }
21656 arg2 = static_cast< int >(val2);
21657 if (arg1) (arg1)->m_wheelDelta = arg2;
21658
21659 resultobj = SWIG_Py_Void();
21660 return resultobj;
21661 fail:
21662 return NULL;
21663 }
21664
21665
21666 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21667 PyObject *resultobj = 0;
21668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21669 int result;
21670 void *argp1 = 0 ;
21671 int res1 = 0 ;
21672 PyObject *swig_obj[1] ;
21673
21674 if (!args) SWIG_fail;
21675 swig_obj[0] = args;
21676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21679 }
21680 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21681 result = (int) ((arg1)->m_wheelDelta);
21682 resultobj = SWIG_From_int(static_cast< int >(result));
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690 PyObject *resultobj = 0;
21691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21692 int arg2 ;
21693 void *argp1 = 0 ;
21694 int res1 = 0 ;
21695 int val2 ;
21696 int ecode2 = 0 ;
21697 PyObject *swig_obj[2] ;
21698
21699 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21701 if (!SWIG_IsOK(res1)) {
21702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21703 }
21704 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21705 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21706 if (!SWIG_IsOK(ecode2)) {
21707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21708 }
21709 arg2 = static_cast< int >(val2);
21710 if (arg1) (arg1)->m_linesPerAction = arg2;
21711
21712 resultobj = SWIG_Py_Void();
21713 return resultobj;
21714 fail:
21715 return NULL;
21716 }
21717
21718
21719 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21720 PyObject *resultobj = 0;
21721 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21722 int result;
21723 void *argp1 = 0 ;
21724 int res1 = 0 ;
21725 PyObject *swig_obj[1] ;
21726
21727 if (!args) SWIG_fail;
21728 swig_obj[0] = args;
21729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21730 if (!SWIG_IsOK(res1)) {
21731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21732 }
21733 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21734 result = (int) ((arg1)->m_linesPerAction);
21735 resultobj = SWIG_From_int(static_cast< int >(result));
21736 return resultobj;
21737 fail:
21738 return NULL;
21739 }
21740
21741
21742 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21743 PyObject *obj;
21744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21745 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21746 return SWIG_Py_Void();
21747 }
21748
21749 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21750 return SWIG_Python_InitShadowInstance(args);
21751 }
21752
21753 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21754 PyObject *resultobj = 0;
21755 int arg1 = (int) 0 ;
21756 int arg2 = (int) 0 ;
21757 wxSetCursorEvent *result = 0 ;
21758 int val1 ;
21759 int ecode1 = 0 ;
21760 int val2 ;
21761 int ecode2 = 0 ;
21762 PyObject * obj0 = 0 ;
21763 PyObject * obj1 = 0 ;
21764 char * kwnames[] = {
21765 (char *) "x",(char *) "y", NULL
21766 };
21767
21768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21769 if (obj0) {
21770 ecode1 = SWIG_AsVal_int(obj0, &val1);
21771 if (!SWIG_IsOK(ecode1)) {
21772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21773 }
21774 arg1 = static_cast< int >(val1);
21775 }
21776 if (obj1) {
21777 ecode2 = SWIG_AsVal_int(obj1, &val2);
21778 if (!SWIG_IsOK(ecode2)) {
21779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21780 }
21781 arg2 = static_cast< int >(val2);
21782 }
21783 {
21784 PyThreadState* __tstate = wxPyBeginAllowThreads();
21785 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21786 wxPyEndAllowThreads(__tstate);
21787 if (PyErr_Occurred()) SWIG_fail;
21788 }
21789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21790 return resultobj;
21791 fail:
21792 return NULL;
21793 }
21794
21795
21796 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21797 PyObject *resultobj = 0;
21798 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21799 int result;
21800 void *argp1 = 0 ;
21801 int res1 = 0 ;
21802 PyObject *swig_obj[1] ;
21803
21804 if (!args) SWIG_fail;
21805 swig_obj[0] = args;
21806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21807 if (!SWIG_IsOK(res1)) {
21808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21809 }
21810 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21811 {
21812 PyThreadState* __tstate = wxPyBeginAllowThreads();
21813 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21814 wxPyEndAllowThreads(__tstate);
21815 if (PyErr_Occurred()) SWIG_fail;
21816 }
21817 resultobj = SWIG_From_int(static_cast< int >(result));
21818 return resultobj;
21819 fail:
21820 return NULL;
21821 }
21822
21823
21824 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21825 PyObject *resultobj = 0;
21826 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21827 int result;
21828 void *argp1 = 0 ;
21829 int res1 = 0 ;
21830 PyObject *swig_obj[1] ;
21831
21832 if (!args) SWIG_fail;
21833 swig_obj[0] = args;
21834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21835 if (!SWIG_IsOK(res1)) {
21836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21837 }
21838 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21839 {
21840 PyThreadState* __tstate = wxPyBeginAllowThreads();
21841 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21842 wxPyEndAllowThreads(__tstate);
21843 if (PyErr_Occurred()) SWIG_fail;
21844 }
21845 resultobj = SWIG_From_int(static_cast< int >(result));
21846 return resultobj;
21847 fail:
21848 return NULL;
21849 }
21850
21851
21852 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21853 PyObject *resultobj = 0;
21854 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21855 wxCursor *arg2 = 0 ;
21856 void *argp1 = 0 ;
21857 int res1 = 0 ;
21858 void *argp2 = 0 ;
21859 int res2 = 0 ;
21860 PyObject * obj0 = 0 ;
21861 PyObject * obj1 = 0 ;
21862 char * kwnames[] = {
21863 (char *) "self",(char *) "cursor", NULL
21864 };
21865
21866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21868 if (!SWIG_IsOK(res1)) {
21869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21870 }
21871 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21873 if (!SWIG_IsOK(res2)) {
21874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21875 }
21876 if (!argp2) {
21877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21878 }
21879 arg2 = reinterpret_cast< wxCursor * >(argp2);
21880 {
21881 PyThreadState* __tstate = wxPyBeginAllowThreads();
21882 (arg1)->SetCursor((wxCursor const &)*arg2);
21883 wxPyEndAllowThreads(__tstate);
21884 if (PyErr_Occurred()) SWIG_fail;
21885 }
21886 resultobj = SWIG_Py_Void();
21887 return resultobj;
21888 fail:
21889 return NULL;
21890 }
21891
21892
21893 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21894 PyObject *resultobj = 0;
21895 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21896 wxCursor *result = 0 ;
21897 void *argp1 = 0 ;
21898 int res1 = 0 ;
21899 PyObject *swig_obj[1] ;
21900
21901 if (!args) SWIG_fail;
21902 swig_obj[0] = args;
21903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21904 if (!SWIG_IsOK(res1)) {
21905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21906 }
21907 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21908 {
21909 PyThreadState* __tstate = wxPyBeginAllowThreads();
21910 {
21911 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21912 result = (wxCursor *) &_result_ref;
21913 }
21914 wxPyEndAllowThreads(__tstate);
21915 if (PyErr_Occurred()) SWIG_fail;
21916 }
21917 {
21918 wxCursor* resultptr = new wxCursor(*result);
21919 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21920 }
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21928 PyObject *resultobj = 0;
21929 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21930 bool result;
21931 void *argp1 = 0 ;
21932 int res1 = 0 ;
21933 PyObject *swig_obj[1] ;
21934
21935 if (!args) SWIG_fail;
21936 swig_obj[0] = args;
21937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21938 if (!SWIG_IsOK(res1)) {
21939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21940 }
21941 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21945 wxPyEndAllowThreads(__tstate);
21946 if (PyErr_Occurred()) SWIG_fail;
21947 }
21948 {
21949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21950 }
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21958 PyObject *obj;
21959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21960 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21961 return SWIG_Py_Void();
21962 }
21963
21964 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21965 return SWIG_Python_InitShadowInstance(args);
21966 }
21967
21968 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21969 PyObject *resultobj = 0;
21970 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21971 wxKeyEvent *result = 0 ;
21972 int val1 ;
21973 int ecode1 = 0 ;
21974 PyObject * obj0 = 0 ;
21975 char * kwnames[] = {
21976 (char *) "eventType", NULL
21977 };
21978
21979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21980 if (obj0) {
21981 ecode1 = SWIG_AsVal_int(obj0, &val1);
21982 if (!SWIG_IsOK(ecode1)) {
21983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21984 }
21985 arg1 = static_cast< wxEventType >(val1);
21986 }
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22001 PyObject *resultobj = 0;
22002 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22003 int result;
22004 void *argp1 = 0 ;
22005 int res1 = 0 ;
22006 PyObject *swig_obj[1] ;
22007
22008 if (!args) SWIG_fail;
22009 swig_obj[0] = args;
22010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22011 if (!SWIG_IsOK(res1)) {
22012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22013 }
22014 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22015 {
22016 PyThreadState* __tstate = wxPyBeginAllowThreads();
22017 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22018 wxPyEndAllowThreads(__tstate);
22019 if (PyErr_Occurred()) SWIG_fail;
22020 }
22021 resultobj = SWIG_From_int(static_cast< int >(result));
22022 return resultobj;
22023 fail:
22024 return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22029 PyObject *resultobj = 0;
22030 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22031 bool result;
22032 void *argp1 = 0 ;
22033 int res1 = 0 ;
22034 PyObject *swig_obj[1] ;
22035
22036 if (!args) SWIG_fail;
22037 swig_obj[0] = args;
22038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22039 if (!SWIG_IsOK(res1)) {
22040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22041 }
22042 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22043 {
22044 PyThreadState* __tstate = wxPyBeginAllowThreads();
22045 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 {
22050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22051 }
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22059 PyObject *resultobj = 0;
22060 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22061 bool result;
22062 void *argp1 = 0 ;
22063 int res1 = 0 ;
22064 PyObject *swig_obj[1] ;
22065
22066 if (!args) SWIG_fail;
22067 swig_obj[0] = args;
22068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22069 if (!SWIG_IsOK(res1)) {
22070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22071 }
22072 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22073 {
22074 PyThreadState* __tstate = wxPyBeginAllowThreads();
22075 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 {
22080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22081 }
22082 return resultobj;
22083 fail:
22084 return NULL;
22085 }
22086
22087
22088 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22089 PyObject *resultobj = 0;
22090 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22091 bool result;
22092 void *argp1 = 0 ;
22093 int res1 = 0 ;
22094 PyObject *swig_obj[1] ;
22095
22096 if (!args) SWIG_fail;
22097 swig_obj[0] = args;
22098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22099 if (!SWIG_IsOK(res1)) {
22100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22101 }
22102 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22103 {
22104 PyThreadState* __tstate = wxPyBeginAllowThreads();
22105 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22106 wxPyEndAllowThreads(__tstate);
22107 if (PyErr_Occurred()) SWIG_fail;
22108 }
22109 {
22110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22111 }
22112 return resultobj;
22113 fail:
22114 return NULL;
22115 }
22116
22117
22118 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22119 PyObject *resultobj = 0;
22120 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22121 bool result;
22122 void *argp1 = 0 ;
22123 int res1 = 0 ;
22124 PyObject *swig_obj[1] ;
22125
22126 if (!args) SWIG_fail;
22127 swig_obj[0] = args;
22128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22129 if (!SWIG_IsOK(res1)) {
22130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22131 }
22132 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22133 {
22134 PyThreadState* __tstate = wxPyBeginAllowThreads();
22135 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22136 wxPyEndAllowThreads(__tstate);
22137 if (PyErr_Occurred()) SWIG_fail;
22138 }
22139 {
22140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22141 }
22142 return resultobj;
22143 fail:
22144 return NULL;
22145 }
22146
22147
22148 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22149 PyObject *resultobj = 0;
22150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22151 bool result;
22152 void *argp1 = 0 ;
22153 int res1 = 0 ;
22154 PyObject *swig_obj[1] ;
22155
22156 if (!args) SWIG_fail;
22157 swig_obj[0] = args;
22158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22161 }
22162 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22163 {
22164 PyThreadState* __tstate = wxPyBeginAllowThreads();
22165 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 {
22170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22171 }
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22179 PyObject *resultobj = 0;
22180 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22181 bool result;
22182 void *argp1 = 0 ;
22183 int res1 = 0 ;
22184 PyObject *swig_obj[1] ;
22185
22186 if (!args) SWIG_fail;
22187 swig_obj[0] = args;
22188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22189 if (!SWIG_IsOK(res1)) {
22190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22191 }
22192 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22193 {
22194 PyThreadState* __tstate = wxPyBeginAllowThreads();
22195 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22196 wxPyEndAllowThreads(__tstate);
22197 if (PyErr_Occurred()) SWIG_fail;
22198 }
22199 {
22200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22201 }
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22209 PyObject *resultobj = 0;
22210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22211 int result;
22212 void *argp1 = 0 ;
22213 int res1 = 0 ;
22214 PyObject *swig_obj[1] ;
22215
22216 if (!args) SWIG_fail;
22217 swig_obj[0] = args;
22218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22219 if (!SWIG_IsOK(res1)) {
22220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22221 }
22222 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 resultobj = SWIG_From_int(static_cast< int >(result));
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22239 int result;
22240 void *argp1 = 0 ;
22241 int res1 = 0 ;
22242 PyObject *swig_obj[1] ;
22243
22244 if (!args) SWIG_fail;
22245 swig_obj[0] = args;
22246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22247 if (!SWIG_IsOK(res1)) {
22248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22249 }
22250 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22251 {
22252 PyThreadState* __tstate = wxPyBeginAllowThreads();
22253 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22254 wxPyEndAllowThreads(__tstate);
22255 if (PyErr_Occurred()) SWIG_fail;
22256 }
22257 resultobj = SWIG_From_int(static_cast< int >(result));
22258 return resultobj;
22259 fail:
22260 return NULL;
22261 }
22262
22263
22264 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22265 PyObject *resultobj = 0;
22266 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22267 int arg2 ;
22268 void *argp1 = 0 ;
22269 int res1 = 0 ;
22270 int val2 ;
22271 int ecode2 = 0 ;
22272 PyObject * obj0 = 0 ;
22273 PyObject * obj1 = 0 ;
22274 char * kwnames[] = {
22275 (char *) "self",(char *) "uniChar", NULL
22276 };
22277
22278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22280 if (!SWIG_IsOK(res1)) {
22281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22282 }
22283 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22284 ecode2 = SWIG_AsVal_int(obj1, &val2);
22285 if (!SWIG_IsOK(ecode2)) {
22286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22287 }
22288 arg2 = static_cast< int >(val2);
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 resultobj = SWIG_Py_Void();
22296 return resultobj;
22297 fail:
22298 return NULL;
22299 }
22300
22301
22302 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22303 PyObject *resultobj = 0;
22304 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22305 unsigned int result;
22306 void *argp1 = 0 ;
22307 int res1 = 0 ;
22308 PyObject *swig_obj[1] ;
22309
22310 if (!args) SWIG_fail;
22311 swig_obj[0] = args;
22312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22313 if (!SWIG_IsOK(res1)) {
22314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22315 }
22316 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22317 {
22318 PyThreadState* __tstate = wxPyBeginAllowThreads();
22319 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22320 wxPyEndAllowThreads(__tstate);
22321 if (PyErr_Occurred()) SWIG_fail;
22322 }
22323 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22324 return resultobj;
22325 fail:
22326 return NULL;
22327 }
22328
22329
22330 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22331 PyObject *resultobj = 0;
22332 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22333 unsigned int result;
22334 void *argp1 = 0 ;
22335 int res1 = 0 ;
22336 PyObject *swig_obj[1] ;
22337
22338 if (!args) SWIG_fail;
22339 swig_obj[0] = args;
22340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22341 if (!SWIG_IsOK(res1)) {
22342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22343 }
22344 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22345 {
22346 PyThreadState* __tstate = wxPyBeginAllowThreads();
22347 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22348 wxPyEndAllowThreads(__tstate);
22349 if (PyErr_Occurred()) SWIG_fail;
22350 }
22351 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22352 return resultobj;
22353 fail:
22354 return NULL;
22355 }
22356
22357
22358 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22359 PyObject *resultobj = 0;
22360 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22361 wxPoint result;
22362 void *argp1 = 0 ;
22363 int res1 = 0 ;
22364 PyObject *swig_obj[1] ;
22365
22366 if (!args) SWIG_fail;
22367 swig_obj[0] = args;
22368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22369 if (!SWIG_IsOK(res1)) {
22370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22371 }
22372 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22373 {
22374 PyThreadState* __tstate = wxPyBeginAllowThreads();
22375 result = (arg1)->GetPosition();
22376 wxPyEndAllowThreads(__tstate);
22377 if (PyErr_Occurred()) SWIG_fail;
22378 }
22379 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22380 return resultobj;
22381 fail:
22382 return NULL;
22383 }
22384
22385
22386 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22387 PyObject *resultobj = 0;
22388 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22389 long *arg2 = (long *) 0 ;
22390 long *arg3 = (long *) 0 ;
22391 void *argp1 = 0 ;
22392 int res1 = 0 ;
22393 long temp2 ;
22394 int res2 = SWIG_TMPOBJ ;
22395 long temp3 ;
22396 int res3 = SWIG_TMPOBJ ;
22397 PyObject *swig_obj[1] ;
22398
22399 arg2 = &temp2;
22400 arg3 = &temp3;
22401 if (!args) SWIG_fail;
22402 swig_obj[0] = args;
22403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22404 if (!SWIG_IsOK(res1)) {
22405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22406 }
22407 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 (arg1)->GetPosition(arg2,arg3);
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 resultobj = SWIG_Py_Void();
22415 if (SWIG_IsTmpObj(res2)) {
22416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22417 } else {
22418 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22420 }
22421 if (SWIG_IsTmpObj(res3)) {
22422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22423 } else {
22424 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22426 }
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22434 PyObject *resultobj = 0;
22435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22436 int result;
22437 void *argp1 = 0 ;
22438 int res1 = 0 ;
22439 PyObject *swig_obj[1] ;
22440
22441 if (!args) SWIG_fail;
22442 swig_obj[0] = args;
22443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22444 if (!SWIG_IsOK(res1)) {
22445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22446 }
22447 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 result = (int)((wxKeyEvent const *)arg1)->GetX();
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 resultobj = SWIG_From_int(static_cast< int >(result));
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22462 PyObject *resultobj = 0;
22463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22464 int result;
22465 void *argp1 = 0 ;
22466 int res1 = 0 ;
22467 PyObject *swig_obj[1] ;
22468
22469 if (!args) SWIG_fail;
22470 swig_obj[0] = args;
22471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22472 if (!SWIG_IsOK(res1)) {
22473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22474 }
22475 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 result = (int)((wxKeyEvent const *)arg1)->GetY();
22479 wxPyEndAllowThreads(__tstate);
22480 if (PyErr_Occurred()) SWIG_fail;
22481 }
22482 resultobj = SWIG_From_int(static_cast< int >(result));
22483 return resultobj;
22484 fail:
22485 return NULL;
22486 }
22487
22488
22489 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22490 PyObject *resultobj = 0;
22491 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22492 int arg2 ;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 int val2 ;
22496 int ecode2 = 0 ;
22497 PyObject *swig_obj[2] ;
22498
22499 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22501 if (!SWIG_IsOK(res1)) {
22502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22503 }
22504 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22505 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22506 if (!SWIG_IsOK(ecode2)) {
22507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22508 }
22509 arg2 = static_cast< int >(val2);
22510 if (arg1) (arg1)->m_x = arg2;
22511
22512 resultobj = SWIG_Py_Void();
22513 return resultobj;
22514 fail:
22515 return NULL;
22516 }
22517
22518
22519 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22520 PyObject *resultobj = 0;
22521 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22522 int result;
22523 void *argp1 = 0 ;
22524 int res1 = 0 ;
22525 PyObject *swig_obj[1] ;
22526
22527 if (!args) SWIG_fail;
22528 swig_obj[0] = args;
22529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22530 if (!SWIG_IsOK(res1)) {
22531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22532 }
22533 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22534 result = (int) ((arg1)->m_x);
22535 resultobj = SWIG_From_int(static_cast< int >(result));
22536 return resultobj;
22537 fail:
22538 return NULL;
22539 }
22540
22541
22542 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22543 PyObject *resultobj = 0;
22544 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22545 int arg2 ;
22546 void *argp1 = 0 ;
22547 int res1 = 0 ;
22548 int val2 ;
22549 int ecode2 = 0 ;
22550 PyObject *swig_obj[2] ;
22551
22552 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22554 if (!SWIG_IsOK(res1)) {
22555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22556 }
22557 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22558 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22559 if (!SWIG_IsOK(ecode2)) {
22560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22561 }
22562 arg2 = static_cast< int >(val2);
22563 if (arg1) (arg1)->m_y = arg2;
22564
22565 resultobj = SWIG_Py_Void();
22566 return resultobj;
22567 fail:
22568 return NULL;
22569 }
22570
22571
22572 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22573 PyObject *resultobj = 0;
22574 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22575 int result;
22576 void *argp1 = 0 ;
22577 int res1 = 0 ;
22578 PyObject *swig_obj[1] ;
22579
22580 if (!args) SWIG_fail;
22581 swig_obj[0] = args;
22582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22583 if (!SWIG_IsOK(res1)) {
22584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22585 }
22586 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22587 result = (int) ((arg1)->m_y);
22588 resultobj = SWIG_From_int(static_cast< int >(result));
22589 return resultobj;
22590 fail:
22591 return NULL;
22592 }
22593
22594
22595 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22596 PyObject *resultobj = 0;
22597 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22598 long arg2 ;
22599 void *argp1 = 0 ;
22600 int res1 = 0 ;
22601 long val2 ;
22602 int ecode2 = 0 ;
22603 PyObject *swig_obj[2] ;
22604
22605 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22607 if (!SWIG_IsOK(res1)) {
22608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22609 }
22610 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22611 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22612 if (!SWIG_IsOK(ecode2)) {
22613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22614 }
22615 arg2 = static_cast< long >(val2);
22616 if (arg1) (arg1)->m_keyCode = arg2;
22617
22618 resultobj = SWIG_Py_Void();
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22626 PyObject *resultobj = 0;
22627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22628 long result;
22629 void *argp1 = 0 ;
22630 int res1 = 0 ;
22631 PyObject *swig_obj[1] ;
22632
22633 if (!args) SWIG_fail;
22634 swig_obj[0] = args;
22635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22638 }
22639 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22640 result = (long) ((arg1)->m_keyCode);
22641 resultobj = SWIG_From_long(static_cast< long >(result));
22642 return resultobj;
22643 fail:
22644 return NULL;
22645 }
22646
22647
22648 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22649 PyObject *resultobj = 0;
22650 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22651 bool arg2 ;
22652 void *argp1 = 0 ;
22653 int res1 = 0 ;
22654 bool val2 ;
22655 int ecode2 = 0 ;
22656 PyObject *swig_obj[2] ;
22657
22658 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22660 if (!SWIG_IsOK(res1)) {
22661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22662 }
22663 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22664 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22665 if (!SWIG_IsOK(ecode2)) {
22666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22667 }
22668 arg2 = static_cast< bool >(val2);
22669 if (arg1) (arg1)->m_controlDown = arg2;
22670
22671 resultobj = SWIG_Py_Void();
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22679 PyObject *resultobj = 0;
22680 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22681 bool result;
22682 void *argp1 = 0 ;
22683 int res1 = 0 ;
22684 PyObject *swig_obj[1] ;
22685
22686 if (!args) SWIG_fail;
22687 swig_obj[0] = args;
22688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22689 if (!SWIG_IsOK(res1)) {
22690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22691 }
22692 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22693 result = (bool) ((arg1)->m_controlDown);
22694 {
22695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22696 }
22697 return resultobj;
22698 fail:
22699 return NULL;
22700 }
22701
22702
22703 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22704 PyObject *resultobj = 0;
22705 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22706 bool arg2 ;
22707 void *argp1 = 0 ;
22708 int res1 = 0 ;
22709 bool val2 ;
22710 int ecode2 = 0 ;
22711 PyObject *swig_obj[2] ;
22712
22713 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22715 if (!SWIG_IsOK(res1)) {
22716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22717 }
22718 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22719 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22720 if (!SWIG_IsOK(ecode2)) {
22721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22722 }
22723 arg2 = static_cast< bool >(val2);
22724 if (arg1) (arg1)->m_shiftDown = arg2;
22725
22726 resultobj = SWIG_Py_Void();
22727 return resultobj;
22728 fail:
22729 return NULL;
22730 }
22731
22732
22733 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22734 PyObject *resultobj = 0;
22735 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22736 bool result;
22737 void *argp1 = 0 ;
22738 int res1 = 0 ;
22739 PyObject *swig_obj[1] ;
22740
22741 if (!args) SWIG_fail;
22742 swig_obj[0] = args;
22743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22744 if (!SWIG_IsOK(res1)) {
22745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22746 }
22747 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22748 result = (bool) ((arg1)->m_shiftDown);
22749 {
22750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22751 }
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22759 PyObject *resultobj = 0;
22760 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22761 bool arg2 ;
22762 void *argp1 = 0 ;
22763 int res1 = 0 ;
22764 bool val2 ;
22765 int ecode2 = 0 ;
22766 PyObject *swig_obj[2] ;
22767
22768 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22770 if (!SWIG_IsOK(res1)) {
22771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22772 }
22773 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22774 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22775 if (!SWIG_IsOK(ecode2)) {
22776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22777 }
22778 arg2 = static_cast< bool >(val2);
22779 if (arg1) (arg1)->m_altDown = arg2;
22780
22781 resultobj = SWIG_Py_Void();
22782 return resultobj;
22783 fail:
22784 return NULL;
22785 }
22786
22787
22788 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22789 PyObject *resultobj = 0;
22790 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22791 bool result;
22792 void *argp1 = 0 ;
22793 int res1 = 0 ;
22794 PyObject *swig_obj[1] ;
22795
22796 if (!args) SWIG_fail;
22797 swig_obj[0] = args;
22798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22799 if (!SWIG_IsOK(res1)) {
22800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22801 }
22802 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22803 result = (bool) ((arg1)->m_altDown);
22804 {
22805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22806 }
22807 return resultobj;
22808 fail:
22809 return NULL;
22810 }
22811
22812
22813 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22814 PyObject *resultobj = 0;
22815 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22816 bool arg2 ;
22817 void *argp1 = 0 ;
22818 int res1 = 0 ;
22819 bool val2 ;
22820 int ecode2 = 0 ;
22821 PyObject *swig_obj[2] ;
22822
22823 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22825 if (!SWIG_IsOK(res1)) {
22826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22827 }
22828 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22829 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22830 if (!SWIG_IsOK(ecode2)) {
22831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22832 }
22833 arg2 = static_cast< bool >(val2);
22834 if (arg1) (arg1)->m_metaDown = arg2;
22835
22836 resultobj = SWIG_Py_Void();
22837 return resultobj;
22838 fail:
22839 return NULL;
22840 }
22841
22842
22843 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22844 PyObject *resultobj = 0;
22845 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22846 bool result;
22847 void *argp1 = 0 ;
22848 int res1 = 0 ;
22849 PyObject *swig_obj[1] ;
22850
22851 if (!args) SWIG_fail;
22852 swig_obj[0] = args;
22853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22854 if (!SWIG_IsOK(res1)) {
22855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22856 }
22857 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22858 result = (bool) ((arg1)->m_metaDown);
22859 {
22860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22861 }
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22869 PyObject *resultobj = 0;
22870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22871 bool arg2 ;
22872 void *argp1 = 0 ;
22873 int res1 = 0 ;
22874 bool val2 ;
22875 int ecode2 = 0 ;
22876 PyObject *swig_obj[2] ;
22877
22878 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22880 if (!SWIG_IsOK(res1)) {
22881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22882 }
22883 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22884 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22885 if (!SWIG_IsOK(ecode2)) {
22886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22887 }
22888 arg2 = static_cast< bool >(val2);
22889 if (arg1) (arg1)->m_scanCode = arg2;
22890
22891 resultobj = SWIG_Py_Void();
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22899 PyObject *resultobj = 0;
22900 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22901 bool result;
22902 void *argp1 = 0 ;
22903 int res1 = 0 ;
22904 PyObject *swig_obj[1] ;
22905
22906 if (!args) SWIG_fail;
22907 swig_obj[0] = args;
22908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22909 if (!SWIG_IsOK(res1)) {
22910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22911 }
22912 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22913 result = (bool) ((arg1)->m_scanCode);
22914 {
22915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22916 }
22917 return resultobj;
22918 fail:
22919 return NULL;
22920 }
22921
22922
22923 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22924 PyObject *resultobj = 0;
22925 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22926 unsigned int arg2 ;
22927 void *argp1 = 0 ;
22928 int res1 = 0 ;
22929 unsigned int val2 ;
22930 int ecode2 = 0 ;
22931 PyObject *swig_obj[2] ;
22932
22933 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22935 if (!SWIG_IsOK(res1)) {
22936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22937 }
22938 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22939 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22940 if (!SWIG_IsOK(ecode2)) {
22941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22942 }
22943 arg2 = static_cast< unsigned int >(val2);
22944 if (arg1) (arg1)->m_rawCode = arg2;
22945
22946 resultobj = SWIG_Py_Void();
22947 return resultobj;
22948 fail:
22949 return NULL;
22950 }
22951
22952
22953 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22954 PyObject *resultobj = 0;
22955 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22956 unsigned int result;
22957 void *argp1 = 0 ;
22958 int res1 = 0 ;
22959 PyObject *swig_obj[1] ;
22960
22961 if (!args) SWIG_fail;
22962 swig_obj[0] = args;
22963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22964 if (!SWIG_IsOK(res1)) {
22965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22966 }
22967 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22968 result = (unsigned int) ((arg1)->m_rawCode);
22969 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22970 return resultobj;
22971 fail:
22972 return NULL;
22973 }
22974
22975
22976 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22977 PyObject *resultobj = 0;
22978 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22979 unsigned int arg2 ;
22980 void *argp1 = 0 ;
22981 int res1 = 0 ;
22982 unsigned int val2 ;
22983 int ecode2 = 0 ;
22984 PyObject *swig_obj[2] ;
22985
22986 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22988 if (!SWIG_IsOK(res1)) {
22989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22990 }
22991 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22992 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22993 if (!SWIG_IsOK(ecode2)) {
22994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22995 }
22996 arg2 = static_cast< unsigned int >(val2);
22997 if (arg1) (arg1)->m_rawFlags = arg2;
22998
22999 resultobj = SWIG_Py_Void();
23000 return resultobj;
23001 fail:
23002 return NULL;
23003 }
23004
23005
23006 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23007 PyObject *resultobj = 0;
23008 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23009 unsigned int result;
23010 void *argp1 = 0 ;
23011 int res1 = 0 ;
23012 PyObject *swig_obj[1] ;
23013
23014 if (!args) SWIG_fail;
23015 swig_obj[0] = args;
23016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23017 if (!SWIG_IsOK(res1)) {
23018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23019 }
23020 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23021 result = (unsigned int) ((arg1)->m_rawFlags);
23022 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23030 PyObject *obj;
23031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23032 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23033 return SWIG_Py_Void();
23034 }
23035
23036 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23037 return SWIG_Python_InitShadowInstance(args);
23038 }
23039
23040 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23041 PyObject *resultobj = 0;
23042 wxSize const &arg1_defvalue = wxDefaultSize ;
23043 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23044 int arg2 = (int) 0 ;
23045 wxSizeEvent *result = 0 ;
23046 wxSize temp1 ;
23047 int val2 ;
23048 int ecode2 = 0 ;
23049 PyObject * obj0 = 0 ;
23050 PyObject * obj1 = 0 ;
23051 char * kwnames[] = {
23052 (char *) "sz",(char *) "winid", NULL
23053 };
23054
23055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23056 if (obj0) {
23057 {
23058 arg1 = &temp1;
23059 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23060 }
23061 }
23062 if (obj1) {
23063 ecode2 = SWIG_AsVal_int(obj1, &val2);
23064 if (!SWIG_IsOK(ecode2)) {
23065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23066 }
23067 arg2 = static_cast< int >(val2);
23068 }
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23072 wxPyEndAllowThreads(__tstate);
23073 if (PyErr_Occurred()) SWIG_fail;
23074 }
23075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23083 PyObject *resultobj = 0;
23084 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23085 wxSize result;
23086 void *argp1 = 0 ;
23087 int res1 = 0 ;
23088 PyObject *swig_obj[1] ;
23089
23090 if (!args) SWIG_fail;
23091 swig_obj[0] = args;
23092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23093 if (!SWIG_IsOK(res1)) {
23094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23095 }
23096 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23097 {
23098 PyThreadState* __tstate = wxPyBeginAllowThreads();
23099 result = ((wxSizeEvent const *)arg1)->GetSize();
23100 wxPyEndAllowThreads(__tstate);
23101 if (PyErr_Occurred()) SWIG_fail;
23102 }
23103 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23111 PyObject *resultobj = 0;
23112 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23113 wxRect result;
23114 void *argp1 = 0 ;
23115 int res1 = 0 ;
23116 PyObject *swig_obj[1] ;
23117
23118 if (!args) SWIG_fail;
23119 swig_obj[0] = args;
23120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23121 if (!SWIG_IsOK(res1)) {
23122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23123 }
23124 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23125 {
23126 PyThreadState* __tstate = wxPyBeginAllowThreads();
23127 result = ((wxSizeEvent const *)arg1)->GetRect();
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23139 PyObject *resultobj = 0;
23140 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23141 wxRect arg2 ;
23142 void *argp1 = 0 ;
23143 int res1 = 0 ;
23144 void *argp2 ;
23145 int res2 = 0 ;
23146 PyObject * obj0 = 0 ;
23147 PyObject * obj1 = 0 ;
23148 char * kwnames[] = {
23149 (char *) "self",(char *) "rect", NULL
23150 };
23151
23152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23154 if (!SWIG_IsOK(res1)) {
23155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23156 }
23157 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23158 {
23159 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23160 if (!SWIG_IsOK(res2)) {
23161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23162 }
23163 if (!argp2) {
23164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23165 } else {
23166 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23167 arg2 = *temp;
23168 if (SWIG_IsNewObj(res2)) delete temp;
23169 }
23170 }
23171 {
23172 PyThreadState* __tstate = wxPyBeginAllowThreads();
23173 (arg1)->SetRect(arg2);
23174 wxPyEndAllowThreads(__tstate);
23175 if (PyErr_Occurred()) SWIG_fail;
23176 }
23177 resultobj = SWIG_Py_Void();
23178 return resultobj;
23179 fail:
23180 return NULL;
23181 }
23182
23183
23184 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23185 PyObject *resultobj = 0;
23186 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23187 wxSize arg2 ;
23188 void *argp1 = 0 ;
23189 int res1 = 0 ;
23190 void *argp2 ;
23191 int res2 = 0 ;
23192 PyObject * obj0 = 0 ;
23193 PyObject * obj1 = 0 ;
23194 char * kwnames[] = {
23195 (char *) "self",(char *) "size", NULL
23196 };
23197
23198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23200 if (!SWIG_IsOK(res1)) {
23201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23202 }
23203 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23204 {
23205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23206 if (!SWIG_IsOK(res2)) {
23207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23208 }
23209 if (!argp2) {
23210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23211 } else {
23212 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23213 arg2 = *temp;
23214 if (SWIG_IsNewObj(res2)) delete temp;
23215 }
23216 }
23217 {
23218 PyThreadState* __tstate = wxPyBeginAllowThreads();
23219 wxSizeEvent_SetSize(arg1,arg2);
23220 wxPyEndAllowThreads(__tstate);
23221 if (PyErr_Occurred()) SWIG_fail;
23222 }
23223 resultobj = SWIG_Py_Void();
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23231 PyObject *resultobj = 0;
23232 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23233 wxSize *arg2 = (wxSize *) 0 ;
23234 void *argp1 = 0 ;
23235 int res1 = 0 ;
23236 void *argp2 = 0 ;
23237 int res2 = 0 ;
23238 PyObject *swig_obj[2] ;
23239
23240 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23242 if (!SWIG_IsOK(res1)) {
23243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23244 }
23245 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23246 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23247 if (!SWIG_IsOK(res2)) {
23248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23249 }
23250 arg2 = reinterpret_cast< wxSize * >(argp2);
23251 if (arg1) (arg1)->m_size = *arg2;
23252
23253 resultobj = SWIG_Py_Void();
23254 return resultobj;
23255 fail:
23256 return NULL;
23257 }
23258
23259
23260 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23261 PyObject *resultobj = 0;
23262 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23263 wxSize *result = 0 ;
23264 void *argp1 = 0 ;
23265 int res1 = 0 ;
23266 PyObject *swig_obj[1] ;
23267
23268 if (!args) SWIG_fail;
23269 swig_obj[0] = args;
23270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23271 if (!SWIG_IsOK(res1)) {
23272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23273 }
23274 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23275 result = (wxSize *)& ((arg1)->m_size);
23276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23284 PyObject *resultobj = 0;
23285 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23286 wxRect *arg2 = (wxRect *) 0 ;
23287 void *argp1 = 0 ;
23288 int res1 = 0 ;
23289 void *argp2 = 0 ;
23290 int res2 = 0 ;
23291 PyObject *swig_obj[2] ;
23292
23293 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23295 if (!SWIG_IsOK(res1)) {
23296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23297 }
23298 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23299 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23300 if (!SWIG_IsOK(res2)) {
23301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23302 }
23303 arg2 = reinterpret_cast< wxRect * >(argp2);
23304 if (arg1) (arg1)->m_rect = *arg2;
23305
23306 resultobj = SWIG_Py_Void();
23307 return resultobj;
23308 fail:
23309 return NULL;
23310 }
23311
23312
23313 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23314 PyObject *resultobj = 0;
23315 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23316 wxRect *result = 0 ;
23317 void *argp1 = 0 ;
23318 int res1 = 0 ;
23319 PyObject *swig_obj[1] ;
23320
23321 if (!args) SWIG_fail;
23322 swig_obj[0] = args;
23323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23324 if (!SWIG_IsOK(res1)) {
23325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23326 }
23327 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23328 result = (wxRect *)& ((arg1)->m_rect);
23329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23337 PyObject *obj;
23338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23339 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23340 return SWIG_Py_Void();
23341 }
23342
23343 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23344 return SWIG_Python_InitShadowInstance(args);
23345 }
23346
23347 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23348 PyObject *resultobj = 0;
23349 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23350 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23351 int arg2 = (int) 0 ;
23352 wxMoveEvent *result = 0 ;
23353 wxPoint temp1 ;
23354 int val2 ;
23355 int ecode2 = 0 ;
23356 PyObject * obj0 = 0 ;
23357 PyObject * obj1 = 0 ;
23358 char * kwnames[] = {
23359 (char *) "pos",(char *) "winid", NULL
23360 };
23361
23362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23363 if (obj0) {
23364 {
23365 arg1 = &temp1;
23366 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23367 }
23368 }
23369 if (obj1) {
23370 ecode2 = SWIG_AsVal_int(obj1, &val2);
23371 if (!SWIG_IsOK(ecode2)) {
23372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23373 }
23374 arg2 = static_cast< int >(val2);
23375 }
23376 {
23377 PyThreadState* __tstate = wxPyBeginAllowThreads();
23378 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23379 wxPyEndAllowThreads(__tstate);
23380 if (PyErr_Occurred()) SWIG_fail;
23381 }
23382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23383 return resultobj;
23384 fail:
23385 return NULL;
23386 }
23387
23388
23389 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23390 PyObject *resultobj = 0;
23391 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23392 wxPoint result;
23393 void *argp1 = 0 ;
23394 int res1 = 0 ;
23395 PyObject *swig_obj[1] ;
23396
23397 if (!args) SWIG_fail;
23398 swig_obj[0] = args;
23399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23400 if (!SWIG_IsOK(res1)) {
23401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23402 }
23403 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23404 {
23405 PyThreadState* __tstate = wxPyBeginAllowThreads();
23406 result = ((wxMoveEvent const *)arg1)->GetPosition();
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23418 PyObject *resultobj = 0;
23419 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23420 wxRect result;
23421 void *argp1 = 0 ;
23422 int res1 = 0 ;
23423 PyObject *swig_obj[1] ;
23424
23425 if (!args) SWIG_fail;
23426 swig_obj[0] = args;
23427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23428 if (!SWIG_IsOK(res1)) {
23429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23430 }
23431 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23432 {
23433 PyThreadState* __tstate = wxPyBeginAllowThreads();
23434 result = ((wxMoveEvent const *)arg1)->GetRect();
23435 wxPyEndAllowThreads(__tstate);
23436 if (PyErr_Occurred()) SWIG_fail;
23437 }
23438 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23439 return resultobj;
23440 fail:
23441 return NULL;
23442 }
23443
23444
23445 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj = 0;
23447 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23448 wxRect *arg2 = 0 ;
23449 void *argp1 = 0 ;
23450 int res1 = 0 ;
23451 wxRect temp2 ;
23452 PyObject * obj0 = 0 ;
23453 PyObject * obj1 = 0 ;
23454 char * kwnames[] = {
23455 (char *) "self",(char *) "rect", NULL
23456 };
23457
23458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23460 if (!SWIG_IsOK(res1)) {
23461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23462 }
23463 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23464 {
23465 arg2 = &temp2;
23466 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23467 }
23468 {
23469 PyThreadState* __tstate = wxPyBeginAllowThreads();
23470 (arg1)->SetRect((wxRect const &)*arg2);
23471 wxPyEndAllowThreads(__tstate);
23472 if (PyErr_Occurred()) SWIG_fail;
23473 }
23474 resultobj = SWIG_Py_Void();
23475 return resultobj;
23476 fail:
23477 return NULL;
23478 }
23479
23480
23481 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23482 PyObject *resultobj = 0;
23483 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23484 wxPoint *arg2 = 0 ;
23485 void *argp1 = 0 ;
23486 int res1 = 0 ;
23487 wxPoint temp2 ;
23488 PyObject * obj0 = 0 ;
23489 PyObject * obj1 = 0 ;
23490 char * kwnames[] = {
23491 (char *) "self",(char *) "pos", NULL
23492 };
23493
23494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23496 if (!SWIG_IsOK(res1)) {
23497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23498 }
23499 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23500 {
23501 arg2 = &temp2;
23502 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23503 }
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 (arg1)->SetPosition((wxPoint const &)*arg2);
23507 wxPyEndAllowThreads(__tstate);
23508 if (PyErr_Occurred()) SWIG_fail;
23509 }
23510 resultobj = SWIG_Py_Void();
23511 return resultobj;
23512 fail:
23513 return NULL;
23514 }
23515
23516
23517 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23518 PyObject *obj;
23519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23520 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23521 return SWIG_Py_Void();
23522 }
23523
23524 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23525 return SWIG_Python_InitShadowInstance(args);
23526 }
23527
23528 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23529 PyObject *resultobj = 0;
23530 int arg1 = (int) 0 ;
23531 wxPaintEvent *result = 0 ;
23532 int val1 ;
23533 int ecode1 = 0 ;
23534 PyObject * obj0 = 0 ;
23535 char * kwnames[] = {
23536 (char *) "Id", NULL
23537 };
23538
23539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23540 if (obj0) {
23541 ecode1 = SWIG_AsVal_int(obj0, &val1);
23542 if (!SWIG_IsOK(ecode1)) {
23543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23544 }
23545 arg1 = static_cast< int >(val1);
23546 }
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23550 wxPyEndAllowThreads(__tstate);
23551 if (PyErr_Occurred()) SWIG_fail;
23552 }
23553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23554 return resultobj;
23555 fail:
23556 return NULL;
23557 }
23558
23559
23560 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23561 PyObject *obj;
23562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23563 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23564 return SWIG_Py_Void();
23565 }
23566
23567 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23568 return SWIG_Python_InitShadowInstance(args);
23569 }
23570
23571 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23572 PyObject *resultobj = 0;
23573 int arg1 = (int) 0 ;
23574 wxNcPaintEvent *result = 0 ;
23575 int val1 ;
23576 int ecode1 = 0 ;
23577 PyObject * obj0 = 0 ;
23578 char * kwnames[] = {
23579 (char *) "winid", NULL
23580 };
23581
23582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23583 if (obj0) {
23584 ecode1 = SWIG_AsVal_int(obj0, &val1);
23585 if (!SWIG_IsOK(ecode1)) {
23586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23587 }
23588 arg1 = static_cast< int >(val1);
23589 }
23590 {
23591 PyThreadState* __tstate = wxPyBeginAllowThreads();
23592 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23597 return resultobj;
23598 fail:
23599 return NULL;
23600 }
23601
23602
23603 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23604 PyObject *obj;
23605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23606 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23607 return SWIG_Py_Void();
23608 }
23609
23610 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23611 return SWIG_Python_InitShadowInstance(args);
23612 }
23613
23614 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23615 PyObject *resultobj = 0;
23616 int arg1 = (int) 0 ;
23617 wxDC *arg2 = (wxDC *) NULL ;
23618 wxEraseEvent *result = 0 ;
23619 int val1 ;
23620 int ecode1 = 0 ;
23621 void *argp2 = 0 ;
23622 int res2 = 0 ;
23623 PyObject * obj0 = 0 ;
23624 PyObject * obj1 = 0 ;
23625 char * kwnames[] = {
23626 (char *) "Id",(char *) "dc", NULL
23627 };
23628
23629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23630 if (obj0) {
23631 ecode1 = SWIG_AsVal_int(obj0, &val1);
23632 if (!SWIG_IsOK(ecode1)) {
23633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23634 }
23635 arg1 = static_cast< int >(val1);
23636 }
23637 if (obj1) {
23638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23639 if (!SWIG_IsOK(res2)) {
23640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23641 }
23642 arg2 = reinterpret_cast< wxDC * >(argp2);
23643 }
23644 {
23645 PyThreadState* __tstate = wxPyBeginAllowThreads();
23646 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23647 wxPyEndAllowThreads(__tstate);
23648 if (PyErr_Occurred()) SWIG_fail;
23649 }
23650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23651 return resultobj;
23652 fail:
23653 return NULL;
23654 }
23655
23656
23657 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23658 PyObject *resultobj = 0;
23659 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23660 wxDC *result = 0 ;
23661 void *argp1 = 0 ;
23662 int res1 = 0 ;
23663 PyObject *swig_obj[1] ;
23664
23665 if (!args) SWIG_fail;
23666 swig_obj[0] = args;
23667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23668 if (!SWIG_IsOK(res1)) {
23669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23670 }
23671 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23672 {
23673 PyThreadState* __tstate = wxPyBeginAllowThreads();
23674 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 {
23679 resultobj = wxPyMake_wxObject(result, (bool)0);
23680 }
23681 return resultobj;
23682 fail:
23683 return NULL;
23684 }
23685
23686
23687 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23688 PyObject *obj;
23689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23690 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23691 return SWIG_Py_Void();
23692 }
23693
23694 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23695 return SWIG_Python_InitShadowInstance(args);
23696 }
23697
23698 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23699 PyObject *resultobj = 0;
23700 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23701 int arg2 = (int) 0 ;
23702 wxFocusEvent *result = 0 ;
23703 int val1 ;
23704 int ecode1 = 0 ;
23705 int val2 ;
23706 int ecode2 = 0 ;
23707 PyObject * obj0 = 0 ;
23708 PyObject * obj1 = 0 ;
23709 char * kwnames[] = {
23710 (char *) "type",(char *) "winid", NULL
23711 };
23712
23713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23714 if (obj0) {
23715 ecode1 = SWIG_AsVal_int(obj0, &val1);
23716 if (!SWIG_IsOK(ecode1)) {
23717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23718 }
23719 arg1 = static_cast< wxEventType >(val1);
23720 }
23721 if (obj1) {
23722 ecode2 = SWIG_AsVal_int(obj1, &val2);
23723 if (!SWIG_IsOK(ecode2)) {
23724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23725 }
23726 arg2 = static_cast< int >(val2);
23727 }
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23742 PyObject *resultobj = 0;
23743 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23744 wxWindow *result = 0 ;
23745 void *argp1 = 0 ;
23746 int res1 = 0 ;
23747 PyObject *swig_obj[1] ;
23748
23749 if (!args) SWIG_fail;
23750 swig_obj[0] = args;
23751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23752 if (!SWIG_IsOK(res1)) {
23753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23754 }
23755 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23756 {
23757 PyThreadState* __tstate = wxPyBeginAllowThreads();
23758 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23759 wxPyEndAllowThreads(__tstate);
23760 if (PyErr_Occurred()) SWIG_fail;
23761 }
23762 {
23763 resultobj = wxPyMake_wxObject(result, (bool)0);
23764 }
23765 return resultobj;
23766 fail:
23767 return NULL;
23768 }
23769
23770
23771 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23772 PyObject *resultobj = 0;
23773 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23774 wxWindow *arg2 = (wxWindow *) 0 ;
23775 void *argp1 = 0 ;
23776 int res1 = 0 ;
23777 void *argp2 = 0 ;
23778 int res2 = 0 ;
23779 PyObject * obj0 = 0 ;
23780 PyObject * obj1 = 0 ;
23781 char * kwnames[] = {
23782 (char *) "self",(char *) "win", NULL
23783 };
23784
23785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23787 if (!SWIG_IsOK(res1)) {
23788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23789 }
23790 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23791 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23792 if (!SWIG_IsOK(res2)) {
23793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23794 }
23795 arg2 = reinterpret_cast< wxWindow * >(argp2);
23796 {
23797 PyThreadState* __tstate = wxPyBeginAllowThreads();
23798 (arg1)->SetWindow(arg2);
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 resultobj = SWIG_Py_Void();
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 PyObject *obj;
23811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23812 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23813 return SWIG_Py_Void();
23814 }
23815
23816 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23817 return SWIG_Python_InitShadowInstance(args);
23818 }
23819
23820 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23821 PyObject *resultobj = 0;
23822 wxWindow *arg1 = (wxWindow *) NULL ;
23823 wxChildFocusEvent *result = 0 ;
23824 void *argp1 = 0 ;
23825 int res1 = 0 ;
23826 PyObject * obj0 = 0 ;
23827 char * kwnames[] = {
23828 (char *) "win", NULL
23829 };
23830
23831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23832 if (obj0) {
23833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23834 if (!SWIG_IsOK(res1)) {
23835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23836 }
23837 arg1 = reinterpret_cast< wxWindow * >(argp1);
23838 }
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23855 wxWindow *result = 0 ;
23856 void *argp1 = 0 ;
23857 int res1 = 0 ;
23858 PyObject *swig_obj[1] ;
23859
23860 if (!args) SWIG_fail;
23861 swig_obj[0] = args;
23862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23863 if (!SWIG_IsOK(res1)) {
23864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23865 }
23866 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 {
23874 resultobj = wxPyMake_wxObject(result, (bool)0);
23875 }
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23883 PyObject *obj;
23884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23885 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23886 return SWIG_Py_Void();
23887 }
23888
23889 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23890 return SWIG_Python_InitShadowInstance(args);
23891 }
23892
23893 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23894 PyObject *resultobj = 0;
23895 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23896 bool arg2 = (bool) true ;
23897 int arg3 = (int) 0 ;
23898 wxActivateEvent *result = 0 ;
23899 int val1 ;
23900 int ecode1 = 0 ;
23901 bool val2 ;
23902 int ecode2 = 0 ;
23903 int val3 ;
23904 int ecode3 = 0 ;
23905 PyObject * obj0 = 0 ;
23906 PyObject * obj1 = 0 ;
23907 PyObject * obj2 = 0 ;
23908 char * kwnames[] = {
23909 (char *) "type",(char *) "active",(char *) "Id", NULL
23910 };
23911
23912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23913 if (obj0) {
23914 ecode1 = SWIG_AsVal_int(obj0, &val1);
23915 if (!SWIG_IsOK(ecode1)) {
23916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23917 }
23918 arg1 = static_cast< wxEventType >(val1);
23919 }
23920 if (obj1) {
23921 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23922 if (!SWIG_IsOK(ecode2)) {
23923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23924 }
23925 arg2 = static_cast< bool >(val2);
23926 }
23927 if (obj2) {
23928 ecode3 = SWIG_AsVal_int(obj2, &val3);
23929 if (!SWIG_IsOK(ecode3)) {
23930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23931 }
23932 arg3 = static_cast< int >(val3);
23933 }
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948 PyObject *resultobj = 0;
23949 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23950 bool result;
23951 void *argp1 = 0 ;
23952 int res1 = 0 ;
23953 PyObject *swig_obj[1] ;
23954
23955 if (!args) SWIG_fail;
23956 swig_obj[0] = args;
23957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23958 if (!SWIG_IsOK(res1)) {
23959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23960 }
23961 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 {
23969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23978 PyObject *obj;
23979 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23980 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23981 return SWIG_Py_Void();
23982 }
23983
23984 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23985 return SWIG_Python_InitShadowInstance(args);
23986 }
23987
23988 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23989 PyObject *resultobj = 0;
23990 int arg1 = (int) 0 ;
23991 wxInitDialogEvent *result = 0 ;
23992 int val1 ;
23993 int ecode1 = 0 ;
23994 PyObject * obj0 = 0 ;
23995 char * kwnames[] = {
23996 (char *) "Id", NULL
23997 };
23998
23999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24000 if (obj0) {
24001 ecode1 = SWIG_AsVal_int(obj0, &val1);
24002 if (!SWIG_IsOK(ecode1)) {
24003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24004 }
24005 arg1 = static_cast< int >(val1);
24006 }
24007 {
24008 PyThreadState* __tstate = wxPyBeginAllowThreads();
24009 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24014 return resultobj;
24015 fail:
24016 return NULL;
24017 }
24018
24019
24020 SWIGINTERN PyObject *InitDialogEvent_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_wxInitDialogEvent, SWIG_NewClientData(obj));
24024 return SWIG_Py_Void();
24025 }
24026
24027 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24028 return SWIG_Python_InitShadowInstance(args);
24029 }
24030
24031 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24032 PyObject *resultobj = 0;
24033 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24034 int arg2 = (int) 0 ;
24035 wxMenu *arg3 = (wxMenu *) NULL ;
24036 wxMenuEvent *result = 0 ;
24037 int val1 ;
24038 int ecode1 = 0 ;
24039 int val2 ;
24040 int ecode2 = 0 ;
24041 void *argp3 = 0 ;
24042 int res3 = 0 ;
24043 PyObject * obj0 = 0 ;
24044 PyObject * obj1 = 0 ;
24045 PyObject * obj2 = 0 ;
24046 char * kwnames[] = {
24047 (char *) "type",(char *) "winid",(char *) "menu", NULL
24048 };
24049
24050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",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_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24055 }
24056 arg1 = static_cast< wxEventType >(val1);
24057 }
24058 if (obj1) {
24059 ecode2 = SWIG_AsVal_int(obj1, &val2);
24060 if (!SWIG_IsOK(ecode2)) {
24061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24062 }
24063 arg2 = static_cast< int >(val2);
24064 }
24065 if (obj2) {
24066 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24067 if (!SWIG_IsOK(res3)) {
24068 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24069 }
24070 arg3 = reinterpret_cast< wxMenu * >(argp3);
24071 }
24072 {
24073 PyThreadState* __tstate = wxPyBeginAllowThreads();
24074 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24079 return resultobj;
24080 fail:
24081 return NULL;
24082 }
24083
24084
24085 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24086 PyObject *resultobj = 0;
24087 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24088 int 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_wxMenuEvent, 0 | 0 );
24096 if (!SWIG_IsOK(res1)) {
24097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24098 }
24099 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 resultobj = SWIG_From_int(static_cast< int >(result));
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24114 PyObject *resultobj = 0;
24115 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24116 bool result;
24117 void *argp1 = 0 ;
24118 int res1 = 0 ;
24119 PyObject *swig_obj[1] ;
24120
24121 if (!args) SWIG_fail;
24122 swig_obj[0] = args;
24123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24124 if (!SWIG_IsOK(res1)) {
24125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24126 }
24127 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24131 wxPyEndAllowThreads(__tstate);
24132 if (PyErr_Occurred()) SWIG_fail;
24133 }
24134 {
24135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24136 }
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24144 PyObject *resultobj = 0;
24145 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24146 wxMenu *result = 0 ;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 PyObject *swig_obj[1] ;
24150
24151 if (!args) SWIG_fail;
24152 swig_obj[0] = args;
24153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24154 if (!SWIG_IsOK(res1)) {
24155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24156 }
24157 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24161 wxPyEndAllowThreads(__tstate);
24162 if (PyErr_Occurred()) SWIG_fail;
24163 }
24164 {
24165 resultobj = wxPyMake_wxObject(result, (bool)0);
24166 }
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24174 PyObject *obj;
24175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24176 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24177 return SWIG_Py_Void();
24178 }
24179
24180 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24181 return SWIG_Python_InitShadowInstance(args);
24182 }
24183
24184 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24185 PyObject *resultobj = 0;
24186 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24187 int arg2 = (int) 0 ;
24188 wxCloseEvent *result = 0 ;
24189 int val1 ;
24190 int ecode1 = 0 ;
24191 int val2 ;
24192 int ecode2 = 0 ;
24193 PyObject * obj0 = 0 ;
24194 PyObject * obj1 = 0 ;
24195 char * kwnames[] = {
24196 (char *) "type",(char *) "winid", NULL
24197 };
24198
24199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24200 if (obj0) {
24201 ecode1 = SWIG_AsVal_int(obj0, &val1);
24202 if (!SWIG_IsOK(ecode1)) {
24203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24204 }
24205 arg1 = static_cast< wxEventType >(val1);
24206 }
24207 if (obj1) {
24208 ecode2 = SWIG_AsVal_int(obj1, &val2);
24209 if (!SWIG_IsOK(ecode2)) {
24210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24211 }
24212 arg2 = static_cast< int >(val2);
24213 }
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj = 0;
24229 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24230 bool arg2 ;
24231 void *argp1 = 0 ;
24232 int res1 = 0 ;
24233 bool val2 ;
24234 int ecode2 = 0 ;
24235 PyObject * obj0 = 0 ;
24236 PyObject * obj1 = 0 ;
24237 char * kwnames[] = {
24238 (char *) "self",(char *) "logOff", NULL
24239 };
24240
24241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24243 if (!SWIG_IsOK(res1)) {
24244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24245 }
24246 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24247 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24248 if (!SWIG_IsOK(ecode2)) {
24249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24250 }
24251 arg2 = static_cast< bool >(val2);
24252 {
24253 PyThreadState* __tstate = wxPyBeginAllowThreads();
24254 (arg1)->SetLoggingOff(arg2);
24255 wxPyEndAllowThreads(__tstate);
24256 if (PyErr_Occurred()) SWIG_fail;
24257 }
24258 resultobj = SWIG_Py_Void();
24259 return resultobj;
24260 fail:
24261 return NULL;
24262 }
24263
24264
24265 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24266 PyObject *resultobj = 0;
24267 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24268 bool result;
24269 void *argp1 = 0 ;
24270 int res1 = 0 ;
24271 PyObject *swig_obj[1] ;
24272
24273 if (!args) SWIG_fail;
24274 swig_obj[0] = args;
24275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24278 }
24279 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24283 wxPyEndAllowThreads(__tstate);
24284 if (PyErr_Occurred()) SWIG_fail;
24285 }
24286 {
24287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24288 }
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj = 0;
24297 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24298 bool arg2 = (bool) true ;
24299 void *argp1 = 0 ;
24300 int res1 = 0 ;
24301 bool val2 ;
24302 int ecode2 = 0 ;
24303 PyObject * obj0 = 0 ;
24304 PyObject * obj1 = 0 ;
24305 char * kwnames[] = {
24306 (char *) "self",(char *) "veto", NULL
24307 };
24308
24309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24311 if (!SWIG_IsOK(res1)) {
24312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24313 }
24314 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24315 if (obj1) {
24316 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24317 if (!SWIG_IsOK(ecode2)) {
24318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24319 }
24320 arg2 = static_cast< bool >(val2);
24321 }
24322 {
24323 PyThreadState* __tstate = wxPyBeginAllowThreads();
24324 (arg1)->Veto(arg2);
24325 wxPyEndAllowThreads(__tstate);
24326 if (PyErr_Occurred()) SWIG_fail;
24327 }
24328 resultobj = SWIG_Py_Void();
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24336 PyObject *resultobj = 0;
24337 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24338 bool result;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 PyObject *swig_obj[1] ;
24342
24343 if (!args) SWIG_fail;
24344 swig_obj[0] = args;
24345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24346 if (!SWIG_IsOK(res1)) {
24347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24348 }
24349 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24350 {
24351 PyThreadState* __tstate = wxPyBeginAllowThreads();
24352 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24353 wxPyEndAllowThreads(__tstate);
24354 if (PyErr_Occurred()) SWIG_fail;
24355 }
24356 {
24357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24358 }
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(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 *) "canVeto", NULL
24377 };
24378
24379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",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_SetCanVeto" "', 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_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24388 }
24389 arg2 = static_cast< bool >(val2);
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 (arg1)->SetCanVeto(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_CanVeto(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_CanVeto" "', 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)->CanVeto();
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 *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24434 PyObject *obj;
24435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24436 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24437 return SWIG_Py_Void();
24438 }
24439
24440 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24441 return SWIG_Python_InitShadowInstance(args);
24442 }
24443
24444 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24445 PyObject *resultobj = 0;
24446 int arg1 = (int) 0 ;
24447 bool arg2 = (bool) false ;
24448 wxShowEvent *result = 0 ;
24449 int val1 ;
24450 int ecode1 = 0 ;
24451 bool val2 ;
24452 int ecode2 = 0 ;
24453 PyObject * obj0 = 0 ;
24454 PyObject * obj1 = 0 ;
24455 char * kwnames[] = {
24456 (char *) "winid",(char *) "show", NULL
24457 };
24458
24459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24460 if (obj0) {
24461 ecode1 = SWIG_AsVal_int(obj0, &val1);
24462 if (!SWIG_IsOK(ecode1)) {
24463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24464 }
24465 arg1 = static_cast< int >(val1);
24466 }
24467 if (obj1) {
24468 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24469 if (!SWIG_IsOK(ecode2)) {
24470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24471 }
24472 arg2 = static_cast< bool >(val2);
24473 }
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24477 wxPyEndAllowThreads(__tstate);
24478 if (PyErr_Occurred()) SWIG_fail;
24479 }
24480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24488 PyObject *resultobj = 0;
24489 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24490 bool arg2 ;
24491 void *argp1 = 0 ;
24492 int res1 = 0 ;
24493 bool val2 ;
24494 int ecode2 = 0 ;
24495 PyObject * obj0 = 0 ;
24496 PyObject * obj1 = 0 ;
24497 char * kwnames[] = {
24498 (char *) "self",(char *) "show", NULL
24499 };
24500
24501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24503 if (!SWIG_IsOK(res1)) {
24504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24505 }
24506 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24507 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24508 if (!SWIG_IsOK(ecode2)) {
24509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24510 }
24511 arg2 = static_cast< bool >(val2);
24512 {
24513 PyThreadState* __tstate = wxPyBeginAllowThreads();
24514 (arg1)->SetShow(arg2);
24515 wxPyEndAllowThreads(__tstate);
24516 if (PyErr_Occurred()) SWIG_fail;
24517 }
24518 resultobj = SWIG_Py_Void();
24519 return resultobj;
24520 fail:
24521 return NULL;
24522 }
24523
24524
24525 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24526 PyObject *resultobj = 0;
24527 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24528 bool result;
24529 void *argp1 = 0 ;
24530 int res1 = 0 ;
24531 PyObject *swig_obj[1] ;
24532
24533 if (!args) SWIG_fail;
24534 swig_obj[0] = args;
24535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24536 if (!SWIG_IsOK(res1)) {
24537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24538 }
24539 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24540 {
24541 PyThreadState* __tstate = wxPyBeginAllowThreads();
24542 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24543 wxPyEndAllowThreads(__tstate);
24544 if (PyErr_Occurred()) SWIG_fail;
24545 }
24546 {
24547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24548 }
24549 return resultobj;
24550 fail:
24551 return NULL;
24552 }
24553
24554
24555 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24556 PyObject *obj;
24557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24558 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24559 return SWIG_Py_Void();
24560 }
24561
24562 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24563 return SWIG_Python_InitShadowInstance(args);
24564 }
24565
24566 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24567 PyObject *resultobj = 0;
24568 int arg1 = (int) 0 ;
24569 bool arg2 = (bool) true ;
24570 wxIconizeEvent *result = 0 ;
24571 int val1 ;
24572 int ecode1 = 0 ;
24573 bool val2 ;
24574 int ecode2 = 0 ;
24575 PyObject * obj0 = 0 ;
24576 PyObject * obj1 = 0 ;
24577 char * kwnames[] = {
24578 (char *) "id",(char *) "iconized", NULL
24579 };
24580
24581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24582 if (obj0) {
24583 ecode1 = SWIG_AsVal_int(obj0, &val1);
24584 if (!SWIG_IsOK(ecode1)) {
24585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24586 }
24587 arg1 = static_cast< int >(val1);
24588 }
24589 if (obj1) {
24590 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24591 if (!SWIG_IsOK(ecode2)) {
24592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24593 }
24594 arg2 = static_cast< bool >(val2);
24595 }
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24599 wxPyEndAllowThreads(__tstate);
24600 if (PyErr_Occurred()) SWIG_fail;
24601 }
24602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24603 return resultobj;
24604 fail:
24605 return NULL;
24606 }
24607
24608
24609 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24610 PyObject *resultobj = 0;
24611 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24612 bool result;
24613 void *argp1 = 0 ;
24614 int res1 = 0 ;
24615 PyObject *swig_obj[1] ;
24616
24617 if (!args) SWIG_fail;
24618 swig_obj[0] = args;
24619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24620 if (!SWIG_IsOK(res1)) {
24621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24622 }
24623 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24624 {
24625 PyThreadState* __tstate = wxPyBeginAllowThreads();
24626 result = (bool)(arg1)->Iconized();
24627 wxPyEndAllowThreads(__tstate);
24628 if (PyErr_Occurred()) SWIG_fail;
24629 }
24630 {
24631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24632 }
24633 return resultobj;
24634 fail:
24635 return NULL;
24636 }
24637
24638
24639 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24640 PyObject *obj;
24641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24642 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24643 return SWIG_Py_Void();
24644 }
24645
24646 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24647 return SWIG_Python_InitShadowInstance(args);
24648 }
24649
24650 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24651 PyObject *resultobj = 0;
24652 int arg1 = (int) 0 ;
24653 wxMaximizeEvent *result = 0 ;
24654 int val1 ;
24655 int ecode1 = 0 ;
24656 PyObject * obj0 = 0 ;
24657 char * kwnames[] = {
24658 (char *) "id", NULL
24659 };
24660
24661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24662 if (obj0) {
24663 ecode1 = SWIG_AsVal_int(obj0, &val1);
24664 if (!SWIG_IsOK(ecode1)) {
24665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24666 }
24667 arg1 = static_cast< int >(val1);
24668 }
24669 {
24670 PyThreadState* __tstate = wxPyBeginAllowThreads();
24671 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24672 wxPyEndAllowThreads(__tstate);
24673 if (PyErr_Occurred()) SWIG_fail;
24674 }
24675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24676 return resultobj;
24677 fail:
24678 return NULL;
24679 }
24680
24681
24682 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24683 PyObject *obj;
24684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24685 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24686 return SWIG_Py_Void();
24687 }
24688
24689 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24690 return SWIG_Python_InitShadowInstance(args);
24691 }
24692
24693 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24694 PyObject *resultobj = 0;
24695 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24696 wxPoint result;
24697 void *argp1 = 0 ;
24698 int res1 = 0 ;
24699 PyObject *swig_obj[1] ;
24700
24701 if (!args) SWIG_fail;
24702 swig_obj[0] = args;
24703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24704 if (!SWIG_IsOK(res1)) {
24705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24706 }
24707 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 result = (arg1)->GetPosition();
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24715 return resultobj;
24716 fail:
24717 return NULL;
24718 }
24719
24720
24721 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24722 PyObject *resultobj = 0;
24723 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24724 int result;
24725 void *argp1 = 0 ;
24726 int res1 = 0 ;
24727 PyObject *swig_obj[1] ;
24728
24729 if (!args) SWIG_fail;
24730 swig_obj[0] = args;
24731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24732 if (!SWIG_IsOK(res1)) {
24733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24734 }
24735 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 result = (int)(arg1)->GetNumberOfFiles();
24739 wxPyEndAllowThreads(__tstate);
24740 if (PyErr_Occurred()) SWIG_fail;
24741 }
24742 resultobj = SWIG_From_int(static_cast< int >(result));
24743 return resultobj;
24744 fail:
24745 return NULL;
24746 }
24747
24748
24749 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24750 PyObject *resultobj = 0;
24751 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24752 PyObject *result = 0 ;
24753 void *argp1 = 0 ;
24754 int res1 = 0 ;
24755 PyObject *swig_obj[1] ;
24756
24757 if (!args) SWIG_fail;
24758 swig_obj[0] = args;
24759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24760 if (!SWIG_IsOK(res1)) {
24761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24762 }
24763 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24764 {
24765 PyThreadState* __tstate = wxPyBeginAllowThreads();
24766 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24767 wxPyEndAllowThreads(__tstate);
24768 if (PyErr_Occurred()) SWIG_fail;
24769 }
24770 resultobj = result;
24771 return resultobj;
24772 fail:
24773 return NULL;
24774 }
24775
24776
24777 SWIGINTERN PyObject *DropFilesEvent_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_wxDropFilesEvent, SWIG_NewClientData(obj));
24781 return SWIG_Py_Void();
24782 }
24783
24784 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24785 PyObject *resultobj = 0;
24786 int arg1 = (int) 0 ;
24787 wxUpdateUIEvent *result = 0 ;
24788 int val1 ;
24789 int ecode1 = 0 ;
24790 PyObject * obj0 = 0 ;
24791 char * kwnames[] = {
24792 (char *) "commandId", NULL
24793 };
24794
24795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24796 if (obj0) {
24797 ecode1 = SWIG_AsVal_int(obj0, &val1);
24798 if (!SWIG_IsOK(ecode1)) {
24799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24800 }
24801 arg1 = static_cast< int >(val1);
24802 }
24803 {
24804 PyThreadState* __tstate = wxPyBeginAllowThreads();
24805 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24810 return resultobj;
24811 fail:
24812 return NULL;
24813 }
24814
24815
24816 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24817 PyObject *resultobj = 0;
24818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24819 bool result;
24820 void *argp1 = 0 ;
24821 int res1 = 0 ;
24822 PyObject *swig_obj[1] ;
24823
24824 if (!args) SWIG_fail;
24825 swig_obj[0] = args;
24826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24827 if (!SWIG_IsOK(res1)) {
24828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24829 }
24830 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24831 {
24832 PyThreadState* __tstate = wxPyBeginAllowThreads();
24833 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24834 wxPyEndAllowThreads(__tstate);
24835 if (PyErr_Occurred()) SWIG_fail;
24836 }
24837 {
24838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24839 }
24840 return resultobj;
24841 fail:
24842 return NULL;
24843 }
24844
24845
24846 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24847 PyObject *resultobj = 0;
24848 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24849 bool result;
24850 void *argp1 = 0 ;
24851 int res1 = 0 ;
24852 PyObject *swig_obj[1] ;
24853
24854 if (!args) SWIG_fail;
24855 swig_obj[0] = args;
24856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24859 }
24860 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24861 {
24862 PyThreadState* __tstate = wxPyBeginAllowThreads();
24863 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 {
24868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24869 }
24870 return resultobj;
24871 fail:
24872 return NULL;
24873 }
24874
24875
24876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24877 PyObject *resultobj = 0;
24878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24879 bool result;
24880 void *argp1 = 0 ;
24881 int res1 = 0 ;
24882 PyObject *swig_obj[1] ;
24883
24884 if (!args) SWIG_fail;
24885 swig_obj[0] = args;
24886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24887 if (!SWIG_IsOK(res1)) {
24888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24889 }
24890 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 {
24898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24899 }
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24907 PyObject *resultobj = 0;
24908 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24909 wxString result;
24910 void *argp1 = 0 ;
24911 int res1 = 0 ;
24912 PyObject *swig_obj[1] ;
24913
24914 if (!args) SWIG_fail;
24915 swig_obj[0] = args;
24916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24917 if (!SWIG_IsOK(res1)) {
24918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24919 }
24920 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24921 {
24922 PyThreadState* __tstate = wxPyBeginAllowThreads();
24923 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24924 wxPyEndAllowThreads(__tstate);
24925 if (PyErr_Occurred()) SWIG_fail;
24926 }
24927 {
24928 #if wxUSE_UNICODE
24929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24930 #else
24931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24932 #endif
24933 }
24934 return resultobj;
24935 fail:
24936 return NULL;
24937 }
24938
24939
24940 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24941 PyObject *resultobj = 0;
24942 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24943 bool result;
24944 void *argp1 = 0 ;
24945 int res1 = 0 ;
24946 PyObject *swig_obj[1] ;
24947
24948 if (!args) SWIG_fail;
24949 swig_obj[0] = args;
24950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24951 if (!SWIG_IsOK(res1)) {
24952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24953 }
24954 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24955 {
24956 PyThreadState* __tstate = wxPyBeginAllowThreads();
24957 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24958 wxPyEndAllowThreads(__tstate);
24959 if (PyErr_Occurred()) SWIG_fail;
24960 }
24961 {
24962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24963 }
24964 return resultobj;
24965 fail:
24966 return NULL;
24967 }
24968
24969
24970 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24971 PyObject *resultobj = 0;
24972 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24973 bool result;
24974 void *argp1 = 0 ;
24975 int res1 = 0 ;
24976 PyObject *swig_obj[1] ;
24977
24978 if (!args) SWIG_fail;
24979 swig_obj[0] = args;
24980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24981 if (!SWIG_IsOK(res1)) {
24982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24983 }
24984 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24985 {
24986 PyThreadState* __tstate = wxPyBeginAllowThreads();
24987 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24988 wxPyEndAllowThreads(__tstate);
24989 if (PyErr_Occurred()) SWIG_fail;
24990 }
24991 {
24992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24993 }
24994 return resultobj;
24995 fail:
24996 return NULL;
24997 }
24998
24999
25000 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25001 PyObject *resultobj = 0;
25002 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25003 bool result;
25004 void *argp1 = 0 ;
25005 int res1 = 0 ;
25006 PyObject *swig_obj[1] ;
25007
25008 if (!args) SWIG_fail;
25009 swig_obj[0] = args;
25010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25011 if (!SWIG_IsOK(res1)) {
25012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25013 }
25014 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25015 {
25016 PyThreadState* __tstate = wxPyBeginAllowThreads();
25017 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25018 wxPyEndAllowThreads(__tstate);
25019 if (PyErr_Occurred()) SWIG_fail;
25020 }
25021 {
25022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25023 }
25024 return resultobj;
25025 fail:
25026 return NULL;
25027 }
25028
25029
25030 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25031 PyObject *resultobj = 0;
25032 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25033 bool result;
25034 void *argp1 = 0 ;
25035 int res1 = 0 ;
25036 PyObject *swig_obj[1] ;
25037
25038 if (!args) SWIG_fail;
25039 swig_obj[0] = args;
25040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25041 if (!SWIG_IsOK(res1)) {
25042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25043 }
25044 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25045 {
25046 PyThreadState* __tstate = wxPyBeginAllowThreads();
25047 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25048 wxPyEndAllowThreads(__tstate);
25049 if (PyErr_Occurred()) SWIG_fail;
25050 }
25051 {
25052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25053 }
25054 return resultobj;
25055 fail:
25056 return NULL;
25057 }
25058
25059
25060 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25061 PyObject *resultobj = 0;
25062 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25063 bool arg2 ;
25064 void *argp1 = 0 ;
25065 int res1 = 0 ;
25066 bool val2 ;
25067 int ecode2 = 0 ;
25068 PyObject * obj0 = 0 ;
25069 PyObject * obj1 = 0 ;
25070 char * kwnames[] = {
25071 (char *) "self",(char *) "check", NULL
25072 };
25073
25074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25076 if (!SWIG_IsOK(res1)) {
25077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25078 }
25079 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25081 if (!SWIG_IsOK(ecode2)) {
25082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25083 }
25084 arg2 = static_cast< bool >(val2);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 (arg1)->Check(arg2);
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_Py_Void();
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25099 PyObject *resultobj = 0;
25100 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25101 bool arg2 ;
25102 void *argp1 = 0 ;
25103 int res1 = 0 ;
25104 bool val2 ;
25105 int ecode2 = 0 ;
25106 PyObject * obj0 = 0 ;
25107 PyObject * obj1 = 0 ;
25108 char * kwnames[] = {
25109 (char *) "self",(char *) "enable", NULL
25110 };
25111
25112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25114 if (!SWIG_IsOK(res1)) {
25115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25116 }
25117 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25118 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25119 if (!SWIG_IsOK(ecode2)) {
25120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25121 }
25122 arg2 = static_cast< bool >(val2);
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 (arg1)->Enable(arg2);
25126 wxPyEndAllowThreads(__tstate);
25127 if (PyErr_Occurred()) SWIG_fail;
25128 }
25129 resultobj = SWIG_Py_Void();
25130 return resultobj;
25131 fail:
25132 return NULL;
25133 }
25134
25135
25136 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25137 PyObject *resultobj = 0;
25138 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25139 bool arg2 ;
25140 void *argp1 = 0 ;
25141 int res1 = 0 ;
25142 bool val2 ;
25143 int ecode2 = 0 ;
25144 PyObject * obj0 = 0 ;
25145 PyObject * obj1 = 0 ;
25146 char * kwnames[] = {
25147 (char *) "self",(char *) "show", NULL
25148 };
25149
25150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25152 if (!SWIG_IsOK(res1)) {
25153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25154 }
25155 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25156 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25157 if (!SWIG_IsOK(ecode2)) {
25158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25159 }
25160 arg2 = static_cast< bool >(val2);
25161 {
25162 PyThreadState* __tstate = wxPyBeginAllowThreads();
25163 (arg1)->Show(arg2);
25164 wxPyEndAllowThreads(__tstate);
25165 if (PyErr_Occurred()) SWIG_fail;
25166 }
25167 resultobj = SWIG_Py_Void();
25168 return resultobj;
25169 fail:
25170 return NULL;
25171 }
25172
25173
25174 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25175 PyObject *resultobj = 0;
25176 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25177 wxString *arg2 = 0 ;
25178 void *argp1 = 0 ;
25179 int res1 = 0 ;
25180 bool temp2 = false ;
25181 PyObject * obj0 = 0 ;
25182 PyObject * obj1 = 0 ;
25183 char * kwnames[] = {
25184 (char *) "self",(char *) "text", NULL
25185 };
25186
25187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25189 if (!SWIG_IsOK(res1)) {
25190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25191 }
25192 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25193 {
25194 arg2 = wxString_in_helper(obj1);
25195 if (arg2 == NULL) SWIG_fail;
25196 temp2 = true;
25197 }
25198 {
25199 PyThreadState* __tstate = wxPyBeginAllowThreads();
25200 (arg1)->SetText((wxString const &)*arg2);
25201 wxPyEndAllowThreads(__tstate);
25202 if (PyErr_Occurred()) SWIG_fail;
25203 }
25204 resultobj = SWIG_Py_Void();
25205 {
25206 if (temp2)
25207 delete arg2;
25208 }
25209 return resultobj;
25210 fail:
25211 {
25212 if (temp2)
25213 delete arg2;
25214 }
25215 return NULL;
25216 }
25217
25218
25219 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25220 PyObject *resultobj = 0;
25221 long arg1 ;
25222 long val1 ;
25223 int ecode1 = 0 ;
25224 PyObject * obj0 = 0 ;
25225 char * kwnames[] = {
25226 (char *) "updateInterval", NULL
25227 };
25228
25229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25230 ecode1 = SWIG_AsVal_long(obj0, &val1);
25231 if (!SWIG_IsOK(ecode1)) {
25232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25233 }
25234 arg1 = static_cast< long >(val1);
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 wxUpdateUIEvent::SetUpdateInterval(arg1);
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 resultobj = SWIG_Py_Void();
25242 return resultobj;
25243 fail:
25244 return NULL;
25245 }
25246
25247
25248 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25249 PyObject *resultobj = 0;
25250 long result;
25251
25252 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25253 {
25254 PyThreadState* __tstate = wxPyBeginAllowThreads();
25255 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 resultobj = SWIG_From_long(static_cast< long >(result));
25260 return resultobj;
25261 fail:
25262 return NULL;
25263 }
25264
25265
25266 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25267 PyObject *resultobj = 0;
25268 wxWindow *arg1 = (wxWindow *) 0 ;
25269 bool result;
25270 void *argp1 = 0 ;
25271 int res1 = 0 ;
25272 PyObject * obj0 = 0 ;
25273 char * kwnames[] = {
25274 (char *) "win", NULL
25275 };
25276
25277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25279 if (!SWIG_IsOK(res1)) {
25280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25281 }
25282 arg1 = reinterpret_cast< wxWindow * >(argp1);
25283 {
25284 PyThreadState* __tstate = wxPyBeginAllowThreads();
25285 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25286 wxPyEndAllowThreads(__tstate);
25287 if (PyErr_Occurred()) SWIG_fail;
25288 }
25289 {
25290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25291 }
25292 return resultobj;
25293 fail:
25294 return NULL;
25295 }
25296
25297
25298 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25299 PyObject *resultobj = 0;
25300
25301 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25302 {
25303 PyThreadState* __tstate = wxPyBeginAllowThreads();
25304 wxUpdateUIEvent::ResetUpdateTime();
25305 wxPyEndAllowThreads(__tstate);
25306 if (PyErr_Occurred()) SWIG_fail;
25307 }
25308 resultobj = SWIG_Py_Void();
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25316 PyObject *resultobj = 0;
25317 wxUpdateUIMode arg1 ;
25318 int val1 ;
25319 int ecode1 = 0 ;
25320 PyObject * obj0 = 0 ;
25321 char * kwnames[] = {
25322 (char *) "mode", NULL
25323 };
25324
25325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25326 ecode1 = SWIG_AsVal_int(obj0, &val1);
25327 if (!SWIG_IsOK(ecode1)) {
25328 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25329 }
25330 arg1 = static_cast< wxUpdateUIMode >(val1);
25331 {
25332 PyThreadState* __tstate = wxPyBeginAllowThreads();
25333 wxUpdateUIEvent::SetMode(arg1);
25334 wxPyEndAllowThreads(__tstate);
25335 if (PyErr_Occurred()) SWIG_fail;
25336 }
25337 resultobj = SWIG_Py_Void();
25338 return resultobj;
25339 fail:
25340 return NULL;
25341 }
25342
25343
25344 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25345 PyObject *resultobj = 0;
25346 wxUpdateUIMode result;
25347
25348 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25349 {
25350 PyThreadState* __tstate = wxPyBeginAllowThreads();
25351 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25352 wxPyEndAllowThreads(__tstate);
25353 if (PyErr_Occurred()) SWIG_fail;
25354 }
25355 resultobj = SWIG_From_int(static_cast< int >(result));
25356 return resultobj;
25357 fail:
25358 return NULL;
25359 }
25360
25361
25362 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25363 PyObject *obj;
25364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25365 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25366 return SWIG_Py_Void();
25367 }
25368
25369 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25370 return SWIG_Python_InitShadowInstance(args);
25371 }
25372
25373 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25374 PyObject *resultobj = 0;
25375 wxSysColourChangedEvent *result = 0 ;
25376
25377 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25378 {
25379 PyThreadState* __tstate = wxPyBeginAllowThreads();
25380 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25385 return resultobj;
25386 fail:
25387 return NULL;
25388 }
25389
25390
25391 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25392 PyObject *obj;
25393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25394 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25395 return SWIG_Py_Void();
25396 }
25397
25398 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25399 return SWIG_Python_InitShadowInstance(args);
25400 }
25401
25402 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25403 PyObject *resultobj = 0;
25404 int arg1 = (int) 0 ;
25405 wxWindow *arg2 = (wxWindow *) NULL ;
25406 wxMouseCaptureChangedEvent *result = 0 ;
25407 int val1 ;
25408 int ecode1 = 0 ;
25409 void *argp2 = 0 ;
25410 int res2 = 0 ;
25411 PyObject * obj0 = 0 ;
25412 PyObject * obj1 = 0 ;
25413 char * kwnames[] = {
25414 (char *) "winid",(char *) "gainedCapture", NULL
25415 };
25416
25417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25418 if (obj0) {
25419 ecode1 = SWIG_AsVal_int(obj0, &val1);
25420 if (!SWIG_IsOK(ecode1)) {
25421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25422 }
25423 arg1 = static_cast< int >(val1);
25424 }
25425 if (obj1) {
25426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25427 if (!SWIG_IsOK(res2)) {
25428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25429 }
25430 arg2 = reinterpret_cast< wxWindow * >(argp2);
25431 }
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25439 return resultobj;
25440 fail:
25441 return NULL;
25442 }
25443
25444
25445 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25446 PyObject *resultobj = 0;
25447 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25448 wxWindow *result = 0 ;
25449 void *argp1 = 0 ;
25450 int res1 = 0 ;
25451 PyObject *swig_obj[1] ;
25452
25453 if (!args) SWIG_fail;
25454 swig_obj[0] = args;
25455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25456 if (!SWIG_IsOK(res1)) {
25457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25458 }
25459 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25463 wxPyEndAllowThreads(__tstate);
25464 if (PyErr_Occurred()) SWIG_fail;
25465 }
25466 {
25467 resultobj = wxPyMake_wxObject(result, (bool)0);
25468 }
25469 return resultobj;
25470 fail:
25471 return NULL;
25472 }
25473
25474
25475 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25476 PyObject *obj;
25477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25478 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25479 return SWIG_Py_Void();
25480 }
25481
25482 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25483 return SWIG_Python_InitShadowInstance(args);
25484 }
25485
25486 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25487 PyObject *resultobj = 0;
25488 int arg1 = (int) 0 ;
25489 wxMouseCaptureLostEvent *result = 0 ;
25490 int val1 ;
25491 int ecode1 = 0 ;
25492 PyObject * obj0 = 0 ;
25493 char * kwnames[] = {
25494 (char *) "winid", NULL
25495 };
25496
25497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25498 if (obj0) {
25499 ecode1 = SWIG_AsVal_int(obj0, &val1);
25500 if (!SWIG_IsOK(ecode1)) {
25501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25502 }
25503 arg1 = static_cast< int >(val1);
25504 }
25505 {
25506 PyThreadState* __tstate = wxPyBeginAllowThreads();
25507 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25508 wxPyEndAllowThreads(__tstate);
25509 if (PyErr_Occurred()) SWIG_fail;
25510 }
25511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25512 return resultobj;
25513 fail:
25514 return NULL;
25515 }
25516
25517
25518 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25519 PyObject *obj;
25520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25521 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25522 return SWIG_Py_Void();
25523 }
25524
25525 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25526 return SWIG_Python_InitShadowInstance(args);
25527 }
25528
25529 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25530 PyObject *resultobj = 0;
25531 wxDisplayChangedEvent *result = 0 ;
25532
25533 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25534 {
25535 PyThreadState* __tstate = wxPyBeginAllowThreads();
25536 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25537 wxPyEndAllowThreads(__tstate);
25538 if (PyErr_Occurred()) SWIG_fail;
25539 }
25540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25541 return resultobj;
25542 fail:
25543 return NULL;
25544 }
25545
25546
25547 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25548 PyObject *obj;
25549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25550 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25551 return SWIG_Py_Void();
25552 }
25553
25554 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25555 return SWIG_Python_InitShadowInstance(args);
25556 }
25557
25558 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25559 PyObject *resultobj = 0;
25560 int arg1 = (int) 0 ;
25561 wxPaletteChangedEvent *result = 0 ;
25562 int val1 ;
25563 int ecode1 = 0 ;
25564 PyObject * obj0 = 0 ;
25565 char * kwnames[] = {
25566 (char *) "id", NULL
25567 };
25568
25569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25570 if (obj0) {
25571 ecode1 = SWIG_AsVal_int(obj0, &val1);
25572 if (!SWIG_IsOK(ecode1)) {
25573 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25574 }
25575 arg1 = static_cast< int >(val1);
25576 }
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj = 0;
25592 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25593 wxWindow *arg2 = (wxWindow *) 0 ;
25594 void *argp1 = 0 ;
25595 int res1 = 0 ;
25596 void *argp2 = 0 ;
25597 int res2 = 0 ;
25598 PyObject * obj0 = 0 ;
25599 PyObject * obj1 = 0 ;
25600 char * kwnames[] = {
25601 (char *) "self",(char *) "win", NULL
25602 };
25603
25604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25606 if (!SWIG_IsOK(res1)) {
25607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25608 }
25609 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25611 if (!SWIG_IsOK(res2)) {
25612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25613 }
25614 arg2 = reinterpret_cast< wxWindow * >(argp2);
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 (arg1)->SetChangedWindow(arg2);
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 resultobj = SWIG_Py_Void();
25622 return resultobj;
25623 fail:
25624 return NULL;
25625 }
25626
25627
25628 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25629 PyObject *resultobj = 0;
25630 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25631 wxWindow *result = 0 ;
25632 void *argp1 = 0 ;
25633 int res1 = 0 ;
25634 PyObject *swig_obj[1] ;
25635
25636 if (!args) SWIG_fail;
25637 swig_obj[0] = args;
25638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25639 if (!SWIG_IsOK(res1)) {
25640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25641 }
25642 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 result = (wxWindow *)(arg1)->GetChangedWindow();
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 {
25650 resultobj = wxPyMake_wxObject(result, (bool)0);
25651 }
25652 return resultobj;
25653 fail:
25654 return NULL;
25655 }
25656
25657
25658 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25659 PyObject *obj;
25660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25661 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25662 return SWIG_Py_Void();
25663 }
25664
25665 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25666 return SWIG_Python_InitShadowInstance(args);
25667 }
25668
25669 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25670 PyObject *resultobj = 0;
25671 int arg1 = (int) 0 ;
25672 wxQueryNewPaletteEvent *result = 0 ;
25673 int val1 ;
25674 int ecode1 = 0 ;
25675 PyObject * obj0 = 0 ;
25676 char * kwnames[] = {
25677 (char *) "winid", NULL
25678 };
25679
25680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25681 if (obj0) {
25682 ecode1 = SWIG_AsVal_int(obj0, &val1);
25683 if (!SWIG_IsOK(ecode1)) {
25684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25685 }
25686 arg1 = static_cast< int >(val1);
25687 }
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj = 0;
25703 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25704 bool arg2 ;
25705 void *argp1 = 0 ;
25706 int res1 = 0 ;
25707 bool val2 ;
25708 int ecode2 = 0 ;
25709 PyObject * obj0 = 0 ;
25710 PyObject * obj1 = 0 ;
25711 char * kwnames[] = {
25712 (char *) "self",(char *) "realized", NULL
25713 };
25714
25715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25719 }
25720 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25721 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25722 if (!SWIG_IsOK(ecode2)) {
25723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25724 }
25725 arg2 = static_cast< bool >(val2);
25726 {
25727 PyThreadState* __tstate = wxPyBeginAllowThreads();
25728 (arg1)->SetPaletteRealized(arg2);
25729 wxPyEndAllowThreads(__tstate);
25730 if (PyErr_Occurred()) SWIG_fail;
25731 }
25732 resultobj = SWIG_Py_Void();
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25740 PyObject *resultobj = 0;
25741 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25742 bool result;
25743 void *argp1 = 0 ;
25744 int res1 = 0 ;
25745 PyObject *swig_obj[1] ;
25746
25747 if (!args) SWIG_fail;
25748 swig_obj[0] = args;
25749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25750 if (!SWIG_IsOK(res1)) {
25751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25752 }
25753 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25754 {
25755 PyThreadState* __tstate = wxPyBeginAllowThreads();
25756 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25757 wxPyEndAllowThreads(__tstate);
25758 if (PyErr_Occurred()) SWIG_fail;
25759 }
25760 {
25761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25762 }
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25770 PyObject *obj;
25771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25772 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25773 return SWIG_Py_Void();
25774 }
25775
25776 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25777 return SWIG_Python_InitShadowInstance(args);
25778 }
25779
25780 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25781 PyObject *resultobj = 0;
25782 wxNavigationKeyEvent *result = 0 ;
25783
25784 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25785 {
25786 PyThreadState* __tstate = wxPyBeginAllowThreads();
25787 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25788 wxPyEndAllowThreads(__tstate);
25789 if (PyErr_Occurred()) SWIG_fail;
25790 }
25791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25792 return resultobj;
25793 fail:
25794 return NULL;
25795 }
25796
25797
25798 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25799 PyObject *resultobj = 0;
25800 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25801 bool result;
25802 void *argp1 = 0 ;
25803 int res1 = 0 ;
25804 PyObject *swig_obj[1] ;
25805
25806 if (!args) SWIG_fail;
25807 swig_obj[0] = args;
25808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25809 if (!SWIG_IsOK(res1)) {
25810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25811 }
25812 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 {
25820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25821 }
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25829 PyObject *resultobj = 0;
25830 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25831 bool arg2 ;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 bool val2 ;
25835 int ecode2 = 0 ;
25836 PyObject * obj0 = 0 ;
25837 PyObject * obj1 = 0 ;
25838 char * kwnames[] = {
25839 (char *) "self",(char *) "forward", NULL
25840 };
25841
25842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25844 if (!SWIG_IsOK(res1)) {
25845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25846 }
25847 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25849 if (!SWIG_IsOK(ecode2)) {
25850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25851 }
25852 arg2 = static_cast< bool >(val2);
25853 {
25854 PyThreadState* __tstate = wxPyBeginAllowThreads();
25855 (arg1)->SetDirection(arg2);
25856 wxPyEndAllowThreads(__tstate);
25857 if (PyErr_Occurred()) SWIG_fail;
25858 }
25859 resultobj = SWIG_Py_Void();
25860 return resultobj;
25861 fail:
25862 return NULL;
25863 }
25864
25865
25866 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25867 PyObject *resultobj = 0;
25868 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25869 bool result;
25870 void *argp1 = 0 ;
25871 int res1 = 0 ;
25872 PyObject *swig_obj[1] ;
25873
25874 if (!args) SWIG_fail;
25875 swig_obj[0] = args;
25876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25877 if (!SWIG_IsOK(res1)) {
25878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25879 }
25880 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25881 {
25882 PyThreadState* __tstate = wxPyBeginAllowThreads();
25883 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25884 wxPyEndAllowThreads(__tstate);
25885 if (PyErr_Occurred()) SWIG_fail;
25886 }
25887 {
25888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25889 }
25890 return resultobj;
25891 fail:
25892 return NULL;
25893 }
25894
25895
25896 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25897 PyObject *resultobj = 0;
25898 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25899 bool arg2 ;
25900 void *argp1 = 0 ;
25901 int res1 = 0 ;
25902 bool val2 ;
25903 int ecode2 = 0 ;
25904 PyObject * obj0 = 0 ;
25905 PyObject * obj1 = 0 ;
25906 char * kwnames[] = {
25907 (char *) "self",(char *) "ischange", NULL
25908 };
25909
25910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25912 if (!SWIG_IsOK(res1)) {
25913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25914 }
25915 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25916 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25917 if (!SWIG_IsOK(ecode2)) {
25918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25919 }
25920 arg2 = static_cast< bool >(val2);
25921 {
25922 PyThreadState* __tstate = wxPyBeginAllowThreads();
25923 (arg1)->SetWindowChange(arg2);
25924 wxPyEndAllowThreads(__tstate);
25925 if (PyErr_Occurred()) SWIG_fail;
25926 }
25927 resultobj = SWIG_Py_Void();
25928 return resultobj;
25929 fail:
25930 return NULL;
25931 }
25932
25933
25934 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25935 PyObject *resultobj = 0;
25936 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25937 bool result;
25938 void *argp1 = 0 ;
25939 int res1 = 0 ;
25940 PyObject *swig_obj[1] ;
25941
25942 if (!args) SWIG_fail;
25943 swig_obj[0] = args;
25944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25945 if (!SWIG_IsOK(res1)) {
25946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25947 }
25948 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25949 {
25950 PyThreadState* __tstate = wxPyBeginAllowThreads();
25951 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25952 wxPyEndAllowThreads(__tstate);
25953 if (PyErr_Occurred()) SWIG_fail;
25954 }
25955 {
25956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25957 }
25958 return resultobj;
25959 fail:
25960 return NULL;
25961 }
25962
25963
25964 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25965 PyObject *resultobj = 0;
25966 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25967 bool arg2 ;
25968 void *argp1 = 0 ;
25969 int res1 = 0 ;
25970 bool val2 ;
25971 int ecode2 = 0 ;
25972 PyObject * obj0 = 0 ;
25973 PyObject * obj1 = 0 ;
25974 char * kwnames[] = {
25975 (char *) "self",(char *) "bIs", NULL
25976 };
25977
25978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25980 if (!SWIG_IsOK(res1)) {
25981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25982 }
25983 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25984 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25985 if (!SWIG_IsOK(ecode2)) {
25986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25987 }
25988 arg2 = static_cast< bool >(val2);
25989 {
25990 PyThreadState* __tstate = wxPyBeginAllowThreads();
25991 (arg1)->SetFromTab(arg2);
25992 wxPyEndAllowThreads(__tstate);
25993 if (PyErr_Occurred()) SWIG_fail;
25994 }
25995 resultobj = SWIG_Py_Void();
25996 return resultobj;
25997 fail:
25998 return NULL;
25999 }
26000
26001
26002 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj = 0;
26004 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26005 long arg2 ;
26006 void *argp1 = 0 ;
26007 int res1 = 0 ;
26008 long val2 ;
26009 int ecode2 = 0 ;
26010 PyObject * obj0 = 0 ;
26011 PyObject * obj1 = 0 ;
26012 char * kwnames[] = {
26013 (char *) "self",(char *) "flags", NULL
26014 };
26015
26016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26018 if (!SWIG_IsOK(res1)) {
26019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26020 }
26021 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26022 ecode2 = SWIG_AsVal_long(obj1, &val2);
26023 if (!SWIG_IsOK(ecode2)) {
26024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26025 }
26026 arg2 = static_cast< long >(val2);
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 (arg1)->SetFlags(arg2);
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 resultobj = SWIG_Py_Void();
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26041 PyObject *resultobj = 0;
26042 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26043 wxWindow *result = 0 ;
26044 void *argp1 = 0 ;
26045 int res1 = 0 ;
26046 PyObject *swig_obj[1] ;
26047
26048 if (!args) SWIG_fail;
26049 swig_obj[0] = args;
26050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26051 if (!SWIG_IsOK(res1)) {
26052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26053 }
26054 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26055 {
26056 PyThreadState* __tstate = wxPyBeginAllowThreads();
26057 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26058 wxPyEndAllowThreads(__tstate);
26059 if (PyErr_Occurred()) SWIG_fail;
26060 }
26061 {
26062 resultobj = wxPyMake_wxObject(result, (bool)0);
26063 }
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26071 PyObject *resultobj = 0;
26072 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26073 wxWindow *arg2 = (wxWindow *) 0 ;
26074 void *argp1 = 0 ;
26075 int res1 = 0 ;
26076 void *argp2 = 0 ;
26077 int res2 = 0 ;
26078 PyObject * obj0 = 0 ;
26079 PyObject * obj1 = 0 ;
26080 char * kwnames[] = {
26081 (char *) "self",(char *) "win", NULL
26082 };
26083
26084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26086 if (!SWIG_IsOK(res1)) {
26087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26088 }
26089 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26091 if (!SWIG_IsOK(res2)) {
26092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26093 }
26094 arg2 = reinterpret_cast< wxWindow * >(argp2);
26095 {
26096 PyThreadState* __tstate = wxPyBeginAllowThreads();
26097 (arg1)->SetCurrentFocus(arg2);
26098 wxPyEndAllowThreads(__tstate);
26099 if (PyErr_Occurred()) SWIG_fail;
26100 }
26101 resultobj = SWIG_Py_Void();
26102 return resultobj;
26103 fail:
26104 return NULL;
26105 }
26106
26107
26108 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26109 PyObject *obj;
26110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26111 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26112 return SWIG_Py_Void();
26113 }
26114
26115 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26116 return SWIG_Python_InitShadowInstance(args);
26117 }
26118
26119 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26120 PyObject *resultobj = 0;
26121 wxWindow *arg1 = (wxWindow *) NULL ;
26122 wxWindowCreateEvent *result = 0 ;
26123 void *argp1 = 0 ;
26124 int res1 = 0 ;
26125 PyObject * obj0 = 0 ;
26126 char * kwnames[] = {
26127 (char *) "win", NULL
26128 };
26129
26130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26131 if (obj0) {
26132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26133 if (!SWIG_IsOK(res1)) {
26134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26135 }
26136 arg1 = reinterpret_cast< wxWindow * >(argp1);
26137 }
26138 {
26139 PyThreadState* __tstate = wxPyBeginAllowThreads();
26140 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26141 wxPyEndAllowThreads(__tstate);
26142 if (PyErr_Occurred()) SWIG_fail;
26143 }
26144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26145 return resultobj;
26146 fail:
26147 return NULL;
26148 }
26149
26150
26151 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26152 PyObject *resultobj = 0;
26153 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26154 wxWindow *result = 0 ;
26155 void *argp1 = 0 ;
26156 int res1 = 0 ;
26157 PyObject *swig_obj[1] ;
26158
26159 if (!args) SWIG_fail;
26160 swig_obj[0] = args;
26161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26162 if (!SWIG_IsOK(res1)) {
26163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26164 }
26165 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26166 {
26167 PyThreadState* __tstate = wxPyBeginAllowThreads();
26168 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26169 wxPyEndAllowThreads(__tstate);
26170 if (PyErr_Occurred()) SWIG_fail;
26171 }
26172 {
26173 resultobj = wxPyMake_wxObject(result, (bool)0);
26174 }
26175 return resultobj;
26176 fail:
26177 return NULL;
26178 }
26179
26180
26181 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26182 PyObject *obj;
26183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26184 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26185 return SWIG_Py_Void();
26186 }
26187
26188 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26189 return SWIG_Python_InitShadowInstance(args);
26190 }
26191
26192 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26193 PyObject *resultobj = 0;
26194 wxWindow *arg1 = (wxWindow *) NULL ;
26195 wxWindowDestroyEvent *result = 0 ;
26196 void *argp1 = 0 ;
26197 int res1 = 0 ;
26198 PyObject * obj0 = 0 ;
26199 char * kwnames[] = {
26200 (char *) "win", NULL
26201 };
26202
26203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26204 if (obj0) {
26205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26206 if (!SWIG_IsOK(res1)) {
26207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26208 }
26209 arg1 = reinterpret_cast< wxWindow * >(argp1);
26210 }
26211 {
26212 PyThreadState* __tstate = wxPyBeginAllowThreads();
26213 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26214 wxPyEndAllowThreads(__tstate);
26215 if (PyErr_Occurred()) SWIG_fail;
26216 }
26217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26218 return resultobj;
26219 fail:
26220 return NULL;
26221 }
26222
26223
26224 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26225 PyObject *resultobj = 0;
26226 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26227 wxWindow *result = 0 ;
26228 void *argp1 = 0 ;
26229 int res1 = 0 ;
26230 PyObject *swig_obj[1] ;
26231
26232 if (!args) SWIG_fail;
26233 swig_obj[0] = args;
26234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26235 if (!SWIG_IsOK(res1)) {
26236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26237 }
26238 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26239 {
26240 PyThreadState* __tstate = wxPyBeginAllowThreads();
26241 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26242 wxPyEndAllowThreads(__tstate);
26243 if (PyErr_Occurred()) SWIG_fail;
26244 }
26245 {
26246 resultobj = wxPyMake_wxObject(result, (bool)0);
26247 }
26248 return resultobj;
26249 fail:
26250 return NULL;
26251 }
26252
26253
26254 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26255 PyObject *obj;
26256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26257 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26258 return SWIG_Py_Void();
26259 }
26260
26261 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26262 return SWIG_Python_InitShadowInstance(args);
26263 }
26264
26265 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26266 PyObject *resultobj = 0;
26267 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26268 int arg2 = (int) 0 ;
26269 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26270 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26271 wxContextMenuEvent *result = 0 ;
26272 int val1 ;
26273 int ecode1 = 0 ;
26274 int val2 ;
26275 int ecode2 = 0 ;
26276 wxPoint temp3 ;
26277 PyObject * obj0 = 0 ;
26278 PyObject * obj1 = 0 ;
26279 PyObject * obj2 = 0 ;
26280 char * kwnames[] = {
26281 (char *) "type",(char *) "winid",(char *) "pt", NULL
26282 };
26283
26284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26285 if (obj0) {
26286 ecode1 = SWIG_AsVal_int(obj0, &val1);
26287 if (!SWIG_IsOK(ecode1)) {
26288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26289 }
26290 arg1 = static_cast< wxEventType >(val1);
26291 }
26292 if (obj1) {
26293 ecode2 = SWIG_AsVal_int(obj1, &val2);
26294 if (!SWIG_IsOK(ecode2)) {
26295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26296 }
26297 arg2 = static_cast< int >(val2);
26298 }
26299 if (obj2) {
26300 {
26301 arg3 = &temp3;
26302 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26303 }
26304 }
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26308 wxPyEndAllowThreads(__tstate);
26309 if (PyErr_Occurred()) SWIG_fail;
26310 }
26311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26312 return resultobj;
26313 fail:
26314 return NULL;
26315 }
26316
26317
26318 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26319 PyObject *resultobj = 0;
26320 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26321 wxPoint *result = 0 ;
26322 void *argp1 = 0 ;
26323 int res1 = 0 ;
26324 PyObject *swig_obj[1] ;
26325
26326 if (!args) SWIG_fail;
26327 swig_obj[0] = args;
26328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26329 if (!SWIG_IsOK(res1)) {
26330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26331 }
26332 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26333 {
26334 PyThreadState* __tstate = wxPyBeginAllowThreads();
26335 {
26336 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26337 result = (wxPoint *) &_result_ref;
26338 }
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26343 return resultobj;
26344 fail:
26345 return NULL;
26346 }
26347
26348
26349 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26350 PyObject *resultobj = 0;
26351 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26352 wxPoint *arg2 = 0 ;
26353 void *argp1 = 0 ;
26354 int res1 = 0 ;
26355 wxPoint temp2 ;
26356 PyObject * obj0 = 0 ;
26357 PyObject * obj1 = 0 ;
26358 char * kwnames[] = {
26359 (char *) "self",(char *) "pos", NULL
26360 };
26361
26362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26364 if (!SWIG_IsOK(res1)) {
26365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26366 }
26367 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26368 {
26369 arg2 = &temp2;
26370 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26371 }
26372 {
26373 PyThreadState* __tstate = wxPyBeginAllowThreads();
26374 (arg1)->SetPosition((wxPoint const &)*arg2);
26375 wxPyEndAllowThreads(__tstate);
26376 if (PyErr_Occurred()) SWIG_fail;
26377 }
26378 resultobj = SWIG_Py_Void();
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26386 PyObject *obj;
26387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26388 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26389 return SWIG_Py_Void();
26390 }
26391
26392 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26393 return SWIG_Python_InitShadowInstance(args);
26394 }
26395
26396 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26397 PyObject *resultobj = 0;
26398 wxIdleEvent *result = 0 ;
26399
26400 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26401 {
26402 PyThreadState* __tstate = wxPyBeginAllowThreads();
26403 result = (wxIdleEvent *)new wxIdleEvent();
26404 wxPyEndAllowThreads(__tstate);
26405 if (PyErr_Occurred()) SWIG_fail;
26406 }
26407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26408 return resultobj;
26409 fail:
26410 return NULL;
26411 }
26412
26413
26414 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26415 PyObject *resultobj = 0;
26416 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26417 bool arg2 = (bool) true ;
26418 void *argp1 = 0 ;
26419 int res1 = 0 ;
26420 bool val2 ;
26421 int ecode2 = 0 ;
26422 PyObject * obj0 = 0 ;
26423 PyObject * obj1 = 0 ;
26424 char * kwnames[] = {
26425 (char *) "self",(char *) "needMore", NULL
26426 };
26427
26428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26430 if (!SWIG_IsOK(res1)) {
26431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26432 }
26433 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26434 if (obj1) {
26435 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26436 if (!SWIG_IsOK(ecode2)) {
26437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26438 }
26439 arg2 = static_cast< bool >(val2);
26440 }
26441 {
26442 PyThreadState* __tstate = wxPyBeginAllowThreads();
26443 (arg1)->RequestMore(arg2);
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 resultobj = SWIG_Py_Void();
26448 return resultobj;
26449 fail:
26450 return NULL;
26451 }
26452
26453
26454 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26455 PyObject *resultobj = 0;
26456 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26457 bool result;
26458 void *argp1 = 0 ;
26459 int res1 = 0 ;
26460 PyObject *swig_obj[1] ;
26461
26462 if (!args) SWIG_fail;
26463 swig_obj[0] = args;
26464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26465 if (!SWIG_IsOK(res1)) {
26466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26467 }
26468 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26472 wxPyEndAllowThreads(__tstate);
26473 if (PyErr_Occurred()) SWIG_fail;
26474 }
26475 {
26476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26477 }
26478 return resultobj;
26479 fail:
26480 return NULL;
26481 }
26482
26483
26484 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26485 PyObject *resultobj = 0;
26486 wxIdleMode arg1 ;
26487 int val1 ;
26488 int ecode1 = 0 ;
26489 PyObject * obj0 = 0 ;
26490 char * kwnames[] = {
26491 (char *) "mode", NULL
26492 };
26493
26494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26495 ecode1 = SWIG_AsVal_int(obj0, &val1);
26496 if (!SWIG_IsOK(ecode1)) {
26497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26498 }
26499 arg1 = static_cast< wxIdleMode >(val1);
26500 {
26501 PyThreadState* __tstate = wxPyBeginAllowThreads();
26502 wxIdleEvent::SetMode(arg1);
26503 wxPyEndAllowThreads(__tstate);
26504 if (PyErr_Occurred()) SWIG_fail;
26505 }
26506 resultobj = SWIG_Py_Void();
26507 return resultobj;
26508 fail:
26509 return NULL;
26510 }
26511
26512
26513 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26514 PyObject *resultobj = 0;
26515 wxIdleMode result;
26516
26517 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (wxIdleMode)wxIdleEvent::GetMode();
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 resultobj = SWIG_From_int(static_cast< int >(result));
26525 return resultobj;
26526 fail:
26527 return NULL;
26528 }
26529
26530
26531 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26532 PyObject *resultobj = 0;
26533 wxWindow *arg1 = (wxWindow *) 0 ;
26534 bool result;
26535 void *argp1 = 0 ;
26536 int res1 = 0 ;
26537 PyObject * obj0 = 0 ;
26538 char * kwnames[] = {
26539 (char *) "win", NULL
26540 };
26541
26542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26544 if (!SWIG_IsOK(res1)) {
26545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26546 }
26547 arg1 = reinterpret_cast< wxWindow * >(argp1);
26548 {
26549 PyThreadState* __tstate = wxPyBeginAllowThreads();
26550 result = (bool)wxIdleEvent::CanSend(arg1);
26551 wxPyEndAllowThreads(__tstate);
26552 if (PyErr_Occurred()) SWIG_fail;
26553 }
26554 {
26555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26556 }
26557 return resultobj;
26558 fail:
26559 return NULL;
26560 }
26561
26562
26563 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26564 PyObject *obj;
26565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26566 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26567 return SWIG_Py_Void();
26568 }
26569
26570 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26571 return SWIG_Python_InitShadowInstance(args);
26572 }
26573
26574 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26575 PyObject *resultobj = 0;
26576 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26577 int arg2 = (int) 0 ;
26578 wxClipboardTextEvent *result = 0 ;
26579 int val1 ;
26580 int ecode1 = 0 ;
26581 int val2 ;
26582 int ecode2 = 0 ;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585 char * kwnames[] = {
26586 (char *) "type",(char *) "winid", NULL
26587 };
26588
26589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26590 if (obj0) {
26591 ecode1 = SWIG_AsVal_int(obj0, &val1);
26592 if (!SWIG_IsOK(ecode1)) {
26593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26594 }
26595 arg1 = static_cast< wxEventType >(val1);
26596 }
26597 if (obj1) {
26598 ecode2 = SWIG_AsVal_int(obj1, &val2);
26599 if (!SWIG_IsOK(ecode2)) {
26600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26601 }
26602 arg2 = static_cast< int >(val2);
26603 }
26604 {
26605 PyThreadState* __tstate = wxPyBeginAllowThreads();
26606 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26607 wxPyEndAllowThreads(__tstate);
26608 if (PyErr_Occurred()) SWIG_fail;
26609 }
26610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26618 PyObject *obj;
26619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26620 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26621 return SWIG_Py_Void();
26622 }
26623
26624 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26625 return SWIG_Python_InitShadowInstance(args);
26626 }
26627
26628 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26629 PyObject *resultobj = 0;
26630 int arg1 = (int) 0 ;
26631 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26632 wxPyEvent *result = 0 ;
26633 int val1 ;
26634 int ecode1 = 0 ;
26635 int val2 ;
26636 int ecode2 = 0 ;
26637 PyObject * obj0 = 0 ;
26638 PyObject * obj1 = 0 ;
26639 char * kwnames[] = {
26640 (char *) "winid",(char *) "eventType", NULL
26641 };
26642
26643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26644 if (obj0) {
26645 ecode1 = SWIG_AsVal_int(obj0, &val1);
26646 if (!SWIG_IsOK(ecode1)) {
26647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26648 }
26649 arg1 = static_cast< int >(val1);
26650 }
26651 if (obj1) {
26652 ecode2 = SWIG_AsVal_int(obj1, &val2);
26653 if (!SWIG_IsOK(ecode2)) {
26654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26655 }
26656 arg2 = static_cast< wxEventType >(val2);
26657 }
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26665 return resultobj;
26666 fail:
26667 return NULL;
26668 }
26669
26670
26671 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26672 PyObject *resultobj = 0;
26673 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26674 void *argp1 = 0 ;
26675 int res1 = 0 ;
26676 PyObject *swig_obj[1] ;
26677
26678 if (!args) SWIG_fail;
26679 swig_obj[0] = args;
26680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26681 if (!SWIG_IsOK(res1)) {
26682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26683 }
26684 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26685 {
26686 PyThreadState* __tstate = wxPyBeginAllowThreads();
26687 delete arg1;
26688
26689 wxPyEndAllowThreads(__tstate);
26690 if (PyErr_Occurred()) SWIG_fail;
26691 }
26692 resultobj = SWIG_Py_Void();
26693 return resultobj;
26694 fail:
26695 return NULL;
26696 }
26697
26698
26699 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26700 PyObject *resultobj = 0;
26701 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26702 PyObject *arg2 = (PyObject *) 0 ;
26703 void *argp1 = 0 ;
26704 int res1 = 0 ;
26705 PyObject * obj0 = 0 ;
26706 PyObject * obj1 = 0 ;
26707 char * kwnames[] = {
26708 (char *) "self",(char *) "self", NULL
26709 };
26710
26711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26713 if (!SWIG_IsOK(res1)) {
26714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26715 }
26716 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26717 arg2 = obj1;
26718 {
26719 PyThreadState* __tstate = wxPyBeginAllowThreads();
26720 (arg1)->SetSelf(arg2);
26721 wxPyEndAllowThreads(__tstate);
26722 if (PyErr_Occurred()) SWIG_fail;
26723 }
26724 resultobj = SWIG_Py_Void();
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26732 PyObject *resultobj = 0;
26733 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26734 PyObject *result = 0 ;
26735 void *argp1 = 0 ;
26736 int res1 = 0 ;
26737 PyObject *swig_obj[1] ;
26738
26739 if (!args) SWIG_fail;
26740 swig_obj[0] = args;
26741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26742 if (!SWIG_IsOK(res1)) {
26743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26744 }
26745 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26746 {
26747 PyThreadState* __tstate = wxPyBeginAllowThreads();
26748 result = (PyObject *)(arg1)->GetSelf();
26749 wxPyEndAllowThreads(__tstate);
26750 if (PyErr_Occurred()) SWIG_fail;
26751 }
26752 resultobj = result;
26753 return resultobj;
26754 fail:
26755 return NULL;
26756 }
26757
26758
26759 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26760 PyObject *obj;
26761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26762 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26763 return SWIG_Py_Void();
26764 }
26765
26766 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26767 return SWIG_Python_InitShadowInstance(args);
26768 }
26769
26770 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj = 0;
26772 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26773 int arg2 = (int) 0 ;
26774 wxPyCommandEvent *result = 0 ;
26775 int val1 ;
26776 int ecode1 = 0 ;
26777 int val2 ;
26778 int ecode2 = 0 ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 char * kwnames[] = {
26782 (char *) "eventType",(char *) "id", NULL
26783 };
26784
26785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26786 if (obj0) {
26787 ecode1 = SWIG_AsVal_int(obj0, &val1);
26788 if (!SWIG_IsOK(ecode1)) {
26789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26790 }
26791 arg1 = static_cast< wxEventType >(val1);
26792 }
26793 if (obj1) {
26794 ecode2 = SWIG_AsVal_int(obj1, &val2);
26795 if (!SWIG_IsOK(ecode2)) {
26796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26797 }
26798 arg2 = static_cast< int >(val2);
26799 }
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *resultobj = 0;
26815 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 PyObject *swig_obj[1] ;
26819
26820 if (!args) SWIG_fail;
26821 swig_obj[0] = args;
26822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26823 if (!SWIG_IsOK(res1)) {
26824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26825 }
26826 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 delete arg1;
26830
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 resultobj = SWIG_Py_Void();
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26842 PyObject *resultobj = 0;
26843 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26844 PyObject *arg2 = (PyObject *) 0 ;
26845 void *argp1 = 0 ;
26846 int res1 = 0 ;
26847 PyObject * obj0 = 0 ;
26848 PyObject * obj1 = 0 ;
26849 char * kwnames[] = {
26850 (char *) "self",(char *) "self", NULL
26851 };
26852
26853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26855 if (!SWIG_IsOK(res1)) {
26856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26857 }
26858 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26859 arg2 = obj1;
26860 {
26861 PyThreadState* __tstate = wxPyBeginAllowThreads();
26862 (arg1)->SetSelf(arg2);
26863 wxPyEndAllowThreads(__tstate);
26864 if (PyErr_Occurred()) SWIG_fail;
26865 }
26866 resultobj = SWIG_Py_Void();
26867 return resultobj;
26868 fail:
26869 return NULL;
26870 }
26871
26872
26873 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26874 PyObject *resultobj = 0;
26875 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26876 PyObject *result = 0 ;
26877 void *argp1 = 0 ;
26878 int res1 = 0 ;
26879 PyObject *swig_obj[1] ;
26880
26881 if (!args) SWIG_fail;
26882 swig_obj[0] = args;
26883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26884 if (!SWIG_IsOK(res1)) {
26885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26886 }
26887 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26888 {
26889 PyThreadState* __tstate = wxPyBeginAllowThreads();
26890 result = (PyObject *)(arg1)->GetSelf();
26891 wxPyEndAllowThreads(__tstate);
26892 if (PyErr_Occurred()) SWIG_fail;
26893 }
26894 resultobj = result;
26895 return resultobj;
26896 fail:
26897 return NULL;
26898 }
26899
26900
26901 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26902 PyObject *obj;
26903 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26904 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26905 return SWIG_Py_Void();
26906 }
26907
26908 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26909 return SWIG_Python_InitShadowInstance(args);
26910 }
26911
26912 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26913 PyObject *resultobj = 0;
26914 wxWindow *arg1 = (wxWindow *) 0 ;
26915 wxDateTime *arg2 = 0 ;
26916 wxEventType arg3 ;
26917 wxDateEvent *result = 0 ;
26918 void *argp1 = 0 ;
26919 int res1 = 0 ;
26920 void *argp2 = 0 ;
26921 int res2 = 0 ;
26922 int val3 ;
26923 int ecode3 = 0 ;
26924 PyObject * obj0 = 0 ;
26925 PyObject * obj1 = 0 ;
26926 PyObject * obj2 = 0 ;
26927 char * kwnames[] = {
26928 (char *) "win",(char *) "dt",(char *) "type", NULL
26929 };
26930
26931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26933 if (!SWIG_IsOK(res1)) {
26934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26935 }
26936 arg1 = reinterpret_cast< wxWindow * >(argp1);
26937 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26938 if (!SWIG_IsOK(res2)) {
26939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26940 }
26941 if (!argp2) {
26942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26943 }
26944 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26945 ecode3 = SWIG_AsVal_int(obj2, &val3);
26946 if (!SWIG_IsOK(ecode3)) {
26947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26948 }
26949 arg3 = static_cast< wxEventType >(val3);
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26957 return resultobj;
26958 fail:
26959 return NULL;
26960 }
26961
26962
26963 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26964 PyObject *resultobj = 0;
26965 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26966 wxDateTime *result = 0 ;
26967 void *argp1 = 0 ;
26968 int res1 = 0 ;
26969 PyObject *swig_obj[1] ;
26970
26971 if (!args) SWIG_fail;
26972 swig_obj[0] = args;
26973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26974 if (!SWIG_IsOK(res1)) {
26975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26976 }
26977 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26978 {
26979 PyThreadState* __tstate = wxPyBeginAllowThreads();
26980 {
26981 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26982 result = (wxDateTime *) &_result_ref;
26983 }
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26988 return resultobj;
26989 fail:
26990 return NULL;
26991 }
26992
26993
26994 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26995 PyObject *resultobj = 0;
26996 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26997 wxDateTime *arg2 = 0 ;
26998 void *argp1 = 0 ;
26999 int res1 = 0 ;
27000 void *argp2 = 0 ;
27001 int res2 = 0 ;
27002 PyObject * obj0 = 0 ;
27003 PyObject * obj1 = 0 ;
27004 char * kwnames[] = {
27005 (char *) "self",(char *) "date", NULL
27006 };
27007
27008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27010 if (!SWIG_IsOK(res1)) {
27011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27012 }
27013 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27014 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27015 if (!SWIG_IsOK(res2)) {
27016 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27017 }
27018 if (!argp2) {
27019 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27020 }
27021 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 (arg1)->SetDate((wxDateTime const &)*arg2);
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 resultobj = SWIG_Py_Void();
27029 return resultobj;
27030 fail:
27031 return NULL;
27032 }
27033
27034
27035 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27036 PyObject *obj;
27037 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27038 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27039 return SWIG_Py_Void();
27040 }
27041
27042 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27043 return SWIG_Python_InitShadowInstance(args);
27044 }
27045
27046 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27047 PyObject *resultobj = 0;
27048 wxPyApp *result = 0 ;
27049
27050 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27051 {
27052 PyThreadState* __tstate = wxPyBeginAllowThreads();
27053 result = (wxPyApp *)new_wxPyApp();
27054 wxPyEndAllowThreads(__tstate);
27055 if (PyErr_Occurred()) SWIG_fail;
27056 }
27057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27065 PyObject *resultobj = 0;
27066 wxPyApp *arg1 = (wxPyApp *) 0 ;
27067 void *argp1 = 0 ;
27068 int res1 = 0 ;
27069 PyObject *swig_obj[1] ;
27070
27071 if (!args) SWIG_fail;
27072 swig_obj[0] = args;
27073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27074 if (!SWIG_IsOK(res1)) {
27075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27076 }
27077 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 delete arg1;
27081
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 resultobj = SWIG_Py_Void();
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj = 0;
27094 wxPyApp *arg1 = (wxPyApp *) 0 ;
27095 PyObject *arg2 = (PyObject *) 0 ;
27096 PyObject *arg3 = (PyObject *) 0 ;
27097 bool arg4 ;
27098 void *argp1 = 0 ;
27099 int res1 = 0 ;
27100 bool val4 ;
27101 int ecode4 = 0 ;
27102 PyObject * obj0 = 0 ;
27103 PyObject * obj1 = 0 ;
27104 PyObject * obj2 = 0 ;
27105 PyObject * obj3 = 0 ;
27106 char * kwnames[] = {
27107 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27108 };
27109
27110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27112 if (!SWIG_IsOK(res1)) {
27113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27114 }
27115 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27116 arg2 = obj1;
27117 arg3 = obj2;
27118 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27119 if (!SWIG_IsOK(ecode4)) {
27120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27121 }
27122 arg4 = static_cast< bool >(val4);
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 resultobj = SWIG_Py_Void();
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27137 PyObject *resultobj = 0;
27138 wxPyApp *arg1 = (wxPyApp *) 0 ;
27139 wxString result;
27140 void *argp1 = 0 ;
27141 int res1 = 0 ;
27142 PyObject *swig_obj[1] ;
27143
27144 if (!args) SWIG_fail;
27145 swig_obj[0] = args;
27146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27147 if (!SWIG_IsOK(res1)) {
27148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27149 }
27150 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27151 {
27152 PyThreadState* __tstate = wxPyBeginAllowThreads();
27153 result = ((wxPyApp const *)arg1)->GetAppName();
27154 wxPyEndAllowThreads(__tstate);
27155 if (PyErr_Occurred()) SWIG_fail;
27156 }
27157 {
27158 #if wxUSE_UNICODE
27159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27160 #else
27161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27162 #endif
27163 }
27164 return resultobj;
27165 fail:
27166 return NULL;
27167 }
27168
27169
27170 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27171 PyObject *resultobj = 0;
27172 wxPyApp *arg1 = (wxPyApp *) 0 ;
27173 wxString *arg2 = 0 ;
27174 void *argp1 = 0 ;
27175 int res1 = 0 ;
27176 bool temp2 = false ;
27177 PyObject * obj0 = 0 ;
27178 PyObject * obj1 = 0 ;
27179 char * kwnames[] = {
27180 (char *) "self",(char *) "name", NULL
27181 };
27182
27183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27185 if (!SWIG_IsOK(res1)) {
27186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27187 }
27188 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27189 {
27190 arg2 = wxString_in_helper(obj1);
27191 if (arg2 == NULL) SWIG_fail;
27192 temp2 = true;
27193 }
27194 {
27195 PyThreadState* __tstate = wxPyBeginAllowThreads();
27196 (arg1)->SetAppName((wxString const &)*arg2);
27197 wxPyEndAllowThreads(__tstate);
27198 if (PyErr_Occurred()) SWIG_fail;
27199 }
27200 resultobj = SWIG_Py_Void();
27201 {
27202 if (temp2)
27203 delete arg2;
27204 }
27205 return resultobj;
27206 fail:
27207 {
27208 if (temp2)
27209 delete arg2;
27210 }
27211 return NULL;
27212 }
27213
27214
27215 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27216 PyObject *resultobj = 0;
27217 wxPyApp *arg1 = (wxPyApp *) 0 ;
27218 wxString result;
27219 void *argp1 = 0 ;
27220 int res1 = 0 ;
27221 PyObject *swig_obj[1] ;
27222
27223 if (!args) SWIG_fail;
27224 swig_obj[0] = args;
27225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27226 if (!SWIG_IsOK(res1)) {
27227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27228 }
27229 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27230 {
27231 PyThreadState* __tstate = wxPyBeginAllowThreads();
27232 result = ((wxPyApp const *)arg1)->GetClassName();
27233 wxPyEndAllowThreads(__tstate);
27234 if (PyErr_Occurred()) SWIG_fail;
27235 }
27236 {
27237 #if wxUSE_UNICODE
27238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27239 #else
27240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27241 #endif
27242 }
27243 return resultobj;
27244 fail:
27245 return NULL;
27246 }
27247
27248
27249 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27250 PyObject *resultobj = 0;
27251 wxPyApp *arg1 = (wxPyApp *) 0 ;
27252 wxString *arg2 = 0 ;
27253 void *argp1 = 0 ;
27254 int res1 = 0 ;
27255 bool temp2 = false ;
27256 PyObject * obj0 = 0 ;
27257 PyObject * obj1 = 0 ;
27258 char * kwnames[] = {
27259 (char *) "self",(char *) "name", NULL
27260 };
27261
27262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27264 if (!SWIG_IsOK(res1)) {
27265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27266 }
27267 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27268 {
27269 arg2 = wxString_in_helper(obj1);
27270 if (arg2 == NULL) SWIG_fail;
27271 temp2 = true;
27272 }
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 (arg1)->SetClassName((wxString const &)*arg2);
27276 wxPyEndAllowThreads(__tstate);
27277 if (PyErr_Occurred()) SWIG_fail;
27278 }
27279 resultobj = SWIG_Py_Void();
27280 {
27281 if (temp2)
27282 delete arg2;
27283 }
27284 return resultobj;
27285 fail:
27286 {
27287 if (temp2)
27288 delete arg2;
27289 }
27290 return NULL;
27291 }
27292
27293
27294 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27295 PyObject *resultobj = 0;
27296 wxPyApp *arg1 = (wxPyApp *) 0 ;
27297 wxString *result = 0 ;
27298 void *argp1 = 0 ;
27299 int res1 = 0 ;
27300 PyObject *swig_obj[1] ;
27301
27302 if (!args) SWIG_fail;
27303 swig_obj[0] = args;
27304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27305 if (!SWIG_IsOK(res1)) {
27306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27307 }
27308 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27309 {
27310 PyThreadState* __tstate = wxPyBeginAllowThreads();
27311 {
27312 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27313 result = (wxString *) &_result_ref;
27314 }
27315 wxPyEndAllowThreads(__tstate);
27316 if (PyErr_Occurred()) SWIG_fail;
27317 }
27318 {
27319 #if wxUSE_UNICODE
27320 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27321 #else
27322 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27323 #endif
27324 }
27325 return resultobj;
27326 fail:
27327 return NULL;
27328 }
27329
27330
27331 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27332 PyObject *resultobj = 0;
27333 wxPyApp *arg1 = (wxPyApp *) 0 ;
27334 wxString *arg2 = 0 ;
27335 void *argp1 = 0 ;
27336 int res1 = 0 ;
27337 bool temp2 = false ;
27338 PyObject * obj0 = 0 ;
27339 PyObject * obj1 = 0 ;
27340 char * kwnames[] = {
27341 (char *) "self",(char *) "name", NULL
27342 };
27343
27344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27346 if (!SWIG_IsOK(res1)) {
27347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27348 }
27349 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27350 {
27351 arg2 = wxString_in_helper(obj1);
27352 if (arg2 == NULL) SWIG_fail;
27353 temp2 = true;
27354 }
27355 {
27356 PyThreadState* __tstate = wxPyBeginAllowThreads();
27357 (arg1)->SetVendorName((wxString const &)*arg2);
27358 wxPyEndAllowThreads(__tstate);
27359 if (PyErr_Occurred()) SWIG_fail;
27360 }
27361 resultobj = SWIG_Py_Void();
27362 {
27363 if (temp2)
27364 delete arg2;
27365 }
27366 return resultobj;
27367 fail:
27368 {
27369 if (temp2)
27370 delete arg2;
27371 }
27372 return NULL;
27373 }
27374
27375
27376 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27377 PyObject *resultobj = 0;
27378 wxPyApp *arg1 = (wxPyApp *) 0 ;
27379 wxAppTraits *result = 0 ;
27380 void *argp1 = 0 ;
27381 int res1 = 0 ;
27382 PyObject *swig_obj[1] ;
27383
27384 if (!args) SWIG_fail;
27385 swig_obj[0] = args;
27386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27387 if (!SWIG_IsOK(res1)) {
27388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27389 }
27390 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27391 {
27392 PyThreadState* __tstate = wxPyBeginAllowThreads();
27393 result = (wxAppTraits *)(arg1)->GetTraits();
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27398 return resultobj;
27399 fail:
27400 return NULL;
27401 }
27402
27403
27404 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27405 PyObject *resultobj = 0;
27406 wxPyApp *arg1 = (wxPyApp *) 0 ;
27407 void *argp1 = 0 ;
27408 int res1 = 0 ;
27409 PyObject *swig_obj[1] ;
27410
27411 if (!args) SWIG_fail;
27412 swig_obj[0] = args;
27413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27414 if (!SWIG_IsOK(res1)) {
27415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27416 }
27417 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 (arg1)->ProcessPendingEvents();
27421 wxPyEndAllowThreads(__tstate);
27422 if (PyErr_Occurred()) SWIG_fail;
27423 }
27424 resultobj = SWIG_Py_Void();
27425 return resultobj;
27426 fail:
27427 return NULL;
27428 }
27429
27430
27431 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27432 PyObject *resultobj = 0;
27433 wxPyApp *arg1 = (wxPyApp *) 0 ;
27434 bool arg2 = (bool) false ;
27435 bool result;
27436 void *argp1 = 0 ;
27437 int res1 = 0 ;
27438 bool val2 ;
27439 int ecode2 = 0 ;
27440 PyObject * obj0 = 0 ;
27441 PyObject * obj1 = 0 ;
27442 char * kwnames[] = {
27443 (char *) "self",(char *) "onlyIfNeeded", NULL
27444 };
27445
27446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27450 }
27451 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27452 if (obj1) {
27453 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27454 if (!SWIG_IsOK(ecode2)) {
27455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27456 }
27457 arg2 = static_cast< bool >(val2);
27458 }
27459 {
27460 PyThreadState* __tstate = wxPyBeginAllowThreads();
27461 result = (bool)(arg1)->Yield(arg2);
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 {
27466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27467 }
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27475 PyObject *resultobj = 0;
27476 wxPyApp *arg1 = (wxPyApp *) 0 ;
27477 void *argp1 = 0 ;
27478 int res1 = 0 ;
27479 PyObject *swig_obj[1] ;
27480
27481 if (!args) SWIG_fail;
27482 swig_obj[0] = args;
27483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27484 if (!SWIG_IsOK(res1)) {
27485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27486 }
27487 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27488 {
27489 PyThreadState* __tstate = wxPyBeginAllowThreads();
27490 (arg1)->WakeUpIdle();
27491 wxPyEndAllowThreads(__tstate);
27492 if (PyErr_Occurred()) SWIG_fail;
27493 }
27494 resultobj = SWIG_Py_Void();
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27502 PyObject *resultobj = 0;
27503 bool result;
27504
27505 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 result = (bool)wxPyApp::IsMainLoopRunning();
27509 wxPyEndAllowThreads(__tstate);
27510 if (PyErr_Occurred()) SWIG_fail;
27511 }
27512 {
27513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27514 }
27515 return resultobj;
27516 fail:
27517 return NULL;
27518 }
27519
27520
27521 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27522 PyObject *resultobj = 0;
27523 wxPyApp *arg1 = (wxPyApp *) 0 ;
27524 int result;
27525 void *argp1 = 0 ;
27526 int res1 = 0 ;
27527 PyObject *swig_obj[1] ;
27528
27529 if (!args) SWIG_fail;
27530 swig_obj[0] = args;
27531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27532 if (!SWIG_IsOK(res1)) {
27533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27534 }
27535 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 result = (int)(arg1)->MainLoop();
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_From_int(static_cast< int >(result));
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27550 PyObject *resultobj = 0;
27551 wxPyApp *arg1 = (wxPyApp *) 0 ;
27552 void *argp1 = 0 ;
27553 int res1 = 0 ;
27554 PyObject *swig_obj[1] ;
27555
27556 if (!args) SWIG_fail;
27557 swig_obj[0] = args;
27558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27559 if (!SWIG_IsOK(res1)) {
27560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27561 }
27562 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27563 {
27564 PyThreadState* __tstate = wxPyBeginAllowThreads();
27565 (arg1)->Exit();
27566 wxPyEndAllowThreads(__tstate);
27567 if (PyErr_Occurred()) SWIG_fail;
27568 }
27569 resultobj = SWIG_Py_Void();
27570 return resultobj;
27571 fail:
27572 return NULL;
27573 }
27574
27575
27576 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27577 PyObject *resultobj = 0;
27578 wxPyApp *arg1 = (wxPyApp *) 0 ;
27579 void *argp1 = 0 ;
27580 int res1 = 0 ;
27581 PyObject *swig_obj[1] ;
27582
27583 if (!args) SWIG_fail;
27584 swig_obj[0] = args;
27585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27586 if (!SWIG_IsOK(res1)) {
27587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27588 }
27589 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 (arg1)->ExitMainLoop();
27593 wxPyEndAllowThreads(__tstate);
27594 if (PyErr_Occurred()) SWIG_fail;
27595 }
27596 resultobj = SWIG_Py_Void();
27597 return resultobj;
27598 fail:
27599 return NULL;
27600 }
27601
27602
27603 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27604 PyObject *resultobj = 0;
27605 wxPyApp *arg1 = (wxPyApp *) 0 ;
27606 bool result;
27607 void *argp1 = 0 ;
27608 int res1 = 0 ;
27609 PyObject *swig_obj[1] ;
27610
27611 if (!args) SWIG_fail;
27612 swig_obj[0] = args;
27613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27614 if (!SWIG_IsOK(res1)) {
27615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27616 }
27617 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 result = (bool)(arg1)->Pending();
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 {
27625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27626 }
27627 return resultobj;
27628 fail:
27629 return NULL;
27630 }
27631
27632
27633 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27634 PyObject *resultobj = 0;
27635 wxPyApp *arg1 = (wxPyApp *) 0 ;
27636 bool result;
27637 void *argp1 = 0 ;
27638 int res1 = 0 ;
27639 PyObject *swig_obj[1] ;
27640
27641 if (!args) SWIG_fail;
27642 swig_obj[0] = args;
27643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27644 if (!SWIG_IsOK(res1)) {
27645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27646 }
27647 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27648 {
27649 PyThreadState* __tstate = wxPyBeginAllowThreads();
27650 result = (bool)(arg1)->Dispatch();
27651 wxPyEndAllowThreads(__tstate);
27652 if (PyErr_Occurred()) SWIG_fail;
27653 }
27654 {
27655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27656 }
27657 return resultobj;
27658 fail:
27659 return NULL;
27660 }
27661
27662
27663 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27664 PyObject *resultobj = 0;
27665 wxPyApp *arg1 = (wxPyApp *) 0 ;
27666 bool result;
27667 void *argp1 = 0 ;
27668 int res1 = 0 ;
27669 PyObject *swig_obj[1] ;
27670
27671 if (!args) SWIG_fail;
27672 swig_obj[0] = args;
27673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27674 if (!SWIG_IsOK(res1)) {
27675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27676 }
27677 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27678 {
27679 PyThreadState* __tstate = wxPyBeginAllowThreads();
27680 result = (bool)(arg1)->ProcessIdle();
27681 wxPyEndAllowThreads(__tstate);
27682 if (PyErr_Occurred()) SWIG_fail;
27683 }
27684 {
27685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27686 }
27687 return resultobj;
27688 fail:
27689 return NULL;
27690 }
27691
27692
27693 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27694 PyObject *resultobj = 0;
27695 wxPyApp *arg1 = (wxPyApp *) 0 ;
27696 wxWindow *arg2 = (wxWindow *) 0 ;
27697 wxIdleEvent *arg3 = 0 ;
27698 bool result;
27699 void *argp1 = 0 ;
27700 int res1 = 0 ;
27701 void *argp2 = 0 ;
27702 int res2 = 0 ;
27703 void *argp3 = 0 ;
27704 int res3 = 0 ;
27705 PyObject * obj0 = 0 ;
27706 PyObject * obj1 = 0 ;
27707 PyObject * obj2 = 0 ;
27708 char * kwnames[] = {
27709 (char *) "self",(char *) "win",(char *) "event", NULL
27710 };
27711
27712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27714 if (!SWIG_IsOK(res1)) {
27715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27716 }
27717 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27719 if (!SWIG_IsOK(res2)) {
27720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27721 }
27722 arg2 = reinterpret_cast< wxWindow * >(argp2);
27723 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27724 if (!SWIG_IsOK(res3)) {
27725 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27726 }
27727 if (!argp3) {
27728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27729 }
27730 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27731 {
27732 PyThreadState* __tstate = wxPyBeginAllowThreads();
27733 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27734 wxPyEndAllowThreads(__tstate);
27735 if (PyErr_Occurred()) SWIG_fail;
27736 }
27737 {
27738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27739 }
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27747 PyObject *resultobj = 0;
27748 wxPyApp *arg1 = (wxPyApp *) 0 ;
27749 bool result;
27750 void *argp1 = 0 ;
27751 int res1 = 0 ;
27752 PyObject *swig_obj[1] ;
27753
27754 if (!args) SWIG_fail;
27755 swig_obj[0] = args;
27756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27757 if (!SWIG_IsOK(res1)) {
27758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27759 }
27760 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27761 {
27762 PyThreadState* __tstate = wxPyBeginAllowThreads();
27763 result = (bool)((wxPyApp const *)arg1)->IsActive();
27764 wxPyEndAllowThreads(__tstate);
27765 if (PyErr_Occurred()) SWIG_fail;
27766 }
27767 {
27768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27769 }
27770 return resultobj;
27771 fail:
27772 return NULL;
27773 }
27774
27775
27776 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27777 PyObject *resultobj = 0;
27778 wxPyApp *arg1 = (wxPyApp *) 0 ;
27779 wxWindow *arg2 = (wxWindow *) 0 ;
27780 void *argp1 = 0 ;
27781 int res1 = 0 ;
27782 void *argp2 = 0 ;
27783 int res2 = 0 ;
27784 PyObject * obj0 = 0 ;
27785 PyObject * obj1 = 0 ;
27786 char * kwnames[] = {
27787 (char *) "self",(char *) "win", NULL
27788 };
27789
27790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27792 if (!SWIG_IsOK(res1)) {
27793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27794 }
27795 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27796 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27797 if (!SWIG_IsOK(res2)) {
27798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27799 }
27800 arg2 = reinterpret_cast< wxWindow * >(argp2);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 (arg1)->SetTopWindow(arg2);
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 resultobj = SWIG_Py_Void();
27808 return resultobj;
27809 fail:
27810 return NULL;
27811 }
27812
27813
27814 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27815 PyObject *resultobj = 0;
27816 wxPyApp *arg1 = (wxPyApp *) 0 ;
27817 wxWindow *result = 0 ;
27818 void *argp1 = 0 ;
27819 int res1 = 0 ;
27820 PyObject *swig_obj[1] ;
27821
27822 if (!args) SWIG_fail;
27823 swig_obj[0] = args;
27824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27825 if (!SWIG_IsOK(res1)) {
27826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27827 }
27828 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27829 {
27830 PyThreadState* __tstate = wxPyBeginAllowThreads();
27831 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 {
27836 resultobj = wxPyMake_wxObject(result, (bool)0);
27837 }
27838 return resultobj;
27839 fail:
27840 return NULL;
27841 }
27842
27843
27844 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27845 PyObject *resultobj = 0;
27846 wxPyApp *arg1 = (wxPyApp *) 0 ;
27847 bool arg2 ;
27848 void *argp1 = 0 ;
27849 int res1 = 0 ;
27850 bool val2 ;
27851 int ecode2 = 0 ;
27852 PyObject * obj0 = 0 ;
27853 PyObject * obj1 = 0 ;
27854 char * kwnames[] = {
27855 (char *) "self",(char *) "flag", NULL
27856 };
27857
27858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27860 if (!SWIG_IsOK(res1)) {
27861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27862 }
27863 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27864 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27865 if (!SWIG_IsOK(ecode2)) {
27866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27867 }
27868 arg2 = static_cast< bool >(val2);
27869 {
27870 PyThreadState* __tstate = wxPyBeginAllowThreads();
27871 (arg1)->SetExitOnFrameDelete(arg2);
27872 wxPyEndAllowThreads(__tstate);
27873 if (PyErr_Occurred()) SWIG_fail;
27874 }
27875 resultobj = SWIG_Py_Void();
27876 return resultobj;
27877 fail:
27878 return NULL;
27879 }
27880
27881
27882 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27883 PyObject *resultobj = 0;
27884 wxPyApp *arg1 = (wxPyApp *) 0 ;
27885 bool result;
27886 void *argp1 = 0 ;
27887 int res1 = 0 ;
27888 PyObject *swig_obj[1] ;
27889
27890 if (!args) SWIG_fail;
27891 swig_obj[0] = args;
27892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27893 if (!SWIG_IsOK(res1)) {
27894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27895 }
27896 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27897 {
27898 PyThreadState* __tstate = wxPyBeginAllowThreads();
27899 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 {
27904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27905 }
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj = 0;
27914 wxPyApp *arg1 = (wxPyApp *) 0 ;
27915 bool arg2 ;
27916 void *argp1 = 0 ;
27917 int res1 = 0 ;
27918 bool val2 ;
27919 int ecode2 = 0 ;
27920 PyObject * obj0 = 0 ;
27921 PyObject * obj1 = 0 ;
27922 char * kwnames[] = {
27923 (char *) "self",(char *) "flag", NULL
27924 };
27925
27926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27928 if (!SWIG_IsOK(res1)) {
27929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27930 }
27931 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27932 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27933 if (!SWIG_IsOK(ecode2)) {
27934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27935 }
27936 arg2 = static_cast< bool >(val2);
27937 {
27938 PyThreadState* __tstate = wxPyBeginAllowThreads();
27939 (arg1)->SetUseBestVisual(arg2);
27940 wxPyEndAllowThreads(__tstate);
27941 if (PyErr_Occurred()) SWIG_fail;
27942 }
27943 resultobj = SWIG_Py_Void();
27944 return resultobj;
27945 fail:
27946 return NULL;
27947 }
27948
27949
27950 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27951 PyObject *resultobj = 0;
27952 wxPyApp *arg1 = (wxPyApp *) 0 ;
27953 bool result;
27954 void *argp1 = 0 ;
27955 int res1 = 0 ;
27956 PyObject *swig_obj[1] ;
27957
27958 if (!args) SWIG_fail;
27959 swig_obj[0] = args;
27960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27961 if (!SWIG_IsOK(res1)) {
27962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27963 }
27964 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27965 {
27966 PyThreadState* __tstate = wxPyBeginAllowThreads();
27967 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27968 wxPyEndAllowThreads(__tstate);
27969 if (PyErr_Occurred()) SWIG_fail;
27970 }
27971 {
27972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27973 }
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27981 PyObject *resultobj = 0;
27982 wxPyApp *arg1 = (wxPyApp *) 0 ;
27983 int arg2 ;
27984 void *argp1 = 0 ;
27985 int res1 = 0 ;
27986 int val2 ;
27987 int ecode2 = 0 ;
27988 PyObject * obj0 = 0 ;
27989 PyObject * obj1 = 0 ;
27990 char * kwnames[] = {
27991 (char *) "self",(char *) "mode", NULL
27992 };
27993
27994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27996 if (!SWIG_IsOK(res1)) {
27997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27998 }
27999 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28000 ecode2 = SWIG_AsVal_int(obj1, &val2);
28001 if (!SWIG_IsOK(ecode2)) {
28002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28003 }
28004 arg2 = static_cast< int >(val2);
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 (arg1)->SetPrintMode(arg2);
28008 wxPyEndAllowThreads(__tstate);
28009 if (PyErr_Occurred()) SWIG_fail;
28010 }
28011 resultobj = SWIG_Py_Void();
28012 return resultobj;
28013 fail:
28014 return NULL;
28015 }
28016
28017
28018 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28019 PyObject *resultobj = 0;
28020 wxPyApp *arg1 = (wxPyApp *) 0 ;
28021 int result;
28022 void *argp1 = 0 ;
28023 int res1 = 0 ;
28024 PyObject *swig_obj[1] ;
28025
28026 if (!args) SWIG_fail;
28027 swig_obj[0] = args;
28028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28029 if (!SWIG_IsOK(res1)) {
28030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28031 }
28032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 resultobj = SWIG_From_int(static_cast< int >(result));
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj = 0;
28048 wxPyApp *arg1 = (wxPyApp *) 0 ;
28049 int arg2 ;
28050 void *argp1 = 0 ;
28051 int res1 = 0 ;
28052 int val2 ;
28053 int ecode2 = 0 ;
28054 PyObject * obj0 = 0 ;
28055 PyObject * obj1 = 0 ;
28056 char * kwnames[] = {
28057 (char *) "self",(char *) "mode", NULL
28058 };
28059
28060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28062 if (!SWIG_IsOK(res1)) {
28063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28064 }
28065 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28066 ecode2 = SWIG_AsVal_int(obj1, &val2);
28067 if (!SWIG_IsOK(ecode2)) {
28068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28069 }
28070 arg2 = static_cast< int >(val2);
28071 {
28072 PyThreadState* __tstate = wxPyBeginAllowThreads();
28073 (arg1)->SetAssertMode(arg2);
28074 wxPyEndAllowThreads(__tstate);
28075 if (PyErr_Occurred()) SWIG_fail;
28076 }
28077 resultobj = SWIG_Py_Void();
28078 return resultobj;
28079 fail:
28080 return NULL;
28081 }
28082
28083
28084 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28085 PyObject *resultobj = 0;
28086 wxPyApp *arg1 = (wxPyApp *) 0 ;
28087 int result;
28088 void *argp1 = 0 ;
28089 int res1 = 0 ;
28090 PyObject *swig_obj[1] ;
28091
28092 if (!args) SWIG_fail;
28093 swig_obj[0] = args;
28094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28095 if (!SWIG_IsOK(res1)) {
28096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28097 }
28098 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = (int)(arg1)->GetAssertMode();
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 resultobj = SWIG_From_int(static_cast< int >(result));
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28113 PyObject *resultobj = 0;
28114 bool result;
28115
28116 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28120 wxPyEndAllowThreads(__tstate);
28121 if (PyErr_Occurred()) SWIG_fail;
28122 }
28123 {
28124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28125 }
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28133 PyObject *resultobj = 0;
28134 long result;
28135
28136 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 result = (long)wxPyApp::GetMacAboutMenuItemId();
28140 wxPyEndAllowThreads(__tstate);
28141 if (PyErr_Occurred()) SWIG_fail;
28142 }
28143 resultobj = SWIG_From_long(static_cast< long >(result));
28144 return resultobj;
28145 fail:
28146 return NULL;
28147 }
28148
28149
28150 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28151 PyObject *resultobj = 0;
28152 long result;
28153
28154 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28155 {
28156 PyThreadState* __tstate = wxPyBeginAllowThreads();
28157 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28158 wxPyEndAllowThreads(__tstate);
28159 if (PyErr_Occurred()) SWIG_fail;
28160 }
28161 resultobj = SWIG_From_long(static_cast< long >(result));
28162 return resultobj;
28163 fail:
28164 return NULL;
28165 }
28166
28167
28168 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28169 PyObject *resultobj = 0;
28170 long result;
28171
28172 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 result = (long)wxPyApp::GetMacExitMenuItemId();
28176 wxPyEndAllowThreads(__tstate);
28177 if (PyErr_Occurred()) SWIG_fail;
28178 }
28179 resultobj = SWIG_From_long(static_cast< long >(result));
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28187 PyObject *resultobj = 0;
28188 wxString result;
28189
28190 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28191 {
28192 PyThreadState* __tstate = wxPyBeginAllowThreads();
28193 result = wxPyApp::GetMacHelpMenuTitleName();
28194 wxPyEndAllowThreads(__tstate);
28195 if (PyErr_Occurred()) SWIG_fail;
28196 }
28197 {
28198 #if wxUSE_UNICODE
28199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28200 #else
28201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28202 #endif
28203 }
28204 return resultobj;
28205 fail:
28206 return NULL;
28207 }
28208
28209
28210 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28211 PyObject *resultobj = 0;
28212 bool arg1 ;
28213 bool val1 ;
28214 int ecode1 = 0 ;
28215 PyObject * obj0 = 0 ;
28216 char * kwnames[] = {
28217 (char *) "val", NULL
28218 };
28219
28220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28221 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28222 if (!SWIG_IsOK(ecode1)) {
28223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28224 }
28225 arg1 = static_cast< bool >(val1);
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 resultobj = SWIG_Py_Void();
28233 return resultobj;
28234 fail:
28235 return NULL;
28236 }
28237
28238
28239 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28240 PyObject *resultobj = 0;
28241 long arg1 ;
28242 long val1 ;
28243 int ecode1 = 0 ;
28244 PyObject * obj0 = 0 ;
28245 char * kwnames[] = {
28246 (char *) "val", NULL
28247 };
28248
28249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28250 ecode1 = SWIG_AsVal_long(obj0, &val1);
28251 if (!SWIG_IsOK(ecode1)) {
28252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28253 }
28254 arg1 = static_cast< long >(val1);
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 wxPyApp::SetMacAboutMenuItemId(arg1);
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 resultobj = SWIG_Py_Void();
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28269 PyObject *resultobj = 0;
28270 long arg1 ;
28271 long val1 ;
28272 int ecode1 = 0 ;
28273 PyObject * obj0 = 0 ;
28274 char * kwnames[] = {
28275 (char *) "val", NULL
28276 };
28277
28278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28279 ecode1 = SWIG_AsVal_long(obj0, &val1);
28280 if (!SWIG_IsOK(ecode1)) {
28281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28282 }
28283 arg1 = static_cast< long >(val1);
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 resultobj = SWIG_Py_Void();
28291 return resultobj;
28292 fail:
28293 return NULL;
28294 }
28295
28296
28297 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28298 PyObject *resultobj = 0;
28299 long arg1 ;
28300 long val1 ;
28301 int ecode1 = 0 ;
28302 PyObject * obj0 = 0 ;
28303 char * kwnames[] = {
28304 (char *) "val", NULL
28305 };
28306
28307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28308 ecode1 = SWIG_AsVal_long(obj0, &val1);
28309 if (!SWIG_IsOK(ecode1)) {
28310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28311 }
28312 arg1 = static_cast< long >(val1);
28313 {
28314 PyThreadState* __tstate = wxPyBeginAllowThreads();
28315 wxPyApp::SetMacExitMenuItemId(arg1);
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 resultobj = SWIG_Py_Void();
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28327 PyObject *resultobj = 0;
28328 wxString *arg1 = 0 ;
28329 bool temp1 = false ;
28330 PyObject * obj0 = 0 ;
28331 char * kwnames[] = {
28332 (char *) "val", NULL
28333 };
28334
28335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28336 {
28337 arg1 = wxString_in_helper(obj0);
28338 if (arg1 == NULL) SWIG_fail;
28339 temp1 = true;
28340 }
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 resultobj = SWIG_Py_Void();
28348 {
28349 if (temp1)
28350 delete arg1;
28351 }
28352 return resultobj;
28353 fail:
28354 {
28355 if (temp1)
28356 delete arg1;
28357 }
28358 return NULL;
28359 }
28360
28361
28362 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28363 PyObject *resultobj = 0;
28364 wxPyApp *arg1 = (wxPyApp *) 0 ;
28365 void *argp1 = 0 ;
28366 int res1 = 0 ;
28367 PyObject *swig_obj[1] ;
28368
28369 if (!args) SWIG_fail;
28370 swig_obj[0] = args;
28371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28372 if (!SWIG_IsOK(res1)) {
28373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28374 }
28375 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28376 {
28377 PyThreadState* __tstate = wxPyBeginAllowThreads();
28378 (arg1)->_BootstrapApp();
28379 wxPyEndAllowThreads(__tstate);
28380 if (PyErr_Occurred()) SWIG_fail;
28381 }
28382 resultobj = SWIG_Py_Void();
28383 return resultobj;
28384 fail:
28385 return NULL;
28386 }
28387
28388
28389 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28390 PyObject *resultobj = 0;
28391 int result;
28392
28393 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (int)wxPyApp_GetComCtl32Version();
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 resultobj = SWIG_From_int(static_cast< int >(result));
28401 return resultobj;
28402 fail:
28403 return NULL;
28404 }
28405
28406
28407 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28408 PyObject *obj;
28409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28410 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28411 return SWIG_Py_Void();
28412 }
28413
28414 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28415 return SWIG_Python_InitShadowInstance(args);
28416 }
28417
28418 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28419 PyObject *resultobj = 0;
28420
28421 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 wxExit();
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_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28436 PyObject *resultobj = 0;
28437 bool result;
28438
28439 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28440 {
28441 PyThreadState* __tstate = wxPyBeginAllowThreads();
28442 result = (bool)wxYield();
28443 wxPyEndAllowThreads(__tstate);
28444 if (PyErr_Occurred()) SWIG_fail;
28445 }
28446 {
28447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28448 }
28449 return resultobj;
28450 fail:
28451 return NULL;
28452 }
28453
28454
28455 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28456 PyObject *resultobj = 0;
28457 bool result;
28458
28459 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = (bool)wxYieldIfNeeded();
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 {
28467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28468 }
28469 return resultobj;
28470 fail:
28471 return NULL;
28472 }
28473
28474
28475 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28476 PyObject *resultobj = 0;
28477 wxWindow *arg1 = (wxWindow *) NULL ;
28478 bool arg2 = (bool) false ;
28479 bool result;
28480 void *argp1 = 0 ;
28481 int res1 = 0 ;
28482 bool val2 ;
28483 int ecode2 = 0 ;
28484 PyObject * obj0 = 0 ;
28485 PyObject * obj1 = 0 ;
28486 char * kwnames[] = {
28487 (char *) "win",(char *) "onlyIfNeeded", NULL
28488 };
28489
28490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28491 if (obj0) {
28492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28493 if (!SWIG_IsOK(res1)) {
28494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28495 }
28496 arg1 = reinterpret_cast< wxWindow * >(argp1);
28497 }
28498 if (obj1) {
28499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28500 if (!SWIG_IsOK(ecode2)) {
28501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28502 }
28503 arg2 = static_cast< bool >(val2);
28504 }
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (bool)wxSafeYield(arg1,arg2);
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 {
28512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28513 }
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28521 PyObject *resultobj = 0;
28522
28523 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 wxWakeUpIdle();
28527 wxPyEndAllowThreads(__tstate);
28528 if (PyErr_Occurred()) SWIG_fail;
28529 }
28530 resultobj = SWIG_Py_Void();
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28538 PyObject *resultobj = 0;
28539 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28540 wxEvent *arg2 = 0 ;
28541 void *argp1 = 0 ;
28542 int res1 = 0 ;
28543 void *argp2 = 0 ;
28544 int res2 = 0 ;
28545 PyObject * obj0 = 0 ;
28546 PyObject * obj1 = 0 ;
28547 char * kwnames[] = {
28548 (char *) "dest",(char *) "event", NULL
28549 };
28550
28551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28553 if (!SWIG_IsOK(res1)) {
28554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28555 }
28556 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28557 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28558 if (!SWIG_IsOK(res2)) {
28559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28560 }
28561 if (!argp2) {
28562 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28563 }
28564 arg2 = reinterpret_cast< wxEvent * >(argp2);
28565 {
28566 PyThreadState* __tstate = wxPyBeginAllowThreads();
28567 wxPostEvent(arg1,*arg2);
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 resultobj = SWIG_Py_Void();
28572 return resultobj;
28573 fail:
28574 return NULL;
28575 }
28576
28577
28578 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28579 PyObject *resultobj = 0;
28580
28581 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28582 {
28583 PyThreadState* __tstate = wxPyBeginAllowThreads();
28584 wxApp_CleanUp();
28585 wxPyEndAllowThreads(__tstate);
28586 if (PyErr_Occurred()) SWIG_fail;
28587 }
28588 resultobj = SWIG_Py_Void();
28589 return resultobj;
28590 fail:
28591 return NULL;
28592 }
28593
28594
28595 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28596 PyObject *resultobj = 0;
28597 wxPyApp *result = 0 ;
28598
28599 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 result = (wxPyApp *)wxPyGetApp();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 resultobj = wxPyMake_wxObject(result, 0);
28608 }
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28616 PyObject *resultobj = 0;
28617 char *arg1 = (char *) 0 ;
28618 int res1 ;
28619 char *buf1 = 0 ;
28620 int alloc1 = 0 ;
28621 PyObject * obj0 = 0 ;
28622 char * kwnames[] = {
28623 (char *) "encoding", NULL
28624 };
28625
28626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28627 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28628 if (!SWIG_IsOK(res1)) {
28629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28630 }
28631 arg1 = buf1;
28632 {
28633 PyThreadState* __tstate = wxPyBeginAllowThreads();
28634 wxSetDefaultPyEncoding((char const *)arg1);
28635 wxPyEndAllowThreads(__tstate);
28636 if (PyErr_Occurred()) SWIG_fail;
28637 }
28638 resultobj = SWIG_Py_Void();
28639 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28640 return resultobj;
28641 fail:
28642 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28648 PyObject *resultobj = 0;
28649 char *result = 0 ;
28650
28651 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 result = (char *)wxGetDefaultPyEncoding();
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 resultobj = SWIG_FromCharPtr(result);
28659 return resultobj;
28660 fail:
28661 return NULL;
28662 }
28663
28664
28665 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28666 PyObject *resultobj = 0;
28667 wxEventLoop *result = 0 ;
28668
28669 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28670 {
28671 PyThreadState* __tstate = wxPyBeginAllowThreads();
28672 result = (wxEventLoop *)new wxEventLoop();
28673 wxPyEndAllowThreads(__tstate);
28674 if (PyErr_Occurred()) SWIG_fail;
28675 }
28676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28684 PyObject *resultobj = 0;
28685 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28686 void *argp1 = 0 ;
28687 int res1 = 0 ;
28688 PyObject *swig_obj[1] ;
28689
28690 if (!args) SWIG_fail;
28691 swig_obj[0] = args;
28692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28693 if (!SWIG_IsOK(res1)) {
28694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28695 }
28696 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28697 {
28698 PyThreadState* __tstate = wxPyBeginAllowThreads();
28699 delete arg1;
28700
28701 wxPyEndAllowThreads(__tstate);
28702 if (PyErr_Occurred()) SWIG_fail;
28703 }
28704 resultobj = SWIG_Py_Void();
28705 return resultobj;
28706 fail:
28707 return NULL;
28708 }
28709
28710
28711 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28712 PyObject *resultobj = 0;
28713 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28714 int result;
28715 void *argp1 = 0 ;
28716 int res1 = 0 ;
28717 PyObject *swig_obj[1] ;
28718
28719 if (!args) SWIG_fail;
28720 swig_obj[0] = args;
28721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28722 if (!SWIG_IsOK(res1)) {
28723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28724 }
28725 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 result = (int)(arg1)->Run();
28729 wxPyEndAllowThreads(__tstate);
28730 if (PyErr_Occurred()) SWIG_fail;
28731 }
28732 resultobj = SWIG_From_int(static_cast< int >(result));
28733 return resultobj;
28734 fail:
28735 return NULL;
28736 }
28737
28738
28739 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28740 PyObject *resultobj = 0;
28741 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28742 int arg2 = (int) 0 ;
28743 void *argp1 = 0 ;
28744 int res1 = 0 ;
28745 int val2 ;
28746 int ecode2 = 0 ;
28747 PyObject * obj0 = 0 ;
28748 PyObject * obj1 = 0 ;
28749 char * kwnames[] = {
28750 (char *) "self",(char *) "rc", NULL
28751 };
28752
28753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28755 if (!SWIG_IsOK(res1)) {
28756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28757 }
28758 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28759 if (obj1) {
28760 ecode2 = SWIG_AsVal_int(obj1, &val2);
28761 if (!SWIG_IsOK(ecode2)) {
28762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28763 }
28764 arg2 = static_cast< int >(val2);
28765 }
28766 {
28767 PyThreadState* __tstate = wxPyBeginAllowThreads();
28768 (arg1)->Exit(arg2);
28769 wxPyEndAllowThreads(__tstate);
28770 if (PyErr_Occurred()) SWIG_fail;
28771 }
28772 resultobj = SWIG_Py_Void();
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28780 PyObject *resultobj = 0;
28781 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28782 bool result;
28783 void *argp1 = 0 ;
28784 int res1 = 0 ;
28785 PyObject *swig_obj[1] ;
28786
28787 if (!args) SWIG_fail;
28788 swig_obj[0] = args;
28789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28790 if (!SWIG_IsOK(res1)) {
28791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28792 }
28793 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 result = (bool)((wxEventLoop const *)arg1)->Pending();
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 {
28801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28802 }
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28810 PyObject *resultobj = 0;
28811 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28812 bool result;
28813 void *argp1 = 0 ;
28814 int res1 = 0 ;
28815 PyObject *swig_obj[1] ;
28816
28817 if (!args) SWIG_fail;
28818 swig_obj[0] = args;
28819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28820 if (!SWIG_IsOK(res1)) {
28821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28822 }
28823 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28824 {
28825 PyThreadState* __tstate = wxPyBeginAllowThreads();
28826 result = (bool)(arg1)->Dispatch();
28827 wxPyEndAllowThreads(__tstate);
28828 if (PyErr_Occurred()) SWIG_fail;
28829 }
28830 {
28831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28832 }
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28840 PyObject *resultobj = 0;
28841 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28842 bool result;
28843 void *argp1 = 0 ;
28844 int res1 = 0 ;
28845 PyObject *swig_obj[1] ;
28846
28847 if (!args) SWIG_fail;
28848 swig_obj[0] = args;
28849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28850 if (!SWIG_IsOK(res1)) {
28851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28852 }
28853 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28857 wxPyEndAllowThreads(__tstate);
28858 if (PyErr_Occurred()) SWIG_fail;
28859 }
28860 {
28861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28862 }
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28870 PyObject *resultobj = 0;
28871 wxEventLoop *result = 0 ;
28872
28873 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28874 {
28875 PyThreadState* __tstate = wxPyBeginAllowThreads();
28876 result = (wxEventLoop *)wxEventLoop::GetActive();
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28881 return resultobj;
28882 fail:
28883 return NULL;
28884 }
28885
28886
28887 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28888 PyObject *resultobj = 0;
28889 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28890 void *argp1 = 0 ;
28891 int res1 = 0 ;
28892 PyObject * obj0 = 0 ;
28893 char * kwnames[] = {
28894 (char *) "loop", NULL
28895 };
28896
28897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28899 if (!SWIG_IsOK(res1)) {
28900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28901 }
28902 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28903 {
28904 PyThreadState* __tstate = wxPyBeginAllowThreads();
28905 wxEventLoop::SetActive(arg1);
28906 wxPyEndAllowThreads(__tstate);
28907 if (PyErr_Occurred()) SWIG_fail;
28908 }
28909 resultobj = SWIG_Py_Void();
28910 return resultobj;
28911 fail:
28912 return NULL;
28913 }
28914
28915
28916 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28917 PyObject *obj;
28918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28919 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28920 return SWIG_Py_Void();
28921 }
28922
28923 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28924 return SWIG_Python_InitShadowInstance(args);
28925 }
28926
28927 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28928 PyObject *resultobj = 0;
28929 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28930 wxEventLoopActivator *result = 0 ;
28931 void *argp1 = 0 ;
28932 int res1 = 0 ;
28933 PyObject * obj0 = 0 ;
28934 char * kwnames[] = {
28935 (char *) "evtLoop", NULL
28936 };
28937
28938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28940 if (!SWIG_IsOK(res1)) {
28941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28942 }
28943 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28944 {
28945 PyThreadState* __tstate = wxPyBeginAllowThreads();
28946 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28958 PyObject *resultobj = 0;
28959 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28960 void *argp1 = 0 ;
28961 int res1 = 0 ;
28962 PyObject *swig_obj[1] ;
28963
28964 if (!args) SWIG_fail;
28965 swig_obj[0] = args;
28966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28967 if (!SWIG_IsOK(res1)) {
28968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28969 }
28970 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28971 {
28972 PyThreadState* __tstate = wxPyBeginAllowThreads();
28973 delete arg1;
28974
28975 wxPyEndAllowThreads(__tstate);
28976 if (PyErr_Occurred()) SWIG_fail;
28977 }
28978 resultobj = SWIG_Py_Void();
28979 return resultobj;
28980 fail:
28981 return NULL;
28982 }
28983
28984
28985 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28986 PyObject *obj;
28987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28988 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28989 return SWIG_Py_Void();
28990 }
28991
28992 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28993 return SWIG_Python_InitShadowInstance(args);
28994 }
28995
28996 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28997 PyObject *resultobj = 0;
28998 int arg1 = (int) 0 ;
28999 int arg2 = (int) 0 ;
29000 int arg3 = (int) 0 ;
29001 wxAcceleratorEntry *result = 0 ;
29002 int val1 ;
29003 int ecode1 = 0 ;
29004 int val2 ;
29005 int ecode2 = 0 ;
29006 int val3 ;
29007 int ecode3 = 0 ;
29008 PyObject * obj0 = 0 ;
29009 PyObject * obj1 = 0 ;
29010 PyObject * obj2 = 0 ;
29011 char * kwnames[] = {
29012 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29013 };
29014
29015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29016 if (obj0) {
29017 ecode1 = SWIG_AsVal_int(obj0, &val1);
29018 if (!SWIG_IsOK(ecode1)) {
29019 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29020 }
29021 arg1 = static_cast< int >(val1);
29022 }
29023 if (obj1) {
29024 ecode2 = SWIG_AsVal_int(obj1, &val2);
29025 if (!SWIG_IsOK(ecode2)) {
29026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29027 }
29028 arg2 = static_cast< int >(val2);
29029 }
29030 if (obj2) {
29031 ecode3 = SWIG_AsVal_int(obj2, &val3);
29032 if (!SWIG_IsOK(ecode3)) {
29033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29034 }
29035 arg3 = static_cast< int >(val3);
29036 }
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29051 PyObject *resultobj = 0;
29052 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29053 void *argp1 = 0 ;
29054 int res1 = 0 ;
29055 PyObject *swig_obj[1] ;
29056
29057 if (!args) SWIG_fail;
29058 swig_obj[0] = args;
29059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29060 if (!SWIG_IsOK(res1)) {
29061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29062 }
29063 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29064 {
29065 PyThreadState* __tstate = wxPyBeginAllowThreads();
29066 delete arg1;
29067
29068 wxPyEndAllowThreads(__tstate);
29069 if (PyErr_Occurred()) SWIG_fail;
29070 }
29071 resultobj = SWIG_Py_Void();
29072 return resultobj;
29073 fail:
29074 return NULL;
29075 }
29076
29077
29078 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29079 PyObject *resultobj = 0;
29080 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29081 int arg2 ;
29082 int arg3 ;
29083 int arg4 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 int val2 ;
29087 int ecode2 = 0 ;
29088 int val3 ;
29089 int ecode3 = 0 ;
29090 int val4 ;
29091 int ecode4 = 0 ;
29092 PyObject * obj0 = 0 ;
29093 PyObject * obj1 = 0 ;
29094 PyObject * obj2 = 0 ;
29095 PyObject * obj3 = 0 ;
29096 char * kwnames[] = {
29097 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29098 };
29099
29100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29102 if (!SWIG_IsOK(res1)) {
29103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29104 }
29105 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29106 ecode2 = SWIG_AsVal_int(obj1, &val2);
29107 if (!SWIG_IsOK(ecode2)) {
29108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29109 }
29110 arg2 = static_cast< int >(val2);
29111 ecode3 = SWIG_AsVal_int(obj2, &val3);
29112 if (!SWIG_IsOK(ecode3)) {
29113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29114 }
29115 arg3 = static_cast< int >(val3);
29116 ecode4 = SWIG_AsVal_int(obj3, &val4);
29117 if (!SWIG_IsOK(ecode4)) {
29118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29119 }
29120 arg4 = static_cast< int >(val4);
29121 {
29122 PyThreadState* __tstate = wxPyBeginAllowThreads();
29123 (arg1)->Set(arg2,arg3,arg4);
29124 wxPyEndAllowThreads(__tstate);
29125 if (PyErr_Occurred()) SWIG_fail;
29126 }
29127 resultobj = SWIG_Py_Void();
29128 return resultobj;
29129 fail:
29130 return NULL;
29131 }
29132
29133
29134 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29135 PyObject *resultobj = 0;
29136 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29137 int result;
29138 void *argp1 = 0 ;
29139 int res1 = 0 ;
29140 PyObject *swig_obj[1] ;
29141
29142 if (!args) SWIG_fail;
29143 swig_obj[0] = args;
29144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29145 if (!SWIG_IsOK(res1)) {
29146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29147 }
29148 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 result = (int)(arg1)->GetFlags();
29152 wxPyEndAllowThreads(__tstate);
29153 if (PyErr_Occurred()) SWIG_fail;
29154 }
29155 resultobj = SWIG_From_int(static_cast< int >(result));
29156 return resultobj;
29157 fail:
29158 return NULL;
29159 }
29160
29161
29162 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29163 PyObject *resultobj = 0;
29164 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29165 int result;
29166 void *argp1 = 0 ;
29167 int res1 = 0 ;
29168 PyObject *swig_obj[1] ;
29169
29170 if (!args) SWIG_fail;
29171 swig_obj[0] = args;
29172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29173 if (!SWIG_IsOK(res1)) {
29174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29175 }
29176 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = (int)(arg1)->GetKeyCode();
29180 wxPyEndAllowThreads(__tstate);
29181 if (PyErr_Occurred()) SWIG_fail;
29182 }
29183 resultobj = SWIG_From_int(static_cast< int >(result));
29184 return resultobj;
29185 fail:
29186 return NULL;
29187 }
29188
29189
29190 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29191 PyObject *resultobj = 0;
29192 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29193 int result;
29194 void *argp1 = 0 ;
29195 int res1 = 0 ;
29196 PyObject *swig_obj[1] ;
29197
29198 if (!args) SWIG_fail;
29199 swig_obj[0] = args;
29200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29201 if (!SWIG_IsOK(res1)) {
29202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29203 }
29204 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 result = (int)(arg1)->GetCommand();
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 resultobj = SWIG_From_int(static_cast< int >(result));
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29219 PyObject *obj;
29220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29221 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29222 return SWIG_Py_Void();
29223 }
29224
29225 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29226 return SWIG_Python_InitShadowInstance(args);
29227 }
29228
29229 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29230 PyObject *resultobj = 0;
29231 int arg1 ;
29232 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29233 wxAcceleratorTable *result = 0 ;
29234 PyObject * obj0 = 0 ;
29235 char * kwnames[] = {
29236 (char *) "n", NULL
29237 };
29238
29239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29240 {
29241 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29242 if (arg2) arg1 = PyList_Size(obj0);
29243 else arg1 = 0;
29244 }
29245 {
29246 PyThreadState* __tstate = wxPyBeginAllowThreads();
29247 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29259 PyObject *resultobj = 0;
29260 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29261 void *argp1 = 0 ;
29262 int res1 = 0 ;
29263 PyObject *swig_obj[1] ;
29264
29265 if (!args) SWIG_fail;
29266 swig_obj[0] = args;
29267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29268 if (!SWIG_IsOK(res1)) {
29269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29270 }
29271 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29272 {
29273 PyThreadState* __tstate = wxPyBeginAllowThreads();
29274 delete arg1;
29275
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 resultobj = SWIG_Py_Void();
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29287 PyObject *resultobj = 0;
29288 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29289 bool result;
29290 void *argp1 = 0 ;
29291 int res1 = 0 ;
29292 PyObject *swig_obj[1] ;
29293
29294 if (!args) SWIG_fail;
29295 swig_obj[0] = args;
29296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29297 if (!SWIG_IsOK(res1)) {
29298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29299 }
29300 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 {
29308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29309 }
29310 return resultobj;
29311 fail:
29312 return NULL;
29313 }
29314
29315
29316 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29317 PyObject *obj;
29318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29319 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29320 return SWIG_Py_Void();
29321 }
29322
29323 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29324 return SWIG_Python_InitShadowInstance(args);
29325 }
29326
29327 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29328 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29329 return 1;
29330 }
29331
29332
29333 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29334 PyObject *pyobj = 0;
29335
29336 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29337 return pyobj;
29338 }
29339
29340
29341 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29342 PyObject *resultobj = 0;
29343 wxString *arg1 = 0 ;
29344 wxAcceleratorEntry *result = 0 ;
29345 bool temp1 = false ;
29346 PyObject * obj0 = 0 ;
29347 char * kwnames[] = {
29348 (char *) "label", NULL
29349 };
29350
29351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29352 {
29353 arg1 = wxString_in_helper(obj0);
29354 if (arg1 == NULL) SWIG_fail;
29355 temp1 = true;
29356 }
29357 {
29358 PyThreadState* __tstate = wxPyBeginAllowThreads();
29359 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29360 wxPyEndAllowThreads(__tstate);
29361 if (PyErr_Occurred()) SWIG_fail;
29362 }
29363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29364 {
29365 if (temp1)
29366 delete arg1;
29367 }
29368 return resultobj;
29369 fail:
29370 {
29371 if (temp1)
29372 delete arg1;
29373 }
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN int PanelNameStr_set(PyObject *) {
29379 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29380 return 1;
29381 }
29382
29383
29384 SWIGINTERN PyObject *PanelNameStr_get(void) {
29385 PyObject *pyobj = 0;
29386
29387 {
29388 #if wxUSE_UNICODE
29389 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29390 #else
29391 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29392 #endif
29393 }
29394 return pyobj;
29395 }
29396
29397
29398 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29399 PyObject *resultobj = 0;
29400 wxVisualAttributes *result = 0 ;
29401
29402 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 result = (wxVisualAttributes *)new_wxVisualAttributes();
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 PyObject *resultobj = 0;
29418 wxVisualAttributes *arg1 = (wxVisualAttributes *) 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_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29428 }
29429 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 delete_wxVisualAttributes(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_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29445 PyObject *resultobj = 0;
29446 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29447 wxFont *arg2 = (wxFont *) 0 ;
29448 void *argp1 = 0 ;
29449 int res1 = 0 ;
29450 void *argp2 = 0 ;
29451 int res2 = 0 ;
29452 PyObject *swig_obj[2] ;
29453
29454 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29456 if (!SWIG_IsOK(res1)) {
29457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29458 }
29459 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29460 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29461 if (!SWIG_IsOK(res2)) {
29462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29463 }
29464 arg2 = reinterpret_cast< wxFont * >(argp2);
29465 if (arg1) (arg1)->font = *arg2;
29466
29467 resultobj = SWIG_Py_Void();
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29475 PyObject *resultobj = 0;
29476 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29477 wxFont *result = 0 ;
29478 void *argp1 = 0 ;
29479 int res1 = 0 ;
29480 PyObject *swig_obj[1] ;
29481
29482 if (!args) SWIG_fail;
29483 swig_obj[0] = args;
29484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29485 if (!SWIG_IsOK(res1)) {
29486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29487 }
29488 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29489 result = (wxFont *)& ((arg1)->font);
29490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29491 return resultobj;
29492 fail:
29493 return NULL;
29494 }
29495
29496
29497 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29498 PyObject *resultobj = 0;
29499 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29500 wxColour *arg2 = (wxColour *) 0 ;
29501 void *argp1 = 0 ;
29502 int res1 = 0 ;
29503 void *argp2 = 0 ;
29504 int res2 = 0 ;
29505 PyObject *swig_obj[2] ;
29506
29507 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29509 if (!SWIG_IsOK(res1)) {
29510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29511 }
29512 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29513 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29514 if (!SWIG_IsOK(res2)) {
29515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29516 }
29517 arg2 = reinterpret_cast< wxColour * >(argp2);
29518 if (arg1) (arg1)->colFg = *arg2;
29519
29520 resultobj = SWIG_Py_Void();
29521 return resultobj;
29522 fail:
29523 return NULL;
29524 }
29525
29526
29527 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29528 PyObject *resultobj = 0;
29529 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29530 wxColour *result = 0 ;
29531 void *argp1 = 0 ;
29532 int res1 = 0 ;
29533 PyObject *swig_obj[1] ;
29534
29535 if (!args) SWIG_fail;
29536 swig_obj[0] = args;
29537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29538 if (!SWIG_IsOK(res1)) {
29539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29540 }
29541 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29542 result = (wxColour *)& ((arg1)->colFg);
29543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29544 return resultobj;
29545 fail:
29546 return NULL;
29547 }
29548
29549
29550 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29551 PyObject *resultobj = 0;
29552 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29553 wxColour *arg2 = (wxColour *) 0 ;
29554 void *argp1 = 0 ;
29555 int res1 = 0 ;
29556 void *argp2 = 0 ;
29557 int res2 = 0 ;
29558 PyObject *swig_obj[2] ;
29559
29560 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29562 if (!SWIG_IsOK(res1)) {
29563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29564 }
29565 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29566 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29567 if (!SWIG_IsOK(res2)) {
29568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29569 }
29570 arg2 = reinterpret_cast< wxColour * >(argp2);
29571 if (arg1) (arg1)->colBg = *arg2;
29572
29573 resultobj = SWIG_Py_Void();
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29581 PyObject *resultobj = 0;
29582 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29583 wxColour *result = 0 ;
29584 void *argp1 = 0 ;
29585 int res1 = 0 ;
29586 PyObject *swig_obj[1] ;
29587
29588 if (!args) SWIG_fail;
29589 swig_obj[0] = args;
29590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29591 if (!SWIG_IsOK(res1)) {
29592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29593 }
29594 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29595 result = (wxColour *)& ((arg1)->colBg);
29596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29597 return resultobj;
29598 fail:
29599 return NULL;
29600 }
29601
29602
29603 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29604 PyObject *obj;
29605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29606 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29607 return SWIG_Py_Void();
29608 }
29609
29610 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29611 return SWIG_Python_InitShadowInstance(args);
29612 }
29613
29614 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29615 PyObject *resultobj = 0;
29616 wxWindow *arg1 = (wxWindow *) 0 ;
29617 int arg2 = (int) (int)-1 ;
29618 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29619 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29620 wxSize const &arg4_defvalue = wxDefaultSize ;
29621 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29622 long arg5 = (long) 0 ;
29623 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29624 wxString *arg6 = (wxString *) &arg6_defvalue ;
29625 wxWindow *result = 0 ;
29626 void *argp1 = 0 ;
29627 int res1 = 0 ;
29628 int val2 ;
29629 int ecode2 = 0 ;
29630 wxPoint temp3 ;
29631 wxSize temp4 ;
29632 long val5 ;
29633 int ecode5 = 0 ;
29634 bool temp6 = false ;
29635 PyObject * obj0 = 0 ;
29636 PyObject * obj1 = 0 ;
29637 PyObject * obj2 = 0 ;
29638 PyObject * obj3 = 0 ;
29639 PyObject * obj4 = 0 ;
29640 PyObject * obj5 = 0 ;
29641 char * kwnames[] = {
29642 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29643 };
29644
29645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29647 if (!SWIG_IsOK(res1)) {
29648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29649 }
29650 arg1 = reinterpret_cast< wxWindow * >(argp1);
29651 if (obj1) {
29652 ecode2 = SWIG_AsVal_int(obj1, &val2);
29653 if (!SWIG_IsOK(ecode2)) {
29654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29655 }
29656 arg2 = static_cast< int >(val2);
29657 }
29658 if (obj2) {
29659 {
29660 arg3 = &temp3;
29661 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29662 }
29663 }
29664 if (obj3) {
29665 {
29666 arg4 = &temp4;
29667 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29668 }
29669 }
29670 if (obj4) {
29671 ecode5 = SWIG_AsVal_long(obj4, &val5);
29672 if (!SWIG_IsOK(ecode5)) {
29673 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29674 }
29675 arg5 = static_cast< long >(val5);
29676 }
29677 if (obj5) {
29678 {
29679 arg6 = wxString_in_helper(obj5);
29680 if (arg6 == NULL) SWIG_fail;
29681 temp6 = true;
29682 }
29683 }
29684 {
29685 if (!wxPyCheckForApp()) SWIG_fail;
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29692 {
29693 if (temp6)
29694 delete arg6;
29695 }
29696 return resultobj;
29697 fail:
29698 {
29699 if (temp6)
29700 delete arg6;
29701 }
29702 return NULL;
29703 }
29704
29705
29706 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29707 PyObject *resultobj = 0;
29708 wxWindow *result = 0 ;
29709
29710 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29711 {
29712 if (!wxPyCheckForApp()) SWIG_fail;
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = (wxWindow *)new wxWindow();
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29719 return resultobj;
29720 fail:
29721 return NULL;
29722 }
29723
29724
29725 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29726 PyObject *resultobj = 0;
29727 wxWindow *arg1 = (wxWindow *) 0 ;
29728 wxWindow *arg2 = (wxWindow *) 0 ;
29729 int arg3 = (int) (int)-1 ;
29730 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29731 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29732 wxSize const &arg5_defvalue = wxDefaultSize ;
29733 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29734 long arg6 = (long) 0 ;
29735 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29736 wxString *arg7 = (wxString *) &arg7_defvalue ;
29737 bool result;
29738 void *argp1 = 0 ;
29739 int res1 = 0 ;
29740 void *argp2 = 0 ;
29741 int res2 = 0 ;
29742 int val3 ;
29743 int ecode3 = 0 ;
29744 wxPoint temp4 ;
29745 wxSize temp5 ;
29746 long val6 ;
29747 int ecode6 = 0 ;
29748 bool temp7 = false ;
29749 PyObject * obj0 = 0 ;
29750 PyObject * obj1 = 0 ;
29751 PyObject * obj2 = 0 ;
29752 PyObject * obj3 = 0 ;
29753 PyObject * obj4 = 0 ;
29754 PyObject * obj5 = 0 ;
29755 PyObject * obj6 = 0 ;
29756 char * kwnames[] = {
29757 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29758 };
29759
29760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29762 if (!SWIG_IsOK(res1)) {
29763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29764 }
29765 arg1 = reinterpret_cast< wxWindow * >(argp1);
29766 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29767 if (!SWIG_IsOK(res2)) {
29768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29769 }
29770 arg2 = reinterpret_cast< wxWindow * >(argp2);
29771 if (obj2) {
29772 ecode3 = SWIG_AsVal_int(obj2, &val3);
29773 if (!SWIG_IsOK(ecode3)) {
29774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29775 }
29776 arg3 = static_cast< int >(val3);
29777 }
29778 if (obj3) {
29779 {
29780 arg4 = &temp4;
29781 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29782 }
29783 }
29784 if (obj4) {
29785 {
29786 arg5 = &temp5;
29787 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29788 }
29789 }
29790 if (obj5) {
29791 ecode6 = SWIG_AsVal_long(obj5, &val6);
29792 if (!SWIG_IsOK(ecode6)) {
29793 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29794 }
29795 arg6 = static_cast< long >(val6);
29796 }
29797 if (obj6) {
29798 {
29799 arg7 = wxString_in_helper(obj6);
29800 if (arg7 == NULL) SWIG_fail;
29801 temp7 = true;
29802 }
29803 }
29804 {
29805 PyThreadState* __tstate = wxPyBeginAllowThreads();
29806 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29807 wxPyEndAllowThreads(__tstate);
29808 if (PyErr_Occurred()) SWIG_fail;
29809 }
29810 {
29811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29812 }
29813 {
29814 if (temp7)
29815 delete arg7;
29816 }
29817 return resultobj;
29818 fail:
29819 {
29820 if (temp7)
29821 delete arg7;
29822 }
29823 return NULL;
29824 }
29825
29826
29827 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29828 PyObject *resultobj = 0;
29829 wxWindow *arg1 = (wxWindow *) 0 ;
29830 bool arg2 = (bool) false ;
29831 bool result;
29832 void *argp1 = 0 ;
29833 int res1 = 0 ;
29834 bool val2 ;
29835 int ecode2 = 0 ;
29836 PyObject * obj0 = 0 ;
29837 PyObject * obj1 = 0 ;
29838 char * kwnames[] = {
29839 (char *) "self",(char *) "force", NULL
29840 };
29841
29842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29844 if (!SWIG_IsOK(res1)) {
29845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29846 }
29847 arg1 = reinterpret_cast< wxWindow * >(argp1);
29848 if (obj1) {
29849 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29850 if (!SWIG_IsOK(ecode2)) {
29851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29852 }
29853 arg2 = static_cast< bool >(val2);
29854 }
29855 {
29856 PyThreadState* __tstate = wxPyBeginAllowThreads();
29857 result = (bool)(arg1)->Close(arg2);
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 {
29862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29863 }
29864 return resultobj;
29865 fail:
29866 return NULL;
29867 }
29868
29869
29870 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29871 PyObject *resultobj = 0;
29872 wxWindow *arg1 = (wxWindow *) 0 ;
29873 bool result;
29874 void *argp1 = 0 ;
29875 int res1 = 0 ;
29876 PyObject *swig_obj[1] ;
29877
29878 if (!args) SWIG_fail;
29879 swig_obj[0] = args;
29880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29881 if (!SWIG_IsOK(res1)) {
29882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29883 }
29884 arg1 = reinterpret_cast< wxWindow * >(argp1);
29885 {
29886 PyThreadState* __tstate = wxPyBeginAllowThreads();
29887 result = (bool)(arg1)->Destroy();
29888 wxPyEndAllowThreads(__tstate);
29889 if (PyErr_Occurred()) SWIG_fail;
29890 }
29891 {
29892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29893 }
29894 return resultobj;
29895 fail:
29896 return NULL;
29897 }
29898
29899
29900 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29901 PyObject *resultobj = 0;
29902 wxWindow *arg1 = (wxWindow *) 0 ;
29903 bool result;
29904 void *argp1 = 0 ;
29905 int res1 = 0 ;
29906 PyObject *swig_obj[1] ;
29907
29908 if (!args) SWIG_fail;
29909 swig_obj[0] = args;
29910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29911 if (!SWIG_IsOK(res1)) {
29912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29913 }
29914 arg1 = reinterpret_cast< wxWindow * >(argp1);
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 result = (bool)(arg1)->DestroyChildren();
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 {
29922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29923 }
29924 return resultobj;
29925 fail:
29926 return NULL;
29927 }
29928
29929
29930 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29931 PyObject *resultobj = 0;
29932 wxWindow *arg1 = (wxWindow *) 0 ;
29933 bool result;
29934 void *argp1 = 0 ;
29935 int res1 = 0 ;
29936 PyObject *swig_obj[1] ;
29937
29938 if (!args) SWIG_fail;
29939 swig_obj[0] = args;
29940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29941 if (!SWIG_IsOK(res1)) {
29942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29943 }
29944 arg1 = reinterpret_cast< wxWindow * >(argp1);
29945 {
29946 PyThreadState* __tstate = wxPyBeginAllowThreads();
29947 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29948 wxPyEndAllowThreads(__tstate);
29949 if (PyErr_Occurred()) SWIG_fail;
29950 }
29951 {
29952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29953 }
29954 return resultobj;
29955 fail:
29956 return NULL;
29957 }
29958
29959
29960 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29961 PyObject *resultobj = 0;
29962 wxWindow *arg1 = (wxWindow *) 0 ;
29963 wxString *arg2 = 0 ;
29964 void *argp1 = 0 ;
29965 int res1 = 0 ;
29966 bool temp2 = false ;
29967 PyObject * obj0 = 0 ;
29968 PyObject * obj1 = 0 ;
29969 char * kwnames[] = {
29970 (char *) "self",(char *) "label", NULL
29971 };
29972
29973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29975 if (!SWIG_IsOK(res1)) {
29976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29977 }
29978 arg1 = reinterpret_cast< wxWindow * >(argp1);
29979 {
29980 arg2 = wxString_in_helper(obj1);
29981 if (arg2 == NULL) SWIG_fail;
29982 temp2 = true;
29983 }
29984 {
29985 PyThreadState* __tstate = wxPyBeginAllowThreads();
29986 (arg1)->SetLabel((wxString const &)*arg2);
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 resultobj = SWIG_Py_Void();
29991 {
29992 if (temp2)
29993 delete arg2;
29994 }
29995 return resultobj;
29996 fail:
29997 {
29998 if (temp2)
29999 delete arg2;
30000 }
30001 return NULL;
30002 }
30003
30004
30005 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30006 PyObject *resultobj = 0;
30007 wxWindow *arg1 = (wxWindow *) 0 ;
30008 wxString result;
30009 void *argp1 = 0 ;
30010 int res1 = 0 ;
30011 PyObject *swig_obj[1] ;
30012
30013 if (!args) SWIG_fail;
30014 swig_obj[0] = args;
30015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30016 if (!SWIG_IsOK(res1)) {
30017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30018 }
30019 arg1 = reinterpret_cast< wxWindow * >(argp1);
30020 {
30021 PyThreadState* __tstate = wxPyBeginAllowThreads();
30022 result = ((wxWindow const *)arg1)->GetLabel();
30023 wxPyEndAllowThreads(__tstate);
30024 if (PyErr_Occurred()) SWIG_fail;
30025 }
30026 {
30027 #if wxUSE_UNICODE
30028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30029 #else
30030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30031 #endif
30032 }
30033 return resultobj;
30034 fail:
30035 return NULL;
30036 }
30037
30038
30039 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30040 PyObject *resultobj = 0;
30041 wxWindow *arg1 = (wxWindow *) 0 ;
30042 wxString *arg2 = 0 ;
30043 void *argp1 = 0 ;
30044 int res1 = 0 ;
30045 bool temp2 = false ;
30046 PyObject * obj0 = 0 ;
30047 PyObject * obj1 = 0 ;
30048 char * kwnames[] = {
30049 (char *) "self",(char *) "name", NULL
30050 };
30051
30052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30054 if (!SWIG_IsOK(res1)) {
30055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30056 }
30057 arg1 = reinterpret_cast< wxWindow * >(argp1);
30058 {
30059 arg2 = wxString_in_helper(obj1);
30060 if (arg2 == NULL) SWIG_fail;
30061 temp2 = true;
30062 }
30063 {
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 (arg1)->SetName((wxString const &)*arg2);
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 resultobj = SWIG_Py_Void();
30070 {
30071 if (temp2)
30072 delete arg2;
30073 }
30074 return resultobj;
30075 fail:
30076 {
30077 if (temp2)
30078 delete arg2;
30079 }
30080 return NULL;
30081 }
30082
30083
30084 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30085 PyObject *resultobj = 0;
30086 wxWindow *arg1 = (wxWindow *) 0 ;
30087 wxString result;
30088 void *argp1 = 0 ;
30089 int res1 = 0 ;
30090 PyObject *swig_obj[1] ;
30091
30092 if (!args) SWIG_fail;
30093 swig_obj[0] = args;
30094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30095 if (!SWIG_IsOK(res1)) {
30096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30097 }
30098 arg1 = reinterpret_cast< wxWindow * >(argp1);
30099 {
30100 PyThreadState* __tstate = wxPyBeginAllowThreads();
30101 result = ((wxWindow const *)arg1)->GetName();
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 {
30106 #if wxUSE_UNICODE
30107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30108 #else
30109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30110 #endif
30111 }
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30119 PyObject *resultobj = 0;
30120 wxWindow *arg1 = (wxWindow *) 0 ;
30121 wxWindowVariant arg2 ;
30122 void *argp1 = 0 ;
30123 int res1 = 0 ;
30124 int val2 ;
30125 int ecode2 = 0 ;
30126 PyObject * obj0 = 0 ;
30127 PyObject * obj1 = 0 ;
30128 char * kwnames[] = {
30129 (char *) "self",(char *) "variant", NULL
30130 };
30131
30132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30134 if (!SWIG_IsOK(res1)) {
30135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30136 }
30137 arg1 = reinterpret_cast< wxWindow * >(argp1);
30138 ecode2 = SWIG_AsVal_int(obj1, &val2);
30139 if (!SWIG_IsOK(ecode2)) {
30140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30141 }
30142 arg2 = static_cast< wxWindowVariant >(val2);
30143 {
30144 PyThreadState* __tstate = wxPyBeginAllowThreads();
30145 (arg1)->SetWindowVariant(arg2);
30146 wxPyEndAllowThreads(__tstate);
30147 if (PyErr_Occurred()) SWIG_fail;
30148 }
30149 resultobj = SWIG_Py_Void();
30150 return resultobj;
30151 fail:
30152 return NULL;
30153 }
30154
30155
30156 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30157 PyObject *resultobj = 0;
30158 wxWindow *arg1 = (wxWindow *) 0 ;
30159 wxWindowVariant result;
30160 void *argp1 = 0 ;
30161 int res1 = 0 ;
30162 PyObject *swig_obj[1] ;
30163
30164 if (!args) SWIG_fail;
30165 swig_obj[0] = args;
30166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30167 if (!SWIG_IsOK(res1)) {
30168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30169 }
30170 arg1 = reinterpret_cast< wxWindow * >(argp1);
30171 {
30172 PyThreadState* __tstate = wxPyBeginAllowThreads();
30173 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 resultobj = SWIG_From_int(static_cast< int >(result));
30178 return resultobj;
30179 fail:
30180 return NULL;
30181 }
30182
30183
30184 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30185 PyObject *resultobj = 0;
30186 wxWindow *arg1 = (wxWindow *) 0 ;
30187 int arg2 ;
30188 void *argp1 = 0 ;
30189 int res1 = 0 ;
30190 int val2 ;
30191 int ecode2 = 0 ;
30192 PyObject * obj0 = 0 ;
30193 PyObject * obj1 = 0 ;
30194 char * kwnames[] = {
30195 (char *) "self",(char *) "winid", NULL
30196 };
30197
30198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30200 if (!SWIG_IsOK(res1)) {
30201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30202 }
30203 arg1 = reinterpret_cast< wxWindow * >(argp1);
30204 ecode2 = SWIG_AsVal_int(obj1, &val2);
30205 if (!SWIG_IsOK(ecode2)) {
30206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30207 }
30208 arg2 = static_cast< int >(val2);
30209 {
30210 PyThreadState* __tstate = wxPyBeginAllowThreads();
30211 (arg1)->SetId(arg2);
30212 wxPyEndAllowThreads(__tstate);
30213 if (PyErr_Occurred()) SWIG_fail;
30214 }
30215 resultobj = SWIG_Py_Void();
30216 return resultobj;
30217 fail:
30218 return NULL;
30219 }
30220
30221
30222 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30223 PyObject *resultobj = 0;
30224 wxWindow *arg1 = (wxWindow *) 0 ;
30225 int result;
30226 void *argp1 = 0 ;
30227 int res1 = 0 ;
30228 PyObject *swig_obj[1] ;
30229
30230 if (!args) SWIG_fail;
30231 swig_obj[0] = args;
30232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30233 if (!SWIG_IsOK(res1)) {
30234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30235 }
30236 arg1 = reinterpret_cast< wxWindow * >(argp1);
30237 {
30238 PyThreadState* __tstate = wxPyBeginAllowThreads();
30239 result = (int)((wxWindow const *)arg1)->GetId();
30240 wxPyEndAllowThreads(__tstate);
30241 if (PyErr_Occurred()) SWIG_fail;
30242 }
30243 resultobj = SWIG_From_int(static_cast< int >(result));
30244 return resultobj;
30245 fail:
30246 return NULL;
30247 }
30248
30249
30250 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30251 PyObject *resultobj = 0;
30252 int result;
30253
30254 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 result = (int)wxWindow::NewControlId();
30258 wxPyEndAllowThreads(__tstate);
30259 if (PyErr_Occurred()) SWIG_fail;
30260 }
30261 resultobj = SWIG_From_int(static_cast< int >(result));
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 int arg1 ;
30271 int result;
30272 int val1 ;
30273 int ecode1 = 0 ;
30274 PyObject * obj0 = 0 ;
30275 char * kwnames[] = {
30276 (char *) "winid", NULL
30277 };
30278
30279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30280 ecode1 = SWIG_AsVal_int(obj0, &val1);
30281 if (!SWIG_IsOK(ecode1)) {
30282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30283 }
30284 arg1 = static_cast< int >(val1);
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 result = (int)wxWindow::NextControlId(arg1);
30288 wxPyEndAllowThreads(__tstate);
30289 if (PyErr_Occurred()) SWIG_fail;
30290 }
30291 resultobj = SWIG_From_int(static_cast< int >(result));
30292 return resultobj;
30293 fail:
30294 return NULL;
30295 }
30296
30297
30298 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30299 PyObject *resultobj = 0;
30300 int arg1 ;
30301 int result;
30302 int val1 ;
30303 int ecode1 = 0 ;
30304 PyObject * obj0 = 0 ;
30305 char * kwnames[] = {
30306 (char *) "winid", NULL
30307 };
30308
30309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30310 ecode1 = SWIG_AsVal_int(obj0, &val1);
30311 if (!SWIG_IsOK(ecode1)) {
30312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30313 }
30314 arg1 = static_cast< int >(val1);
30315 {
30316 PyThreadState* __tstate = wxPyBeginAllowThreads();
30317 result = (int)wxWindow::PrevControlId(arg1);
30318 wxPyEndAllowThreads(__tstate);
30319 if (PyErr_Occurred()) SWIG_fail;
30320 }
30321 resultobj = SWIG_From_int(static_cast< int >(result));
30322 return resultobj;
30323 fail:
30324 return NULL;
30325 }
30326
30327
30328 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30329 PyObject *resultobj = 0;
30330 wxWindow *arg1 = (wxWindow *) 0 ;
30331 wxSize *arg2 = 0 ;
30332 void *argp1 = 0 ;
30333 int res1 = 0 ;
30334 wxSize temp2 ;
30335 PyObject * obj0 = 0 ;
30336 PyObject * obj1 = 0 ;
30337 char * kwnames[] = {
30338 (char *) "self",(char *) "size", NULL
30339 };
30340
30341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30343 if (!SWIG_IsOK(res1)) {
30344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30345 }
30346 arg1 = reinterpret_cast< wxWindow * >(argp1);
30347 {
30348 arg2 = &temp2;
30349 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30350 }
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 (arg1)->SetSize((wxSize const &)*arg2);
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_Py_Void();
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30365 PyObject *resultobj = 0;
30366 wxWindow *arg1 = (wxWindow *) 0 ;
30367 int arg2 ;
30368 int arg3 ;
30369 int arg4 ;
30370 int arg5 ;
30371 int arg6 = (int) wxSIZE_AUTO ;
30372 void *argp1 = 0 ;
30373 int res1 = 0 ;
30374 int val2 ;
30375 int ecode2 = 0 ;
30376 int val3 ;
30377 int ecode3 = 0 ;
30378 int val4 ;
30379 int ecode4 = 0 ;
30380 int val5 ;
30381 int ecode5 = 0 ;
30382 int val6 ;
30383 int ecode6 = 0 ;
30384 PyObject * obj0 = 0 ;
30385 PyObject * obj1 = 0 ;
30386 PyObject * obj2 = 0 ;
30387 PyObject * obj3 = 0 ;
30388 PyObject * obj4 = 0 ;
30389 PyObject * obj5 = 0 ;
30390 char * kwnames[] = {
30391 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30392 };
30393
30394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30396 if (!SWIG_IsOK(res1)) {
30397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30398 }
30399 arg1 = reinterpret_cast< wxWindow * >(argp1);
30400 ecode2 = SWIG_AsVal_int(obj1, &val2);
30401 if (!SWIG_IsOK(ecode2)) {
30402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30403 }
30404 arg2 = static_cast< int >(val2);
30405 ecode3 = SWIG_AsVal_int(obj2, &val3);
30406 if (!SWIG_IsOK(ecode3)) {
30407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30408 }
30409 arg3 = static_cast< int >(val3);
30410 ecode4 = SWIG_AsVal_int(obj3, &val4);
30411 if (!SWIG_IsOK(ecode4)) {
30412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30413 }
30414 arg4 = static_cast< int >(val4);
30415 ecode5 = SWIG_AsVal_int(obj4, &val5);
30416 if (!SWIG_IsOK(ecode5)) {
30417 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30418 }
30419 arg5 = static_cast< int >(val5);
30420 if (obj5) {
30421 ecode6 = SWIG_AsVal_int(obj5, &val6);
30422 if (!SWIG_IsOK(ecode6)) {
30423 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30424 }
30425 arg6 = static_cast< int >(val6);
30426 }
30427 {
30428 PyThreadState* __tstate = wxPyBeginAllowThreads();
30429 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 resultobj = SWIG_Py_Void();
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj = 0;
30442 wxWindow *arg1 = (wxWindow *) 0 ;
30443 wxRect *arg2 = 0 ;
30444 int arg3 = (int) wxSIZE_AUTO ;
30445 void *argp1 = 0 ;
30446 int res1 = 0 ;
30447 wxRect temp2 ;
30448 int val3 ;
30449 int ecode3 = 0 ;
30450 PyObject * obj0 = 0 ;
30451 PyObject * obj1 = 0 ;
30452 PyObject * obj2 = 0 ;
30453 char * kwnames[] = {
30454 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30455 };
30456
30457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30459 if (!SWIG_IsOK(res1)) {
30460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30461 }
30462 arg1 = reinterpret_cast< wxWindow * >(argp1);
30463 {
30464 arg2 = &temp2;
30465 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30466 }
30467 if (obj2) {
30468 ecode3 = SWIG_AsVal_int(obj2, &val3);
30469 if (!SWIG_IsOK(ecode3)) {
30470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30471 }
30472 arg3 = static_cast< int >(val3);
30473 }
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30477 wxPyEndAllowThreads(__tstate);
30478 if (PyErr_Occurred()) SWIG_fail;
30479 }
30480 resultobj = SWIG_Py_Void();
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj = 0;
30489 wxWindow *arg1 = (wxWindow *) 0 ;
30490 int arg2 ;
30491 int arg3 ;
30492 void *argp1 = 0 ;
30493 int res1 = 0 ;
30494 int val2 ;
30495 int ecode2 = 0 ;
30496 int val3 ;
30497 int ecode3 = 0 ;
30498 PyObject * obj0 = 0 ;
30499 PyObject * obj1 = 0 ;
30500 PyObject * obj2 = 0 ;
30501 char * kwnames[] = {
30502 (char *) "self",(char *) "width",(char *) "height", NULL
30503 };
30504
30505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30507 if (!SWIG_IsOK(res1)) {
30508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30509 }
30510 arg1 = reinterpret_cast< wxWindow * >(argp1);
30511 ecode2 = SWIG_AsVal_int(obj1, &val2);
30512 if (!SWIG_IsOK(ecode2)) {
30513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30514 }
30515 arg2 = static_cast< int >(val2);
30516 ecode3 = SWIG_AsVal_int(obj2, &val3);
30517 if (!SWIG_IsOK(ecode3)) {
30518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30519 }
30520 arg3 = static_cast< int >(val3);
30521 {
30522 PyThreadState* __tstate = wxPyBeginAllowThreads();
30523 (arg1)->SetSize(arg2,arg3);
30524 wxPyEndAllowThreads(__tstate);
30525 if (PyErr_Occurred()) SWIG_fail;
30526 }
30527 resultobj = SWIG_Py_Void();
30528 return resultobj;
30529 fail:
30530 return NULL;
30531 }
30532
30533
30534 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30535 PyObject *resultobj = 0;
30536 wxWindow *arg1 = (wxWindow *) 0 ;
30537 wxPoint *arg2 = 0 ;
30538 int arg3 = (int) wxSIZE_USE_EXISTING ;
30539 void *argp1 = 0 ;
30540 int res1 = 0 ;
30541 wxPoint temp2 ;
30542 int val3 ;
30543 int ecode3 = 0 ;
30544 PyObject * obj0 = 0 ;
30545 PyObject * obj1 = 0 ;
30546 PyObject * obj2 = 0 ;
30547 char * kwnames[] = {
30548 (char *) "self",(char *) "pt",(char *) "flags", NULL
30549 };
30550
30551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30553 if (!SWIG_IsOK(res1)) {
30554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30555 }
30556 arg1 = reinterpret_cast< wxWindow * >(argp1);
30557 {
30558 arg2 = &temp2;
30559 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30560 }
30561 if (obj2) {
30562 ecode3 = SWIG_AsVal_int(obj2, &val3);
30563 if (!SWIG_IsOK(ecode3)) {
30564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30565 }
30566 arg3 = static_cast< int >(val3);
30567 }
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 (arg1)->Move((wxPoint const &)*arg2,arg3);
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 resultobj = SWIG_Py_Void();
30575 return resultobj;
30576 fail:
30577 return NULL;
30578 }
30579
30580
30581 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30582 PyObject *resultobj = 0;
30583 wxWindow *arg1 = (wxWindow *) 0 ;
30584 int arg2 ;
30585 int arg3 ;
30586 int arg4 = (int) wxSIZE_USE_EXISTING ;
30587 void *argp1 = 0 ;
30588 int res1 = 0 ;
30589 int val2 ;
30590 int ecode2 = 0 ;
30591 int val3 ;
30592 int ecode3 = 0 ;
30593 int val4 ;
30594 int ecode4 = 0 ;
30595 PyObject * obj0 = 0 ;
30596 PyObject * obj1 = 0 ;
30597 PyObject * obj2 = 0 ;
30598 PyObject * obj3 = 0 ;
30599 char * kwnames[] = {
30600 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30601 };
30602
30603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30605 if (!SWIG_IsOK(res1)) {
30606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30607 }
30608 arg1 = reinterpret_cast< wxWindow * >(argp1);
30609 ecode2 = SWIG_AsVal_int(obj1, &val2);
30610 if (!SWIG_IsOK(ecode2)) {
30611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30612 }
30613 arg2 = static_cast< int >(val2);
30614 ecode3 = SWIG_AsVal_int(obj2, &val3);
30615 if (!SWIG_IsOK(ecode3)) {
30616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30617 }
30618 arg3 = static_cast< int >(val3);
30619 if (obj3) {
30620 ecode4 = SWIG_AsVal_int(obj3, &val4);
30621 if (!SWIG_IsOK(ecode4)) {
30622 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30623 }
30624 arg4 = static_cast< int >(val4);
30625 }
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 (arg1)->Move(arg2,arg3,arg4);
30629 wxPyEndAllowThreads(__tstate);
30630 if (PyErr_Occurred()) SWIG_fail;
30631 }
30632 resultobj = SWIG_Py_Void();
30633 return resultobj;
30634 fail:
30635 return NULL;
30636 }
30637
30638
30639 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30640 PyObject *resultobj = 0;
30641 wxWindow *arg1 = (wxWindow *) 0 ;
30642 wxSize const &arg2_defvalue = wxDefaultSize ;
30643 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30644 void *argp1 = 0 ;
30645 int res1 = 0 ;
30646 wxSize temp2 ;
30647 PyObject * obj0 = 0 ;
30648 PyObject * obj1 = 0 ;
30649 char * kwnames[] = {
30650 (char *) "self",(char *) "size", NULL
30651 };
30652
30653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30655 if (!SWIG_IsOK(res1)) {
30656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30657 }
30658 arg1 = reinterpret_cast< wxWindow * >(argp1);
30659 if (obj1) {
30660 {
30661 arg2 = &temp2;
30662 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30663 }
30664 }
30665 {
30666 PyThreadState* __tstate = wxPyBeginAllowThreads();
30667 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30668 wxPyEndAllowThreads(__tstate);
30669 if (PyErr_Occurred()) SWIG_fail;
30670 }
30671 resultobj = SWIG_Py_Void();
30672 return resultobj;
30673 fail:
30674 return NULL;
30675 }
30676
30677
30678 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30679 PyObject *resultobj = 0;
30680 wxWindow *arg1 = (wxWindow *) 0 ;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 PyObject *swig_obj[1] ;
30684
30685 if (!args) SWIG_fail;
30686 swig_obj[0] = args;
30687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30688 if (!SWIG_IsOK(res1)) {
30689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30690 }
30691 arg1 = reinterpret_cast< wxWindow * >(argp1);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 (arg1)->Raise();
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_Py_Void();
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30706 PyObject *resultobj = 0;
30707 wxWindow *arg1 = (wxWindow *) 0 ;
30708 void *argp1 = 0 ;
30709 int res1 = 0 ;
30710 PyObject *swig_obj[1] ;
30711
30712 if (!args) SWIG_fail;
30713 swig_obj[0] = args;
30714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30715 if (!SWIG_IsOK(res1)) {
30716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30717 }
30718 arg1 = reinterpret_cast< wxWindow * >(argp1);
30719 {
30720 PyThreadState* __tstate = wxPyBeginAllowThreads();
30721 (arg1)->Lower();
30722 wxPyEndAllowThreads(__tstate);
30723 if (PyErr_Occurred()) SWIG_fail;
30724 }
30725 resultobj = SWIG_Py_Void();
30726 return resultobj;
30727 fail:
30728 return NULL;
30729 }
30730
30731
30732 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30733 PyObject *resultobj = 0;
30734 wxWindow *arg1 = (wxWindow *) 0 ;
30735 wxSize *arg2 = 0 ;
30736 void *argp1 = 0 ;
30737 int res1 = 0 ;
30738 wxSize temp2 ;
30739 PyObject * obj0 = 0 ;
30740 PyObject * obj1 = 0 ;
30741 char * kwnames[] = {
30742 (char *) "self",(char *) "size", NULL
30743 };
30744
30745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30747 if (!SWIG_IsOK(res1)) {
30748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30749 }
30750 arg1 = reinterpret_cast< wxWindow * >(argp1);
30751 {
30752 arg2 = &temp2;
30753 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30754 }
30755 {
30756 PyThreadState* __tstate = wxPyBeginAllowThreads();
30757 (arg1)->SetClientSize((wxSize const &)*arg2);
30758 wxPyEndAllowThreads(__tstate);
30759 if (PyErr_Occurred()) SWIG_fail;
30760 }
30761 resultobj = SWIG_Py_Void();
30762 return resultobj;
30763 fail:
30764 return NULL;
30765 }
30766
30767
30768 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30769 PyObject *resultobj = 0;
30770 wxWindow *arg1 = (wxWindow *) 0 ;
30771 int arg2 ;
30772 int arg3 ;
30773 void *argp1 = 0 ;
30774 int res1 = 0 ;
30775 int val2 ;
30776 int ecode2 = 0 ;
30777 int val3 ;
30778 int ecode3 = 0 ;
30779 PyObject * obj0 = 0 ;
30780 PyObject * obj1 = 0 ;
30781 PyObject * obj2 = 0 ;
30782 char * kwnames[] = {
30783 (char *) "self",(char *) "width",(char *) "height", NULL
30784 };
30785
30786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30788 if (!SWIG_IsOK(res1)) {
30789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30790 }
30791 arg1 = reinterpret_cast< wxWindow * >(argp1);
30792 ecode2 = SWIG_AsVal_int(obj1, &val2);
30793 if (!SWIG_IsOK(ecode2)) {
30794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30795 }
30796 arg2 = static_cast< int >(val2);
30797 ecode3 = SWIG_AsVal_int(obj2, &val3);
30798 if (!SWIG_IsOK(ecode3)) {
30799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30800 }
30801 arg3 = static_cast< int >(val3);
30802 {
30803 PyThreadState* __tstate = wxPyBeginAllowThreads();
30804 (arg1)->SetClientSize(arg2,arg3);
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 resultobj = SWIG_Py_Void();
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj = 0;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 wxRect *arg2 = 0 ;
30819 void *argp1 = 0 ;
30820 int res1 = 0 ;
30821 wxRect temp2 ;
30822 PyObject * obj0 = 0 ;
30823 PyObject * obj1 = 0 ;
30824 char * kwnames[] = {
30825 (char *) "self",(char *) "rect", NULL
30826 };
30827
30828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30830 if (!SWIG_IsOK(res1)) {
30831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30832 }
30833 arg1 = reinterpret_cast< wxWindow * >(argp1);
30834 {
30835 arg2 = &temp2;
30836 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30837 }
30838 {
30839 PyThreadState* __tstate = wxPyBeginAllowThreads();
30840 (arg1)->SetClientSize((wxRect const &)*arg2);
30841 wxPyEndAllowThreads(__tstate);
30842 if (PyErr_Occurred()) SWIG_fail;
30843 }
30844 resultobj = SWIG_Py_Void();
30845 return resultobj;
30846 fail:
30847 return NULL;
30848 }
30849
30850
30851 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30852 PyObject *resultobj = 0;
30853 wxWindow *arg1 = (wxWindow *) 0 ;
30854 wxPoint result;
30855 void *argp1 = 0 ;
30856 int res1 = 0 ;
30857 PyObject *swig_obj[1] ;
30858
30859 if (!args) SWIG_fail;
30860 swig_obj[0] = args;
30861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30862 if (!SWIG_IsOK(res1)) {
30863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30864 }
30865 arg1 = reinterpret_cast< wxWindow * >(argp1);
30866 {
30867 PyThreadState* __tstate = wxPyBeginAllowThreads();
30868 result = ((wxWindow const *)arg1)->GetPosition();
30869 wxPyEndAllowThreads(__tstate);
30870 if (PyErr_Occurred()) SWIG_fail;
30871 }
30872 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30873 return resultobj;
30874 fail:
30875 return NULL;
30876 }
30877
30878
30879 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30880 PyObject *resultobj = 0;
30881 wxWindow *arg1 = (wxWindow *) 0 ;
30882 int *arg2 = (int *) 0 ;
30883 int *arg3 = (int *) 0 ;
30884 void *argp1 = 0 ;
30885 int res1 = 0 ;
30886 int temp2 ;
30887 int res2 = SWIG_TMPOBJ ;
30888 int temp3 ;
30889 int res3 = SWIG_TMPOBJ ;
30890 PyObject *swig_obj[1] ;
30891
30892 arg2 = &temp2;
30893 arg3 = &temp3;
30894 if (!args) SWIG_fail;
30895 swig_obj[0] = args;
30896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30897 if (!SWIG_IsOK(res1)) {
30898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30899 }
30900 arg1 = reinterpret_cast< wxWindow * >(argp1);
30901 {
30902 PyThreadState* __tstate = wxPyBeginAllowThreads();
30903 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30904 wxPyEndAllowThreads(__tstate);
30905 if (PyErr_Occurred()) SWIG_fail;
30906 }
30907 resultobj = SWIG_Py_Void();
30908 if (SWIG_IsTmpObj(res2)) {
30909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30910 } else {
30911 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30913 }
30914 if (SWIG_IsTmpObj(res3)) {
30915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30916 } else {
30917 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30919 }
30920 return resultobj;
30921 fail:
30922 return NULL;
30923 }
30924
30925
30926 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30927 PyObject *resultobj = 0;
30928 wxWindow *arg1 = (wxWindow *) 0 ;
30929 wxPoint result;
30930 void *argp1 = 0 ;
30931 int res1 = 0 ;
30932 PyObject *swig_obj[1] ;
30933
30934 if (!args) SWIG_fail;
30935 swig_obj[0] = args;
30936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30937 if (!SWIG_IsOK(res1)) {
30938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30939 }
30940 arg1 = reinterpret_cast< wxWindow * >(argp1);
30941 {
30942 PyThreadState* __tstate = wxPyBeginAllowThreads();
30943 result = ((wxWindow const *)arg1)->GetScreenPosition();
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30948 return resultobj;
30949 fail:
30950 return NULL;
30951 }
30952
30953
30954 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30955 PyObject *resultobj = 0;
30956 wxWindow *arg1 = (wxWindow *) 0 ;
30957 int *arg2 = (int *) 0 ;
30958 int *arg3 = (int *) 0 ;
30959 void *argp1 = 0 ;
30960 int res1 = 0 ;
30961 int temp2 ;
30962 int res2 = SWIG_TMPOBJ ;
30963 int temp3 ;
30964 int res3 = SWIG_TMPOBJ ;
30965 PyObject *swig_obj[1] ;
30966
30967 arg2 = &temp2;
30968 arg3 = &temp3;
30969 if (!args) SWIG_fail;
30970 swig_obj[0] = args;
30971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30972 if (!SWIG_IsOK(res1)) {
30973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30974 }
30975 arg1 = reinterpret_cast< wxWindow * >(argp1);
30976 {
30977 PyThreadState* __tstate = wxPyBeginAllowThreads();
30978 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30979 wxPyEndAllowThreads(__tstate);
30980 if (PyErr_Occurred()) SWIG_fail;
30981 }
30982 resultobj = SWIG_Py_Void();
30983 if (SWIG_IsTmpObj(res2)) {
30984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30985 } else {
30986 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30988 }
30989 if (SWIG_IsTmpObj(res3)) {
30990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30991 } else {
30992 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30994 }
30995 return resultobj;
30996 fail:
30997 return NULL;
30998 }
30999
31000
31001 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31002 PyObject *resultobj = 0;
31003 wxWindow *arg1 = (wxWindow *) 0 ;
31004 wxRect result;
31005 void *argp1 = 0 ;
31006 int res1 = 0 ;
31007 PyObject *swig_obj[1] ;
31008
31009 if (!args) SWIG_fail;
31010 swig_obj[0] = args;
31011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31012 if (!SWIG_IsOK(res1)) {
31013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31014 }
31015 arg1 = reinterpret_cast< wxWindow * >(argp1);
31016 {
31017 PyThreadState* __tstate = wxPyBeginAllowThreads();
31018 result = ((wxWindow const *)arg1)->GetScreenRect();
31019 wxPyEndAllowThreads(__tstate);
31020 if (PyErr_Occurred()) SWIG_fail;
31021 }
31022 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31030 PyObject *resultobj = 0;
31031 wxWindow *arg1 = (wxWindow *) 0 ;
31032 wxSize result;
31033 void *argp1 = 0 ;
31034 int res1 = 0 ;
31035 PyObject *swig_obj[1] ;
31036
31037 if (!args) SWIG_fail;
31038 swig_obj[0] = args;
31039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31040 if (!SWIG_IsOK(res1)) {
31041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31042 }
31043 arg1 = reinterpret_cast< wxWindow * >(argp1);
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 result = ((wxWindow const *)arg1)->GetSize();
31047 wxPyEndAllowThreads(__tstate);
31048 if (PyErr_Occurred()) SWIG_fail;
31049 }
31050 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31051 return resultobj;
31052 fail:
31053 return NULL;
31054 }
31055
31056
31057 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31058 PyObject *resultobj = 0;
31059 wxWindow *arg1 = (wxWindow *) 0 ;
31060 int *arg2 = (int *) 0 ;
31061 int *arg3 = (int *) 0 ;
31062 void *argp1 = 0 ;
31063 int res1 = 0 ;
31064 int temp2 ;
31065 int res2 = SWIG_TMPOBJ ;
31066 int temp3 ;
31067 int res3 = SWIG_TMPOBJ ;
31068 PyObject *swig_obj[1] ;
31069
31070 arg2 = &temp2;
31071 arg3 = &temp3;
31072 if (!args) SWIG_fail;
31073 swig_obj[0] = args;
31074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31075 if (!SWIG_IsOK(res1)) {
31076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31077 }
31078 arg1 = reinterpret_cast< wxWindow * >(argp1);
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 resultobj = SWIG_Py_Void();
31086 if (SWIG_IsTmpObj(res2)) {
31087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31088 } else {
31089 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31091 }
31092 if (SWIG_IsTmpObj(res3)) {
31093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31094 } else {
31095 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31097 }
31098 return resultobj;
31099 fail:
31100 return NULL;
31101 }
31102
31103
31104 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31105 PyObject *resultobj = 0;
31106 wxWindow *arg1 = (wxWindow *) 0 ;
31107 wxRect result;
31108 void *argp1 = 0 ;
31109 int res1 = 0 ;
31110 PyObject *swig_obj[1] ;
31111
31112 if (!args) SWIG_fail;
31113 swig_obj[0] = args;
31114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31117 }
31118 arg1 = reinterpret_cast< wxWindow * >(argp1);
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 result = ((wxWindow const *)arg1)->GetRect();
31122 wxPyEndAllowThreads(__tstate);
31123 if (PyErr_Occurred()) SWIG_fail;
31124 }
31125 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31126 return resultobj;
31127 fail:
31128 return NULL;
31129 }
31130
31131
31132 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31133 PyObject *resultobj = 0;
31134 wxWindow *arg1 = (wxWindow *) 0 ;
31135 wxSize result;
31136 void *argp1 = 0 ;
31137 int res1 = 0 ;
31138 PyObject *swig_obj[1] ;
31139
31140 if (!args) SWIG_fail;
31141 swig_obj[0] = args;
31142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31143 if (!SWIG_IsOK(res1)) {
31144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31145 }
31146 arg1 = reinterpret_cast< wxWindow * >(argp1);
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = ((wxWindow const *)arg1)->GetClientSize();
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31161 PyObject *resultobj = 0;
31162 wxWindow *arg1 = (wxWindow *) 0 ;
31163 int *arg2 = (int *) 0 ;
31164 int *arg3 = (int *) 0 ;
31165 void *argp1 = 0 ;
31166 int res1 = 0 ;
31167 int temp2 ;
31168 int res2 = SWIG_TMPOBJ ;
31169 int temp3 ;
31170 int res3 = SWIG_TMPOBJ ;
31171 PyObject *swig_obj[1] ;
31172
31173 arg2 = &temp2;
31174 arg3 = &temp3;
31175 if (!args) SWIG_fail;
31176 swig_obj[0] = args;
31177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31178 if (!SWIG_IsOK(res1)) {
31179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31180 }
31181 arg1 = reinterpret_cast< wxWindow * >(argp1);
31182 {
31183 PyThreadState* __tstate = wxPyBeginAllowThreads();
31184 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 resultobj = SWIG_Py_Void();
31189 if (SWIG_IsTmpObj(res2)) {
31190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31191 } else {
31192 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31194 }
31195 if (SWIG_IsTmpObj(res3)) {
31196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31197 } else {
31198 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31200 }
31201 return resultobj;
31202 fail:
31203 return NULL;
31204 }
31205
31206
31207 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31208 PyObject *resultobj = 0;
31209 wxWindow *arg1 = (wxWindow *) 0 ;
31210 wxPoint result;
31211 void *argp1 = 0 ;
31212 int res1 = 0 ;
31213 PyObject *swig_obj[1] ;
31214
31215 if (!args) SWIG_fail;
31216 swig_obj[0] = args;
31217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31218 if (!SWIG_IsOK(res1)) {
31219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31220 }
31221 arg1 = reinterpret_cast< wxWindow * >(argp1);
31222 {
31223 PyThreadState* __tstate = wxPyBeginAllowThreads();
31224 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31225 wxPyEndAllowThreads(__tstate);
31226 if (PyErr_Occurred()) SWIG_fail;
31227 }
31228 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31229 return resultobj;
31230 fail:
31231 return NULL;
31232 }
31233
31234
31235 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31236 PyObject *resultobj = 0;
31237 wxWindow *arg1 = (wxWindow *) 0 ;
31238 wxRect result;
31239 void *argp1 = 0 ;
31240 int res1 = 0 ;
31241 PyObject *swig_obj[1] ;
31242
31243 if (!args) SWIG_fail;
31244 swig_obj[0] = args;
31245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31246 if (!SWIG_IsOK(res1)) {
31247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31248 }
31249 arg1 = reinterpret_cast< wxWindow * >(argp1);
31250 {
31251 PyThreadState* __tstate = wxPyBeginAllowThreads();
31252 result = ((wxWindow const *)arg1)->GetClientRect();
31253 wxPyEndAllowThreads(__tstate);
31254 if (PyErr_Occurred()) SWIG_fail;
31255 }
31256 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31257 return resultobj;
31258 fail:
31259 return NULL;
31260 }
31261
31262
31263 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31264 PyObject *resultobj = 0;
31265 wxWindow *arg1 = (wxWindow *) 0 ;
31266 wxSize result;
31267 void *argp1 = 0 ;
31268 int res1 = 0 ;
31269 PyObject *swig_obj[1] ;
31270
31271 if (!args) SWIG_fail;
31272 swig_obj[0] = args;
31273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31274 if (!SWIG_IsOK(res1)) {
31275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31276 }
31277 arg1 = reinterpret_cast< wxWindow * >(argp1);
31278 {
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 result = ((wxWindow const *)arg1)->GetBestSize();
31281 wxPyEndAllowThreads(__tstate);
31282 if (PyErr_Occurred()) SWIG_fail;
31283 }
31284 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31285 return resultobj;
31286 fail:
31287 return NULL;
31288 }
31289
31290
31291 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31292 PyObject *resultobj = 0;
31293 wxWindow *arg1 = (wxWindow *) 0 ;
31294 int *arg2 = (int *) 0 ;
31295 int *arg3 = (int *) 0 ;
31296 void *argp1 = 0 ;
31297 int res1 = 0 ;
31298 int temp2 ;
31299 int res2 = SWIG_TMPOBJ ;
31300 int temp3 ;
31301 int res3 = SWIG_TMPOBJ ;
31302 PyObject *swig_obj[1] ;
31303
31304 arg2 = &temp2;
31305 arg3 = &temp3;
31306 if (!args) SWIG_fail;
31307 swig_obj[0] = args;
31308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31309 if (!SWIG_IsOK(res1)) {
31310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31311 }
31312 arg1 = reinterpret_cast< wxWindow * >(argp1);
31313 {
31314 PyThreadState* __tstate = wxPyBeginAllowThreads();
31315 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31316 wxPyEndAllowThreads(__tstate);
31317 if (PyErr_Occurred()) SWIG_fail;
31318 }
31319 resultobj = SWIG_Py_Void();
31320 if (SWIG_IsTmpObj(res2)) {
31321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31322 } else {
31323 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31325 }
31326 if (SWIG_IsTmpObj(res3)) {
31327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31328 } else {
31329 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31331 }
31332 return resultobj;
31333 fail:
31334 return NULL;
31335 }
31336
31337
31338 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31339 PyObject *resultobj = 0;
31340 wxWindow *arg1 = (wxWindow *) 0 ;
31341 void *argp1 = 0 ;
31342 int res1 = 0 ;
31343 PyObject *swig_obj[1] ;
31344
31345 if (!args) SWIG_fail;
31346 swig_obj[0] = args;
31347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31348 if (!SWIG_IsOK(res1)) {
31349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31350 }
31351 arg1 = reinterpret_cast< wxWindow * >(argp1);
31352 {
31353 PyThreadState* __tstate = wxPyBeginAllowThreads();
31354 (arg1)->InvalidateBestSize();
31355 wxPyEndAllowThreads(__tstate);
31356 if (PyErr_Occurred()) SWIG_fail;
31357 }
31358 resultobj = SWIG_Py_Void();
31359 return resultobj;
31360 fail:
31361 return NULL;
31362 }
31363
31364
31365 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31366 PyObject *resultobj = 0;
31367 wxWindow *arg1 = (wxWindow *) 0 ;
31368 wxSize *arg2 = 0 ;
31369 void *argp1 = 0 ;
31370 int res1 = 0 ;
31371 wxSize temp2 ;
31372 PyObject * obj0 = 0 ;
31373 PyObject * obj1 = 0 ;
31374 char * kwnames[] = {
31375 (char *) "self",(char *) "size", NULL
31376 };
31377
31378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31380 if (!SWIG_IsOK(res1)) {
31381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31382 }
31383 arg1 = reinterpret_cast< wxWindow * >(argp1);
31384 {
31385 arg2 = &temp2;
31386 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31387 }
31388 {
31389 PyThreadState* __tstate = wxPyBeginAllowThreads();
31390 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31391 wxPyEndAllowThreads(__tstate);
31392 if (PyErr_Occurred()) SWIG_fail;
31393 }
31394 resultobj = SWIG_Py_Void();
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31402 PyObject *resultobj = 0;
31403 wxWindow *arg1 = (wxWindow *) 0 ;
31404 wxSize result;
31405 void *argp1 = 0 ;
31406 int res1 = 0 ;
31407 PyObject *swig_obj[1] ;
31408
31409 if (!args) SWIG_fail;
31410 swig_obj[0] = args;
31411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31412 if (!SWIG_IsOK(res1)) {
31413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31414 }
31415 arg1 = reinterpret_cast< wxWindow * >(argp1);
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31419 wxPyEndAllowThreads(__tstate);
31420 if (PyErr_Occurred()) SWIG_fail;
31421 }
31422 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31423 return resultobj;
31424 fail:
31425 return NULL;
31426 }
31427
31428
31429 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31430 PyObject *resultobj = 0;
31431 wxWindow *arg1 = (wxWindow *) 0 ;
31432 wxSize result;
31433 void *argp1 = 0 ;
31434 int res1 = 0 ;
31435 PyObject *swig_obj[1] ;
31436
31437 if (!args) SWIG_fail;
31438 swig_obj[0] = args;
31439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31440 if (!SWIG_IsOK(res1)) {
31441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31442 }
31443 arg1 = reinterpret_cast< wxWindow * >(argp1);
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31447 wxPyEndAllowThreads(__tstate);
31448 if (PyErr_Occurred()) SWIG_fail;
31449 }
31450 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31458 PyObject *resultobj = 0;
31459 wxWindow *arg1 = (wxWindow *) 0 ;
31460 int arg2 = (int) wxBOTH ;
31461 void *argp1 = 0 ;
31462 int res1 = 0 ;
31463 int val2 ;
31464 int ecode2 = 0 ;
31465 PyObject * obj0 = 0 ;
31466 PyObject * obj1 = 0 ;
31467 char * kwnames[] = {
31468 (char *) "self",(char *) "direction", NULL
31469 };
31470
31471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31473 if (!SWIG_IsOK(res1)) {
31474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31475 }
31476 arg1 = reinterpret_cast< wxWindow * >(argp1);
31477 if (obj1) {
31478 ecode2 = SWIG_AsVal_int(obj1, &val2);
31479 if (!SWIG_IsOK(ecode2)) {
31480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31481 }
31482 arg2 = static_cast< int >(val2);
31483 }
31484 {
31485 PyThreadState* __tstate = wxPyBeginAllowThreads();
31486 (arg1)->Center(arg2);
31487 wxPyEndAllowThreads(__tstate);
31488 if (PyErr_Occurred()) SWIG_fail;
31489 }
31490 resultobj = SWIG_Py_Void();
31491 return resultobj;
31492 fail:
31493 return NULL;
31494 }
31495
31496
31497 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31498 PyObject *resultobj = 0;
31499 wxWindow *arg1 = (wxWindow *) 0 ;
31500 int arg2 = (int) wxBOTH ;
31501 void *argp1 = 0 ;
31502 int res1 = 0 ;
31503 int val2 ;
31504 int ecode2 = 0 ;
31505 PyObject * obj0 = 0 ;
31506 PyObject * obj1 = 0 ;
31507 char * kwnames[] = {
31508 (char *) "self",(char *) "dir", NULL
31509 };
31510
31511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31513 if (!SWIG_IsOK(res1)) {
31514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31515 }
31516 arg1 = reinterpret_cast< wxWindow * >(argp1);
31517 if (obj1) {
31518 ecode2 = SWIG_AsVal_int(obj1, &val2);
31519 if (!SWIG_IsOK(ecode2)) {
31520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31521 }
31522 arg2 = static_cast< int >(val2);
31523 }
31524 {
31525 PyThreadState* __tstate = wxPyBeginAllowThreads();
31526 (arg1)->CenterOnParent(arg2);
31527 wxPyEndAllowThreads(__tstate);
31528 if (PyErr_Occurred()) SWIG_fail;
31529 }
31530 resultobj = SWIG_Py_Void();
31531 return resultobj;
31532 fail:
31533 return NULL;
31534 }
31535
31536
31537 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31538 PyObject *resultobj = 0;
31539 wxWindow *arg1 = (wxWindow *) 0 ;
31540 void *argp1 = 0 ;
31541 int res1 = 0 ;
31542 PyObject *swig_obj[1] ;
31543
31544 if (!args) SWIG_fail;
31545 swig_obj[0] = args;
31546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31547 if (!SWIG_IsOK(res1)) {
31548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31549 }
31550 arg1 = reinterpret_cast< wxWindow * >(argp1);
31551 {
31552 PyThreadState* __tstate = wxPyBeginAllowThreads();
31553 (arg1)->Fit();
31554 wxPyEndAllowThreads(__tstate);
31555 if (PyErr_Occurred()) SWIG_fail;
31556 }
31557 resultobj = SWIG_Py_Void();
31558 return resultobj;
31559 fail:
31560 return NULL;
31561 }
31562
31563
31564 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31565 PyObject *resultobj = 0;
31566 wxWindow *arg1 = (wxWindow *) 0 ;
31567 void *argp1 = 0 ;
31568 int res1 = 0 ;
31569 PyObject *swig_obj[1] ;
31570
31571 if (!args) SWIG_fail;
31572 swig_obj[0] = args;
31573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31574 if (!SWIG_IsOK(res1)) {
31575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31576 }
31577 arg1 = reinterpret_cast< wxWindow * >(argp1);
31578 {
31579 PyThreadState* __tstate = wxPyBeginAllowThreads();
31580 (arg1)->FitInside();
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 resultobj = SWIG_Py_Void();
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj = 0;
31593 wxWindow *arg1 = (wxWindow *) 0 ;
31594 int arg2 ;
31595 int arg3 ;
31596 int arg4 = (int) -1 ;
31597 int arg5 = (int) -1 ;
31598 int arg6 = (int) -1 ;
31599 int arg7 = (int) -1 ;
31600 void *argp1 = 0 ;
31601 int res1 = 0 ;
31602 int val2 ;
31603 int ecode2 = 0 ;
31604 int val3 ;
31605 int ecode3 = 0 ;
31606 int val4 ;
31607 int ecode4 = 0 ;
31608 int val5 ;
31609 int ecode5 = 0 ;
31610 int val6 ;
31611 int ecode6 = 0 ;
31612 int val7 ;
31613 int ecode7 = 0 ;
31614 PyObject * obj0 = 0 ;
31615 PyObject * obj1 = 0 ;
31616 PyObject * obj2 = 0 ;
31617 PyObject * obj3 = 0 ;
31618 PyObject * obj4 = 0 ;
31619 PyObject * obj5 = 0 ;
31620 PyObject * obj6 = 0 ;
31621 char * kwnames[] = {
31622 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31623 };
31624
31625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31627 if (!SWIG_IsOK(res1)) {
31628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31629 }
31630 arg1 = reinterpret_cast< wxWindow * >(argp1);
31631 ecode2 = SWIG_AsVal_int(obj1, &val2);
31632 if (!SWIG_IsOK(ecode2)) {
31633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31634 }
31635 arg2 = static_cast< int >(val2);
31636 ecode3 = SWIG_AsVal_int(obj2, &val3);
31637 if (!SWIG_IsOK(ecode3)) {
31638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31639 }
31640 arg3 = static_cast< int >(val3);
31641 if (obj3) {
31642 ecode4 = SWIG_AsVal_int(obj3, &val4);
31643 if (!SWIG_IsOK(ecode4)) {
31644 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31645 }
31646 arg4 = static_cast< int >(val4);
31647 }
31648 if (obj4) {
31649 ecode5 = SWIG_AsVal_int(obj4, &val5);
31650 if (!SWIG_IsOK(ecode5)) {
31651 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31652 }
31653 arg5 = static_cast< int >(val5);
31654 }
31655 if (obj5) {
31656 ecode6 = SWIG_AsVal_int(obj5, &val6);
31657 if (!SWIG_IsOK(ecode6)) {
31658 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31659 }
31660 arg6 = static_cast< int >(val6);
31661 }
31662 if (obj6) {
31663 ecode7 = SWIG_AsVal_int(obj6, &val7);
31664 if (!SWIG_IsOK(ecode7)) {
31665 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31666 }
31667 arg7 = static_cast< int >(val7);
31668 }
31669 {
31670 PyThreadState* __tstate = wxPyBeginAllowThreads();
31671 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31672 wxPyEndAllowThreads(__tstate);
31673 if (PyErr_Occurred()) SWIG_fail;
31674 }
31675 resultobj = SWIG_Py_Void();
31676 return resultobj;
31677 fail:
31678 return NULL;
31679 }
31680
31681
31682 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31683 PyObject *resultobj = 0;
31684 wxWindow *arg1 = (wxWindow *) 0 ;
31685 wxSize *arg2 = 0 ;
31686 wxSize const &arg3_defvalue = wxDefaultSize ;
31687 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31688 wxSize const &arg4_defvalue = wxDefaultSize ;
31689 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 wxSize temp2 ;
31693 wxSize temp3 ;
31694 wxSize temp4 ;
31695 PyObject * obj0 = 0 ;
31696 PyObject * obj1 = 0 ;
31697 PyObject * obj2 = 0 ;
31698 PyObject * obj3 = 0 ;
31699 char * kwnames[] = {
31700 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31701 };
31702
31703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31705 if (!SWIG_IsOK(res1)) {
31706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31707 }
31708 arg1 = reinterpret_cast< wxWindow * >(argp1);
31709 {
31710 arg2 = &temp2;
31711 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31712 }
31713 if (obj2) {
31714 {
31715 arg3 = &temp3;
31716 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31717 }
31718 }
31719 if (obj3) {
31720 {
31721 arg4 = &temp4;
31722 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31723 }
31724 }
31725 {
31726 PyThreadState* __tstate = wxPyBeginAllowThreads();
31727 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 resultobj = SWIG_Py_Void();
31732 return resultobj;
31733 fail:
31734 return NULL;
31735 }
31736
31737
31738 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31739 PyObject *resultobj = 0;
31740 wxWindow *arg1 = (wxWindow *) 0 ;
31741 int arg2 ;
31742 int arg3 ;
31743 int arg4 = (int) -1 ;
31744 int arg5 = (int) -1 ;
31745 void *argp1 = 0 ;
31746 int res1 = 0 ;
31747 int val2 ;
31748 int ecode2 = 0 ;
31749 int val3 ;
31750 int ecode3 = 0 ;
31751 int val4 ;
31752 int ecode4 = 0 ;
31753 int val5 ;
31754 int ecode5 = 0 ;
31755 PyObject * obj0 = 0 ;
31756 PyObject * obj1 = 0 ;
31757 PyObject * obj2 = 0 ;
31758 PyObject * obj3 = 0 ;
31759 PyObject * obj4 = 0 ;
31760 char * kwnames[] = {
31761 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31762 };
31763
31764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31766 if (!SWIG_IsOK(res1)) {
31767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31768 }
31769 arg1 = reinterpret_cast< wxWindow * >(argp1);
31770 ecode2 = SWIG_AsVal_int(obj1, &val2);
31771 if (!SWIG_IsOK(ecode2)) {
31772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31773 }
31774 arg2 = static_cast< int >(val2);
31775 ecode3 = SWIG_AsVal_int(obj2, &val3);
31776 if (!SWIG_IsOK(ecode3)) {
31777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31778 }
31779 arg3 = static_cast< int >(val3);
31780 if (obj3) {
31781 ecode4 = SWIG_AsVal_int(obj3, &val4);
31782 if (!SWIG_IsOK(ecode4)) {
31783 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31784 }
31785 arg4 = static_cast< int >(val4);
31786 }
31787 if (obj4) {
31788 ecode5 = SWIG_AsVal_int(obj4, &val5);
31789 if (!SWIG_IsOK(ecode5)) {
31790 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31791 }
31792 arg5 = static_cast< int >(val5);
31793 }
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 resultobj = SWIG_Py_Void();
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31808 PyObject *resultobj = 0;
31809 wxWindow *arg1 = (wxWindow *) 0 ;
31810 wxSize *arg2 = 0 ;
31811 wxSize const &arg3_defvalue = wxDefaultSize ;
31812 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31813 void *argp1 = 0 ;
31814 int res1 = 0 ;
31815 wxSize temp2 ;
31816 wxSize temp3 ;
31817 PyObject * obj0 = 0 ;
31818 PyObject * obj1 = 0 ;
31819 PyObject * obj2 = 0 ;
31820 char * kwnames[] = {
31821 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31822 };
31823
31824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31826 if (!SWIG_IsOK(res1)) {
31827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31828 }
31829 arg1 = reinterpret_cast< wxWindow * >(argp1);
31830 {
31831 arg2 = &temp2;
31832 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31833 }
31834 if (obj2) {
31835 {
31836 arg3 = &temp3;
31837 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31838 }
31839 }
31840 {
31841 PyThreadState* __tstate = wxPyBeginAllowThreads();
31842 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31843 wxPyEndAllowThreads(__tstate);
31844 if (PyErr_Occurred()) SWIG_fail;
31845 }
31846 resultobj = SWIG_Py_Void();
31847 return resultobj;
31848 fail:
31849 return NULL;
31850 }
31851
31852
31853 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31854 PyObject *resultobj = 0;
31855 wxWindow *arg1 = (wxWindow *) 0 ;
31856 wxSize result;
31857 void *argp1 = 0 ;
31858 int res1 = 0 ;
31859 PyObject *swig_obj[1] ;
31860
31861 if (!args) SWIG_fail;
31862 swig_obj[0] = args;
31863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31864 if (!SWIG_IsOK(res1)) {
31865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31866 }
31867 arg1 = reinterpret_cast< wxWindow * >(argp1);
31868 {
31869 PyThreadState* __tstate = wxPyBeginAllowThreads();
31870 result = ((wxWindow const *)arg1)->GetMaxSize();
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31875 return resultobj;
31876 fail:
31877 return NULL;
31878 }
31879
31880
31881 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31882 PyObject *resultobj = 0;
31883 wxWindow *arg1 = (wxWindow *) 0 ;
31884 wxSize result;
31885 void *argp1 = 0 ;
31886 int res1 = 0 ;
31887 PyObject *swig_obj[1] ;
31888
31889 if (!args) SWIG_fail;
31890 swig_obj[0] = args;
31891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31892 if (!SWIG_IsOK(res1)) {
31893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31894 }
31895 arg1 = reinterpret_cast< wxWindow * >(argp1);
31896 {
31897 PyThreadState* __tstate = wxPyBeginAllowThreads();
31898 result = ((wxWindow const *)arg1)->GetMinSize();
31899 wxPyEndAllowThreads(__tstate);
31900 if (PyErr_Occurred()) SWIG_fail;
31901 }
31902 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31903 return resultobj;
31904 fail:
31905 return NULL;
31906 }
31907
31908
31909 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31910 PyObject *resultobj = 0;
31911 wxWindow *arg1 = (wxWindow *) 0 ;
31912 wxSize *arg2 = 0 ;
31913 void *argp1 = 0 ;
31914 int res1 = 0 ;
31915 wxSize temp2 ;
31916 PyObject * obj0 = 0 ;
31917 PyObject * obj1 = 0 ;
31918 char * kwnames[] = {
31919 (char *) "self",(char *) "minSize", NULL
31920 };
31921
31922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) 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_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31926 }
31927 arg1 = reinterpret_cast< wxWindow * >(argp1);
31928 {
31929 arg2 = &temp2;
31930 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31931 }
31932 {
31933 PyThreadState* __tstate = wxPyBeginAllowThreads();
31934 (arg1)->SetMinSize((wxSize const &)*arg2);
31935 wxPyEndAllowThreads(__tstate);
31936 if (PyErr_Occurred()) SWIG_fail;
31937 }
31938 resultobj = SWIG_Py_Void();
31939 return resultobj;
31940 fail:
31941 return NULL;
31942 }
31943
31944
31945 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31946 PyObject *resultobj = 0;
31947 wxWindow *arg1 = (wxWindow *) 0 ;
31948 wxSize *arg2 = 0 ;
31949 void *argp1 = 0 ;
31950 int res1 = 0 ;
31951 wxSize temp2 ;
31952 PyObject * obj0 = 0 ;
31953 PyObject * obj1 = 0 ;
31954 char * kwnames[] = {
31955 (char *) "self",(char *) "maxSize", NULL
31956 };
31957
31958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31960 if (!SWIG_IsOK(res1)) {
31961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31962 }
31963 arg1 = reinterpret_cast< wxWindow * >(argp1);
31964 {
31965 arg2 = &temp2;
31966 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31967 }
31968 {
31969 PyThreadState* __tstate = wxPyBeginAllowThreads();
31970 (arg1)->SetMaxSize((wxSize const &)*arg2);
31971 wxPyEndAllowThreads(__tstate);
31972 if (PyErr_Occurred()) SWIG_fail;
31973 }
31974 resultobj = SWIG_Py_Void();
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31982 PyObject *resultobj = 0;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 int result;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 PyObject *swig_obj[1] ;
31988
31989 if (!args) SWIG_fail;
31990 swig_obj[0] = args;
31991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31992 if (!SWIG_IsOK(res1)) {
31993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31994 }
31995 arg1 = reinterpret_cast< wxWindow * >(argp1);
31996 {
31997 PyThreadState* __tstate = wxPyBeginAllowThreads();
31998 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31999 wxPyEndAllowThreads(__tstate);
32000 if (PyErr_Occurred()) SWIG_fail;
32001 }
32002 resultobj = SWIG_From_int(static_cast< int >(result));
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32010 PyObject *resultobj = 0;
32011 wxWindow *arg1 = (wxWindow *) 0 ;
32012 int result;
32013 void *argp1 = 0 ;
32014 int res1 = 0 ;
32015 PyObject *swig_obj[1] ;
32016
32017 if (!args) SWIG_fail;
32018 swig_obj[0] = args;
32019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32020 if (!SWIG_IsOK(res1)) {
32021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32022 }
32023 arg1 = reinterpret_cast< wxWindow * >(argp1);
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32027 wxPyEndAllowThreads(__tstate);
32028 if (PyErr_Occurred()) SWIG_fail;
32029 }
32030 resultobj = SWIG_From_int(static_cast< int >(result));
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32038 PyObject *resultobj = 0;
32039 wxWindow *arg1 = (wxWindow *) 0 ;
32040 int result;
32041 void *argp1 = 0 ;
32042 int res1 = 0 ;
32043 PyObject *swig_obj[1] ;
32044
32045 if (!args) SWIG_fail;
32046 swig_obj[0] = args;
32047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32048 if (!SWIG_IsOK(res1)) {
32049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32050 }
32051 arg1 = reinterpret_cast< wxWindow * >(argp1);
32052 {
32053 PyThreadState* __tstate = wxPyBeginAllowThreads();
32054 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32055 wxPyEndAllowThreads(__tstate);
32056 if (PyErr_Occurred()) SWIG_fail;
32057 }
32058 resultobj = SWIG_From_int(static_cast< int >(result));
32059 return resultobj;
32060 fail:
32061 return NULL;
32062 }
32063
32064
32065 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32066 PyObject *resultobj = 0;
32067 wxWindow *arg1 = (wxWindow *) 0 ;
32068 int result;
32069 void *argp1 = 0 ;
32070 int res1 = 0 ;
32071 PyObject *swig_obj[1] ;
32072
32073 if (!args) SWIG_fail;
32074 swig_obj[0] = args;
32075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32076 if (!SWIG_IsOK(res1)) {
32077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32078 }
32079 arg1 = reinterpret_cast< wxWindow * >(argp1);
32080 {
32081 PyThreadState* __tstate = wxPyBeginAllowThreads();
32082 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32083 wxPyEndAllowThreads(__tstate);
32084 if (PyErr_Occurred()) SWIG_fail;
32085 }
32086 resultobj = SWIG_From_int(static_cast< int >(result));
32087 return resultobj;
32088 fail:
32089 return NULL;
32090 }
32091
32092
32093 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32094 PyObject *resultobj = 0;
32095 wxWindow *arg1 = (wxWindow *) 0 ;
32096 wxSize *arg2 = 0 ;
32097 void *argp1 = 0 ;
32098 int res1 = 0 ;
32099 wxSize temp2 ;
32100 PyObject * obj0 = 0 ;
32101 PyObject * obj1 = 0 ;
32102 char * kwnames[] = {
32103 (char *) "self",(char *) "size", NULL
32104 };
32105
32106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32108 if (!SWIG_IsOK(res1)) {
32109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32110 }
32111 arg1 = reinterpret_cast< wxWindow * >(argp1);
32112 {
32113 arg2 = &temp2;
32114 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32115 }
32116 {
32117 PyThreadState* __tstate = wxPyBeginAllowThreads();
32118 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 resultobj = SWIG_Py_Void();
32123 return resultobj;
32124 fail:
32125 return NULL;
32126 }
32127
32128
32129 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32130 PyObject *resultobj = 0;
32131 wxWindow *arg1 = (wxWindow *) 0 ;
32132 int arg2 ;
32133 int arg3 ;
32134 void *argp1 = 0 ;
32135 int res1 = 0 ;
32136 int val2 ;
32137 int ecode2 = 0 ;
32138 int val3 ;
32139 int ecode3 = 0 ;
32140 PyObject * obj0 = 0 ;
32141 PyObject * obj1 = 0 ;
32142 PyObject * obj2 = 0 ;
32143 char * kwnames[] = {
32144 (char *) "self",(char *) "w",(char *) "h", NULL
32145 };
32146
32147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32149 if (!SWIG_IsOK(res1)) {
32150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32151 }
32152 arg1 = reinterpret_cast< wxWindow * >(argp1);
32153 ecode2 = SWIG_AsVal_int(obj1, &val2);
32154 if (!SWIG_IsOK(ecode2)) {
32155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32156 }
32157 arg2 = static_cast< int >(val2);
32158 ecode3 = SWIG_AsVal_int(obj2, &val3);
32159 if (!SWIG_IsOK(ecode3)) {
32160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32161 }
32162 arg3 = static_cast< int >(val3);
32163 {
32164 PyThreadState* __tstate = wxPyBeginAllowThreads();
32165 (arg1)->SetVirtualSize(arg2,arg3);
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 resultobj = SWIG_Py_Void();
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32177 PyObject *resultobj = 0;
32178 wxWindow *arg1 = (wxWindow *) 0 ;
32179 wxSize result;
32180 void *argp1 = 0 ;
32181 int res1 = 0 ;
32182 PyObject *swig_obj[1] ;
32183
32184 if (!args) SWIG_fail;
32185 swig_obj[0] = args;
32186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32187 if (!SWIG_IsOK(res1)) {
32188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32189 }
32190 arg1 = reinterpret_cast< wxWindow * >(argp1);
32191 {
32192 PyThreadState* __tstate = wxPyBeginAllowThreads();
32193 result = ((wxWindow const *)arg1)->GetVirtualSize();
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32198 return resultobj;
32199 fail:
32200 return NULL;
32201 }
32202
32203
32204 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32205 PyObject *resultobj = 0;
32206 wxWindow *arg1 = (wxWindow *) 0 ;
32207 int *arg2 = (int *) 0 ;
32208 int *arg3 = (int *) 0 ;
32209 void *argp1 = 0 ;
32210 int res1 = 0 ;
32211 int temp2 ;
32212 int res2 = SWIG_TMPOBJ ;
32213 int temp3 ;
32214 int res3 = SWIG_TMPOBJ ;
32215 PyObject *swig_obj[1] ;
32216
32217 arg2 = &temp2;
32218 arg3 = &temp3;
32219 if (!args) SWIG_fail;
32220 swig_obj[0] = args;
32221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32222 if (!SWIG_IsOK(res1)) {
32223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32224 }
32225 arg1 = reinterpret_cast< wxWindow * >(argp1);
32226 {
32227 PyThreadState* __tstate = wxPyBeginAllowThreads();
32228 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32229 wxPyEndAllowThreads(__tstate);
32230 if (PyErr_Occurred()) SWIG_fail;
32231 }
32232 resultobj = SWIG_Py_Void();
32233 if (SWIG_IsTmpObj(res2)) {
32234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32235 } else {
32236 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32238 }
32239 if (SWIG_IsTmpObj(res3)) {
32240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32241 } else {
32242 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32244 }
32245 return resultobj;
32246 fail:
32247 return NULL;
32248 }
32249
32250
32251 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32252 PyObject *resultobj = 0;
32253 wxWindow *arg1 = (wxWindow *) 0 ;
32254 wxSize result;
32255 void *argp1 = 0 ;
32256 int res1 = 0 ;
32257 PyObject *swig_obj[1] ;
32258
32259 if (!args) SWIG_fail;
32260 swig_obj[0] = args;
32261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32262 if (!SWIG_IsOK(res1)) {
32263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32264 }
32265 arg1 = reinterpret_cast< wxWindow * >(argp1);
32266 {
32267 PyThreadState* __tstate = wxPyBeginAllowThreads();
32268 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32273 return resultobj;
32274 fail:
32275 return NULL;
32276 }
32277
32278
32279 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32280 PyObject *resultobj = 0;
32281 wxWindow *arg1 = (wxWindow *) 0 ;
32282 bool arg2 = (bool) true ;
32283 bool result;
32284 void *argp1 = 0 ;
32285 int res1 = 0 ;
32286 bool val2 ;
32287 int ecode2 = 0 ;
32288 PyObject * obj0 = 0 ;
32289 PyObject * obj1 = 0 ;
32290 char * kwnames[] = {
32291 (char *) "self",(char *) "show", NULL
32292 };
32293
32294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32296 if (!SWIG_IsOK(res1)) {
32297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32298 }
32299 arg1 = reinterpret_cast< wxWindow * >(argp1);
32300 if (obj1) {
32301 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32302 if (!SWIG_IsOK(ecode2)) {
32303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32304 }
32305 arg2 = static_cast< bool >(val2);
32306 }
32307 {
32308 PyThreadState* __tstate = wxPyBeginAllowThreads();
32309 result = (bool)(arg1)->Show(arg2);
32310 wxPyEndAllowThreads(__tstate);
32311 if (PyErr_Occurred()) SWIG_fail;
32312 }
32313 {
32314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32315 }
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32323 PyObject *resultobj = 0;
32324 wxWindow *arg1 = (wxWindow *) 0 ;
32325 bool result;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 PyObject *swig_obj[1] ;
32329
32330 if (!args) SWIG_fail;
32331 swig_obj[0] = args;
32332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32333 if (!SWIG_IsOK(res1)) {
32334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32335 }
32336 arg1 = reinterpret_cast< wxWindow * >(argp1);
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 result = (bool)(arg1)->Hide();
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 {
32344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32345 }
32346 return resultobj;
32347 fail:
32348 return NULL;
32349 }
32350
32351
32352 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32353 PyObject *resultobj = 0;
32354 wxWindow *arg1 = (wxWindow *) 0 ;
32355 bool arg2 = (bool) true ;
32356 bool result;
32357 void *argp1 = 0 ;
32358 int res1 = 0 ;
32359 bool val2 ;
32360 int ecode2 = 0 ;
32361 PyObject * obj0 = 0 ;
32362 PyObject * obj1 = 0 ;
32363 char * kwnames[] = {
32364 (char *) "self",(char *) "enable", NULL
32365 };
32366
32367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32369 if (!SWIG_IsOK(res1)) {
32370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32371 }
32372 arg1 = reinterpret_cast< wxWindow * >(argp1);
32373 if (obj1) {
32374 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32375 if (!SWIG_IsOK(ecode2)) {
32376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32377 }
32378 arg2 = static_cast< bool >(val2);
32379 }
32380 {
32381 PyThreadState* __tstate = wxPyBeginAllowThreads();
32382 result = (bool)(arg1)->Enable(arg2);
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 {
32387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32388 }
32389 return resultobj;
32390 fail:
32391 return NULL;
32392 }
32393
32394
32395 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 PyObject *resultobj = 0;
32397 wxWindow *arg1 = (wxWindow *) 0 ;
32398 bool result;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 PyObject *swig_obj[1] ;
32402
32403 if (!args) SWIG_fail;
32404 swig_obj[0] = args;
32405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32406 if (!SWIG_IsOK(res1)) {
32407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32408 }
32409 arg1 = reinterpret_cast< wxWindow * >(argp1);
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 result = (bool)(arg1)->Disable();
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 {
32417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32418 }
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32426 PyObject *resultobj = 0;
32427 wxWindow *arg1 = (wxWindow *) 0 ;
32428 bool result;
32429 void *argp1 = 0 ;
32430 int res1 = 0 ;
32431 PyObject *swig_obj[1] ;
32432
32433 if (!args) SWIG_fail;
32434 swig_obj[0] = args;
32435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32436 if (!SWIG_IsOK(res1)) {
32437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32438 }
32439 arg1 = reinterpret_cast< wxWindow * >(argp1);
32440 {
32441 PyThreadState* __tstate = wxPyBeginAllowThreads();
32442 result = (bool)((wxWindow const *)arg1)->IsShown();
32443 wxPyEndAllowThreads(__tstate);
32444 if (PyErr_Occurred()) SWIG_fail;
32445 }
32446 {
32447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32448 }
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32456 PyObject *resultobj = 0;
32457 wxWindow *arg1 = (wxWindow *) 0 ;
32458 bool result;
32459 void *argp1 = 0 ;
32460 int res1 = 0 ;
32461 PyObject *swig_obj[1] ;
32462
32463 if (!args) SWIG_fail;
32464 swig_obj[0] = args;
32465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32466 if (!SWIG_IsOK(res1)) {
32467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32468 }
32469 arg1 = reinterpret_cast< wxWindow * >(argp1);
32470 {
32471 PyThreadState* __tstate = wxPyBeginAllowThreads();
32472 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 {
32477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32478 }
32479 return resultobj;
32480 fail:
32481 return NULL;
32482 }
32483
32484
32485 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32486 PyObject *resultobj = 0;
32487 wxWindow *arg1 = (wxWindow *) 0 ;
32488 long arg2 ;
32489 void *argp1 = 0 ;
32490 int res1 = 0 ;
32491 long val2 ;
32492 int ecode2 = 0 ;
32493 PyObject * obj0 = 0 ;
32494 PyObject * obj1 = 0 ;
32495 char * kwnames[] = {
32496 (char *) "self",(char *) "style", NULL
32497 };
32498
32499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32501 if (!SWIG_IsOK(res1)) {
32502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32503 }
32504 arg1 = reinterpret_cast< wxWindow * >(argp1);
32505 ecode2 = SWIG_AsVal_long(obj1, &val2);
32506 if (!SWIG_IsOK(ecode2)) {
32507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32508 }
32509 arg2 = static_cast< long >(val2);
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 (arg1)->SetWindowStyleFlag(arg2);
32513 wxPyEndAllowThreads(__tstate);
32514 if (PyErr_Occurred()) SWIG_fail;
32515 }
32516 resultobj = SWIG_Py_Void();
32517 return resultobj;
32518 fail:
32519 return NULL;
32520 }
32521
32522
32523 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32524 PyObject *resultobj = 0;
32525 wxWindow *arg1 = (wxWindow *) 0 ;
32526 long result;
32527 void *argp1 = 0 ;
32528 int res1 = 0 ;
32529 PyObject *swig_obj[1] ;
32530
32531 if (!args) SWIG_fail;
32532 swig_obj[0] = args;
32533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32534 if (!SWIG_IsOK(res1)) {
32535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32536 }
32537 arg1 = reinterpret_cast< wxWindow * >(argp1);
32538 {
32539 PyThreadState* __tstate = wxPyBeginAllowThreads();
32540 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32541 wxPyEndAllowThreads(__tstate);
32542 if (PyErr_Occurred()) SWIG_fail;
32543 }
32544 resultobj = SWIG_From_long(static_cast< long >(result));
32545 return resultobj;
32546 fail:
32547 return NULL;
32548 }
32549
32550
32551 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32552 PyObject *resultobj = 0;
32553 wxWindow *arg1 = (wxWindow *) 0 ;
32554 int arg2 ;
32555 bool result;
32556 void *argp1 = 0 ;
32557 int res1 = 0 ;
32558 int val2 ;
32559 int ecode2 = 0 ;
32560 PyObject * obj0 = 0 ;
32561 PyObject * obj1 = 0 ;
32562 char * kwnames[] = {
32563 (char *) "self",(char *) "flag", NULL
32564 };
32565
32566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32568 if (!SWIG_IsOK(res1)) {
32569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32570 }
32571 arg1 = reinterpret_cast< wxWindow * >(argp1);
32572 ecode2 = SWIG_AsVal_int(obj1, &val2);
32573 if (!SWIG_IsOK(ecode2)) {
32574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32575 }
32576 arg2 = static_cast< int >(val2);
32577 {
32578 PyThreadState* __tstate = wxPyBeginAllowThreads();
32579 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32580 wxPyEndAllowThreads(__tstate);
32581 if (PyErr_Occurred()) SWIG_fail;
32582 }
32583 {
32584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32585 }
32586 return resultobj;
32587 fail:
32588 return NULL;
32589 }
32590
32591
32592 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32593 PyObject *resultobj = 0;
32594 wxWindow *arg1 = (wxWindow *) 0 ;
32595 bool result;
32596 void *argp1 = 0 ;
32597 int res1 = 0 ;
32598 PyObject *swig_obj[1] ;
32599
32600 if (!args) SWIG_fail;
32601 swig_obj[0] = args;
32602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32603 if (!SWIG_IsOK(res1)) {
32604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32605 }
32606 arg1 = reinterpret_cast< wxWindow * >(argp1);
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 result = (bool)((wxWindow const *)arg1)->IsRetained();
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 {
32614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32615 }
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32623 PyObject *resultobj = 0;
32624 wxWindow *arg1 = (wxWindow *) 0 ;
32625 long arg2 ;
32626 void *argp1 = 0 ;
32627 int res1 = 0 ;
32628 long val2 ;
32629 int ecode2 = 0 ;
32630 PyObject * obj0 = 0 ;
32631 PyObject * obj1 = 0 ;
32632 char * kwnames[] = {
32633 (char *) "self",(char *) "exStyle", NULL
32634 };
32635
32636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32638 if (!SWIG_IsOK(res1)) {
32639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32640 }
32641 arg1 = reinterpret_cast< wxWindow * >(argp1);
32642 ecode2 = SWIG_AsVal_long(obj1, &val2);
32643 if (!SWIG_IsOK(ecode2)) {
32644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32645 }
32646 arg2 = static_cast< long >(val2);
32647 {
32648 PyThreadState* __tstate = wxPyBeginAllowThreads();
32649 (arg1)->SetExtraStyle(arg2);
32650 wxPyEndAllowThreads(__tstate);
32651 if (PyErr_Occurred()) SWIG_fail;
32652 }
32653 resultobj = SWIG_Py_Void();
32654 return resultobj;
32655 fail:
32656 return NULL;
32657 }
32658
32659
32660 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32661 PyObject *resultobj = 0;
32662 wxWindow *arg1 = (wxWindow *) 0 ;
32663 long result;
32664 void *argp1 = 0 ;
32665 int res1 = 0 ;
32666 PyObject *swig_obj[1] ;
32667
32668 if (!args) SWIG_fail;
32669 swig_obj[0] = args;
32670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32671 if (!SWIG_IsOK(res1)) {
32672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32673 }
32674 arg1 = reinterpret_cast< wxWindow * >(argp1);
32675 {
32676 PyThreadState* __tstate = wxPyBeginAllowThreads();
32677 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32678 wxPyEndAllowThreads(__tstate);
32679 if (PyErr_Occurred()) SWIG_fail;
32680 }
32681 resultobj = SWIG_From_long(static_cast< long >(result));
32682 return resultobj;
32683 fail:
32684 return NULL;
32685 }
32686
32687
32688 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32689 PyObject *resultobj = 0;
32690 wxWindow *arg1 = (wxWindow *) 0 ;
32691 bool arg2 = (bool) true ;
32692 void *argp1 = 0 ;
32693 int res1 = 0 ;
32694 bool val2 ;
32695 int ecode2 = 0 ;
32696 PyObject * obj0 = 0 ;
32697 PyObject * obj1 = 0 ;
32698 char * kwnames[] = {
32699 (char *) "self",(char *) "modal", NULL
32700 };
32701
32702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32704 if (!SWIG_IsOK(res1)) {
32705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32706 }
32707 arg1 = reinterpret_cast< wxWindow * >(argp1);
32708 if (obj1) {
32709 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32710 if (!SWIG_IsOK(ecode2)) {
32711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32712 }
32713 arg2 = static_cast< bool >(val2);
32714 }
32715 {
32716 PyThreadState* __tstate = wxPyBeginAllowThreads();
32717 (arg1)->MakeModal(arg2);
32718 wxPyEndAllowThreads(__tstate);
32719 if (PyErr_Occurred()) SWIG_fail;
32720 }
32721 resultobj = SWIG_Py_Void();
32722 return resultobj;
32723 fail:
32724 return NULL;
32725 }
32726
32727
32728 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32729 PyObject *resultobj = 0;
32730 wxWindow *arg1 = (wxWindow *) 0 ;
32731 bool arg2 ;
32732 void *argp1 = 0 ;
32733 int res1 = 0 ;
32734 bool val2 ;
32735 int ecode2 = 0 ;
32736 PyObject * obj0 = 0 ;
32737 PyObject * obj1 = 0 ;
32738 char * kwnames[] = {
32739 (char *) "self",(char *) "enableTheme", NULL
32740 };
32741
32742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32744 if (!SWIG_IsOK(res1)) {
32745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32746 }
32747 arg1 = reinterpret_cast< wxWindow * >(argp1);
32748 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32749 if (!SWIG_IsOK(ecode2)) {
32750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32751 }
32752 arg2 = static_cast< bool >(val2);
32753 {
32754 PyThreadState* __tstate = wxPyBeginAllowThreads();
32755 (arg1)->SetThemeEnabled(arg2);
32756 wxPyEndAllowThreads(__tstate);
32757 if (PyErr_Occurred()) SWIG_fail;
32758 }
32759 resultobj = SWIG_Py_Void();
32760 return resultobj;
32761 fail:
32762 return NULL;
32763 }
32764
32765
32766 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32767 PyObject *resultobj = 0;
32768 wxWindow *arg1 = (wxWindow *) 0 ;
32769 bool result;
32770 void *argp1 = 0 ;
32771 int res1 = 0 ;
32772 PyObject *swig_obj[1] ;
32773
32774 if (!args) SWIG_fail;
32775 swig_obj[0] = args;
32776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32777 if (!SWIG_IsOK(res1)) {
32778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32779 }
32780 arg1 = reinterpret_cast< wxWindow * >(argp1);
32781 {
32782 PyThreadState* __tstate = wxPyBeginAllowThreads();
32783 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32784 wxPyEndAllowThreads(__tstate);
32785 if (PyErr_Occurred()) SWIG_fail;
32786 }
32787 {
32788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32789 }
32790 return resultobj;
32791 fail:
32792 return NULL;
32793 }
32794
32795
32796 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32797 PyObject *resultobj = 0;
32798 wxWindow *arg1 = (wxWindow *) 0 ;
32799 void *argp1 = 0 ;
32800 int res1 = 0 ;
32801 PyObject *swig_obj[1] ;
32802
32803 if (!args) SWIG_fail;
32804 swig_obj[0] = args;
32805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32806 if (!SWIG_IsOK(res1)) {
32807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32808 }
32809 arg1 = reinterpret_cast< wxWindow * >(argp1);
32810 {
32811 PyThreadState* __tstate = wxPyBeginAllowThreads();
32812 (arg1)->SetFocus();
32813 wxPyEndAllowThreads(__tstate);
32814 if (PyErr_Occurred()) SWIG_fail;
32815 }
32816 resultobj = SWIG_Py_Void();
32817 return resultobj;
32818 fail:
32819 return NULL;
32820 }
32821
32822
32823 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32824 PyObject *resultobj = 0;
32825 wxWindow *arg1 = (wxWindow *) 0 ;
32826 void *argp1 = 0 ;
32827 int res1 = 0 ;
32828 PyObject *swig_obj[1] ;
32829
32830 if (!args) SWIG_fail;
32831 swig_obj[0] = args;
32832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32833 if (!SWIG_IsOK(res1)) {
32834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32835 }
32836 arg1 = reinterpret_cast< wxWindow * >(argp1);
32837 {
32838 PyThreadState* __tstate = wxPyBeginAllowThreads();
32839 (arg1)->SetFocusFromKbd();
32840 wxPyEndAllowThreads(__tstate);
32841 if (PyErr_Occurred()) SWIG_fail;
32842 }
32843 resultobj = SWIG_Py_Void();
32844 return resultobj;
32845 fail:
32846 return NULL;
32847 }
32848
32849
32850 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32851 PyObject *resultobj = 0;
32852 wxWindow *result = 0 ;
32853
32854 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32855 {
32856 if (!wxPyCheckForApp()) SWIG_fail;
32857 PyThreadState* __tstate = wxPyBeginAllowThreads();
32858 result = (wxWindow *)wxWindow::FindFocus();
32859 wxPyEndAllowThreads(__tstate);
32860 if (PyErr_Occurred()) SWIG_fail;
32861 }
32862 {
32863 resultobj = wxPyMake_wxObject(result, 0);
32864 }
32865 return resultobj;
32866 fail:
32867 return NULL;
32868 }
32869
32870
32871 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32872 PyObject *resultobj = 0;
32873 wxWindow *arg1 = (wxWindow *) 0 ;
32874 bool result;
32875 void *argp1 = 0 ;
32876 int res1 = 0 ;
32877 PyObject *swig_obj[1] ;
32878
32879 if (!args) SWIG_fail;
32880 swig_obj[0] = args;
32881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32882 if (!SWIG_IsOK(res1)) {
32883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32884 }
32885 arg1 = reinterpret_cast< wxWindow * >(argp1);
32886 {
32887 PyThreadState* __tstate = wxPyBeginAllowThreads();
32888 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32889 wxPyEndAllowThreads(__tstate);
32890 if (PyErr_Occurred()) SWIG_fail;
32891 }
32892 {
32893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32894 }
32895 return resultobj;
32896 fail:
32897 return NULL;
32898 }
32899
32900
32901 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32902 PyObject *resultobj = 0;
32903 wxWindow *arg1 = (wxWindow *) 0 ;
32904 bool result;
32905 void *argp1 = 0 ;
32906 int res1 = 0 ;
32907 PyObject *swig_obj[1] ;
32908
32909 if (!args) SWIG_fail;
32910 swig_obj[0] = args;
32911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32912 if (!SWIG_IsOK(res1)) {
32913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32914 }
32915 arg1 = reinterpret_cast< wxWindow * >(argp1);
32916 {
32917 PyThreadState* __tstate = wxPyBeginAllowThreads();
32918 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32919 wxPyEndAllowThreads(__tstate);
32920 if (PyErr_Occurred()) SWIG_fail;
32921 }
32922 {
32923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32924 }
32925 return resultobj;
32926 fail:
32927 return NULL;
32928 }
32929
32930
32931 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32932 PyObject *resultobj = 0;
32933 wxWindow *arg1 = (wxWindow *) 0 ;
32934 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32935 bool result;
32936 void *argp1 = 0 ;
32937 int res1 = 0 ;
32938 int val2 ;
32939 int ecode2 = 0 ;
32940 PyObject * obj0 = 0 ;
32941 PyObject * obj1 = 0 ;
32942 char * kwnames[] = {
32943 (char *) "self",(char *) "flags", NULL
32944 };
32945
32946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32948 if (!SWIG_IsOK(res1)) {
32949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32950 }
32951 arg1 = reinterpret_cast< wxWindow * >(argp1);
32952 if (obj1) {
32953 ecode2 = SWIG_AsVal_int(obj1, &val2);
32954 if (!SWIG_IsOK(ecode2)) {
32955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32956 }
32957 arg2 = static_cast< int >(val2);
32958 }
32959 {
32960 PyThreadState* __tstate = wxPyBeginAllowThreads();
32961 result = (bool)(arg1)->Navigate(arg2);
32962 wxPyEndAllowThreads(__tstate);
32963 if (PyErr_Occurred()) SWIG_fail;
32964 }
32965 {
32966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32967 }
32968 return resultobj;
32969 fail:
32970 return NULL;
32971 }
32972
32973
32974 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32975 PyObject *resultobj = 0;
32976 wxWindow *arg1 = (wxWindow *) 0 ;
32977 wxWindow *arg2 = (wxWindow *) 0 ;
32978 void *argp1 = 0 ;
32979 int res1 = 0 ;
32980 void *argp2 = 0 ;
32981 int res2 = 0 ;
32982 PyObject * obj0 = 0 ;
32983 PyObject * obj1 = 0 ;
32984 char * kwnames[] = {
32985 (char *) "self",(char *) "win", NULL
32986 };
32987
32988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32990 if (!SWIG_IsOK(res1)) {
32991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32992 }
32993 arg1 = reinterpret_cast< wxWindow * >(argp1);
32994 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32995 if (!SWIG_IsOK(res2)) {
32996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32997 }
32998 arg2 = reinterpret_cast< wxWindow * >(argp2);
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 (arg1)->MoveAfterInTabOrder(arg2);
33002 wxPyEndAllowThreads(__tstate);
33003 if (PyErr_Occurred()) SWIG_fail;
33004 }
33005 resultobj = SWIG_Py_Void();
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33013 PyObject *resultobj = 0;
33014 wxWindow *arg1 = (wxWindow *) 0 ;
33015 wxWindow *arg2 = (wxWindow *) 0 ;
33016 void *argp1 = 0 ;
33017 int res1 = 0 ;
33018 void *argp2 = 0 ;
33019 int res2 = 0 ;
33020 PyObject * obj0 = 0 ;
33021 PyObject * obj1 = 0 ;
33022 char * kwnames[] = {
33023 (char *) "self",(char *) "win", NULL
33024 };
33025
33026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33028 if (!SWIG_IsOK(res1)) {
33029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33030 }
33031 arg1 = reinterpret_cast< wxWindow * >(argp1);
33032 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33033 if (!SWIG_IsOK(res2)) {
33034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33035 }
33036 arg2 = reinterpret_cast< wxWindow * >(argp2);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 (arg1)->MoveBeforeInTabOrder(arg2);
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 resultobj = SWIG_Py_Void();
33044 return resultobj;
33045 fail:
33046 return NULL;
33047 }
33048
33049
33050 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33051 PyObject *resultobj = 0;
33052 wxWindow *arg1 = (wxWindow *) 0 ;
33053 PyObject *result = 0 ;
33054 void *argp1 = 0 ;
33055 int res1 = 0 ;
33056 PyObject *swig_obj[1] ;
33057
33058 if (!args) SWIG_fail;
33059 swig_obj[0] = args;
33060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33061 if (!SWIG_IsOK(res1)) {
33062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33063 }
33064 arg1 = reinterpret_cast< wxWindow * >(argp1);
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 result = (PyObject *)wxWindow_GetChildren(arg1);
33068 wxPyEndAllowThreads(__tstate);
33069 if (PyErr_Occurred()) SWIG_fail;
33070 }
33071 resultobj = result;
33072 return resultobj;
33073 fail:
33074 return NULL;
33075 }
33076
33077
33078 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33079 PyObject *resultobj = 0;
33080 wxWindow *arg1 = (wxWindow *) 0 ;
33081 wxWindow *result = 0 ;
33082 void *argp1 = 0 ;
33083 int res1 = 0 ;
33084 PyObject *swig_obj[1] ;
33085
33086 if (!args) SWIG_fail;
33087 swig_obj[0] = args;
33088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33089 if (!SWIG_IsOK(res1)) {
33090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33091 }
33092 arg1 = reinterpret_cast< wxWindow * >(argp1);
33093 {
33094 PyThreadState* __tstate = wxPyBeginAllowThreads();
33095 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33096 wxPyEndAllowThreads(__tstate);
33097 if (PyErr_Occurred()) SWIG_fail;
33098 }
33099 {
33100 resultobj = wxPyMake_wxObject(result, 0);
33101 }
33102 return resultobj;
33103 fail:
33104 return NULL;
33105 }
33106
33107
33108 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33109 PyObject *resultobj = 0;
33110 wxWindow *arg1 = (wxWindow *) 0 ;
33111 wxWindow *result = 0 ;
33112 void *argp1 = 0 ;
33113 int res1 = 0 ;
33114 PyObject *swig_obj[1] ;
33115
33116 if (!args) SWIG_fail;
33117 swig_obj[0] = args;
33118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33119 if (!SWIG_IsOK(res1)) {
33120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33121 }
33122 arg1 = reinterpret_cast< wxWindow * >(argp1);
33123 {
33124 PyThreadState* __tstate = wxPyBeginAllowThreads();
33125 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33126 wxPyEndAllowThreads(__tstate);
33127 if (PyErr_Occurred()) SWIG_fail;
33128 }
33129 {
33130 resultobj = wxPyMake_wxObject(result, 0);
33131 }
33132 return resultobj;
33133 fail:
33134 return NULL;
33135 }
33136
33137
33138 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33139 PyObject *resultobj = 0;
33140 wxWindow *arg1 = (wxWindow *) 0 ;
33141 bool result;
33142 void *argp1 = 0 ;
33143 int res1 = 0 ;
33144 PyObject *swig_obj[1] ;
33145
33146 if (!args) SWIG_fail;
33147 swig_obj[0] = args;
33148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33149 if (!SWIG_IsOK(res1)) {
33150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33151 }
33152 arg1 = reinterpret_cast< wxWindow * >(argp1);
33153 {
33154 PyThreadState* __tstate = wxPyBeginAllowThreads();
33155 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33156 wxPyEndAllowThreads(__tstate);
33157 if (PyErr_Occurred()) SWIG_fail;
33158 }
33159 {
33160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33161 }
33162 return resultobj;
33163 fail:
33164 return NULL;
33165 }
33166
33167
33168 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33169 PyObject *resultobj = 0;
33170 wxWindow *arg1 = (wxWindow *) 0 ;
33171 wxWindow *arg2 = (wxWindow *) 0 ;
33172 bool result;
33173 void *argp1 = 0 ;
33174 int res1 = 0 ;
33175 void *argp2 = 0 ;
33176 int res2 = 0 ;
33177 PyObject * obj0 = 0 ;
33178 PyObject * obj1 = 0 ;
33179 char * kwnames[] = {
33180 (char *) "self",(char *) "newParent", NULL
33181 };
33182
33183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33185 if (!SWIG_IsOK(res1)) {
33186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33187 }
33188 arg1 = reinterpret_cast< wxWindow * >(argp1);
33189 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33190 if (!SWIG_IsOK(res2)) {
33191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33192 }
33193 arg2 = reinterpret_cast< wxWindow * >(argp2);
33194 {
33195 PyThreadState* __tstate = wxPyBeginAllowThreads();
33196 result = (bool)(arg1)->Reparent(arg2);
33197 wxPyEndAllowThreads(__tstate);
33198 if (PyErr_Occurred()) SWIG_fail;
33199 }
33200 {
33201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33202 }
33203 return resultobj;
33204 fail:
33205 return NULL;
33206 }
33207
33208
33209 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33210 PyObject *resultobj = 0;
33211 wxWindow *arg1 = (wxWindow *) 0 ;
33212 wxWindow *arg2 = (wxWindow *) 0 ;
33213 void *argp1 = 0 ;
33214 int res1 = 0 ;
33215 void *argp2 = 0 ;
33216 int res2 = 0 ;
33217 PyObject * obj0 = 0 ;
33218 PyObject * obj1 = 0 ;
33219 char * kwnames[] = {
33220 (char *) "self",(char *) "child", NULL
33221 };
33222
33223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33225 if (!SWIG_IsOK(res1)) {
33226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33227 }
33228 arg1 = reinterpret_cast< wxWindow * >(argp1);
33229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33230 if (!SWIG_IsOK(res2)) {
33231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33232 }
33233 arg2 = reinterpret_cast< wxWindow * >(argp2);
33234 {
33235 PyThreadState* __tstate = wxPyBeginAllowThreads();
33236 (arg1)->AddChild(arg2);
33237 wxPyEndAllowThreads(__tstate);
33238 if (PyErr_Occurred()) SWIG_fail;
33239 }
33240 resultobj = SWIG_Py_Void();
33241 return resultobj;
33242 fail:
33243 return NULL;
33244 }
33245
33246
33247 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33248 PyObject *resultobj = 0;
33249 wxWindow *arg1 = (wxWindow *) 0 ;
33250 wxWindow *arg2 = (wxWindow *) 0 ;
33251 void *argp1 = 0 ;
33252 int res1 = 0 ;
33253 void *argp2 = 0 ;
33254 int res2 = 0 ;
33255 PyObject * obj0 = 0 ;
33256 PyObject * obj1 = 0 ;
33257 char * kwnames[] = {
33258 (char *) "self",(char *) "child", NULL
33259 };
33260
33261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33263 if (!SWIG_IsOK(res1)) {
33264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33265 }
33266 arg1 = reinterpret_cast< wxWindow * >(argp1);
33267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33268 if (!SWIG_IsOK(res2)) {
33269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33270 }
33271 arg2 = reinterpret_cast< wxWindow * >(argp2);
33272 {
33273 PyThreadState* __tstate = wxPyBeginAllowThreads();
33274 (arg1)->RemoveChild(arg2);
33275 wxPyEndAllowThreads(__tstate);
33276 if (PyErr_Occurred()) SWIG_fail;
33277 }
33278 resultobj = SWIG_Py_Void();
33279 return resultobj;
33280 fail:
33281 return NULL;
33282 }
33283
33284
33285 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33286 PyObject *resultobj = 0;
33287 wxWindow *arg1 = (wxWindow *) 0 ;
33288 bool arg2 ;
33289 void *argp1 = 0 ;
33290 int res1 = 0 ;
33291 bool val2 ;
33292 int ecode2 = 0 ;
33293 PyObject * obj0 = 0 ;
33294 PyObject * obj1 = 0 ;
33295 char * kwnames[] = {
33296 (char *) "self",(char *) "on", NULL
33297 };
33298
33299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33301 if (!SWIG_IsOK(res1)) {
33302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33303 }
33304 arg1 = reinterpret_cast< wxWindow * >(argp1);
33305 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33306 if (!SWIG_IsOK(ecode2)) {
33307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33308 }
33309 arg2 = static_cast< bool >(val2);
33310 {
33311 PyThreadState* __tstate = wxPyBeginAllowThreads();
33312 (arg1)->SetDoubleBuffered(arg2);
33313 wxPyEndAllowThreads(__tstate);
33314 if (PyErr_Occurred()) SWIG_fail;
33315 }
33316 resultobj = SWIG_Py_Void();
33317 return resultobj;
33318 fail:
33319 return NULL;
33320 }
33321
33322
33323 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33324 PyObject *resultobj = 0;
33325 wxWindow *arg1 = (wxWindow *) 0 ;
33326 long arg2 ;
33327 wxWindow *result = 0 ;
33328 void *argp1 = 0 ;
33329 int res1 = 0 ;
33330 long val2 ;
33331 int ecode2 = 0 ;
33332 PyObject * obj0 = 0 ;
33333 PyObject * obj1 = 0 ;
33334 char * kwnames[] = {
33335 (char *) "self",(char *) "winid", NULL
33336 };
33337
33338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33340 if (!SWIG_IsOK(res1)) {
33341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33342 }
33343 arg1 = reinterpret_cast< wxWindow * >(argp1);
33344 ecode2 = SWIG_AsVal_long(obj1, &val2);
33345 if (!SWIG_IsOK(ecode2)) {
33346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33347 }
33348 arg2 = static_cast< long >(val2);
33349 {
33350 PyThreadState* __tstate = wxPyBeginAllowThreads();
33351 result = (wxWindow *)(arg1)->FindWindow(arg2);
33352 wxPyEndAllowThreads(__tstate);
33353 if (PyErr_Occurred()) SWIG_fail;
33354 }
33355 {
33356 resultobj = wxPyMake_wxObject(result, 0);
33357 }
33358 return resultobj;
33359 fail:
33360 return NULL;
33361 }
33362
33363
33364 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33365 PyObject *resultobj = 0;
33366 wxWindow *arg1 = (wxWindow *) 0 ;
33367 wxString *arg2 = 0 ;
33368 wxWindow *result = 0 ;
33369 void *argp1 = 0 ;
33370 int res1 = 0 ;
33371 bool temp2 = false ;
33372 PyObject * obj0 = 0 ;
33373 PyObject * obj1 = 0 ;
33374 char * kwnames[] = {
33375 (char *) "self",(char *) "name", NULL
33376 };
33377
33378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33380 if (!SWIG_IsOK(res1)) {
33381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33382 }
33383 arg1 = reinterpret_cast< wxWindow * >(argp1);
33384 {
33385 arg2 = wxString_in_helper(obj1);
33386 if (arg2 == NULL) SWIG_fail;
33387 temp2 = true;
33388 }
33389 {
33390 PyThreadState* __tstate = wxPyBeginAllowThreads();
33391 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33392 wxPyEndAllowThreads(__tstate);
33393 if (PyErr_Occurred()) SWIG_fail;
33394 }
33395 {
33396 resultobj = wxPyMake_wxObject(result, 0);
33397 }
33398 {
33399 if (temp2)
33400 delete arg2;
33401 }
33402 return resultobj;
33403 fail:
33404 {
33405 if (temp2)
33406 delete arg2;
33407 }
33408 return NULL;
33409 }
33410
33411
33412 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33413 PyObject *resultobj = 0;
33414 wxWindow *arg1 = (wxWindow *) 0 ;
33415 wxEvtHandler *result = 0 ;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 PyObject *swig_obj[1] ;
33419
33420 if (!args) SWIG_fail;
33421 swig_obj[0] = args;
33422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33423 if (!SWIG_IsOK(res1)) {
33424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33425 }
33426 arg1 = reinterpret_cast< wxWindow * >(argp1);
33427 {
33428 PyThreadState* __tstate = wxPyBeginAllowThreads();
33429 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33430 wxPyEndAllowThreads(__tstate);
33431 if (PyErr_Occurred()) SWIG_fail;
33432 }
33433 {
33434 resultobj = wxPyMake_wxObject(result, 0);
33435 }
33436 return resultobj;
33437 fail:
33438 return NULL;
33439 }
33440
33441
33442 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33443 PyObject *resultobj = 0;
33444 wxWindow *arg1 = (wxWindow *) 0 ;
33445 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33446 void *argp1 = 0 ;
33447 int res1 = 0 ;
33448 void *argp2 = 0 ;
33449 int res2 = 0 ;
33450 PyObject * obj0 = 0 ;
33451 PyObject * obj1 = 0 ;
33452 char * kwnames[] = {
33453 (char *) "self",(char *) "handler", NULL
33454 };
33455
33456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33458 if (!SWIG_IsOK(res1)) {
33459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33460 }
33461 arg1 = reinterpret_cast< wxWindow * >(argp1);
33462 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33463 if (!SWIG_IsOK(res2)) {
33464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33465 }
33466 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33467 {
33468 PyThreadState* __tstate = wxPyBeginAllowThreads();
33469 (arg1)->SetEventHandler(arg2);
33470 wxPyEndAllowThreads(__tstate);
33471 if (PyErr_Occurred()) SWIG_fail;
33472 }
33473 resultobj = SWIG_Py_Void();
33474 return resultobj;
33475 fail:
33476 return NULL;
33477 }
33478
33479
33480 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33481 PyObject *resultobj = 0;
33482 wxWindow *arg1 = (wxWindow *) 0 ;
33483 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33484 void *argp1 = 0 ;
33485 int res1 = 0 ;
33486 void *argp2 = 0 ;
33487 int res2 = 0 ;
33488 PyObject * obj0 = 0 ;
33489 PyObject * obj1 = 0 ;
33490 char * kwnames[] = {
33491 (char *) "self",(char *) "handler", NULL
33492 };
33493
33494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33496 if (!SWIG_IsOK(res1)) {
33497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33498 }
33499 arg1 = reinterpret_cast< wxWindow * >(argp1);
33500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33501 if (!SWIG_IsOK(res2)) {
33502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33503 }
33504 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33505 {
33506 PyThreadState* __tstate = wxPyBeginAllowThreads();
33507 (arg1)->PushEventHandler(arg2);
33508 wxPyEndAllowThreads(__tstate);
33509 if (PyErr_Occurred()) SWIG_fail;
33510 }
33511 resultobj = SWIG_Py_Void();
33512 return resultobj;
33513 fail:
33514 return NULL;
33515 }
33516
33517
33518 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33519 PyObject *resultobj = 0;
33520 wxWindow *arg1 = (wxWindow *) 0 ;
33521 bool arg2 = (bool) false ;
33522 wxEvtHandler *result = 0 ;
33523 void *argp1 = 0 ;
33524 int res1 = 0 ;
33525 bool val2 ;
33526 int ecode2 = 0 ;
33527 PyObject * obj0 = 0 ;
33528 PyObject * obj1 = 0 ;
33529 char * kwnames[] = {
33530 (char *) "self",(char *) "deleteHandler", NULL
33531 };
33532
33533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33535 if (!SWIG_IsOK(res1)) {
33536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33537 }
33538 arg1 = reinterpret_cast< wxWindow * >(argp1);
33539 if (obj1) {
33540 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33541 if (!SWIG_IsOK(ecode2)) {
33542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33543 }
33544 arg2 = static_cast< bool >(val2);
33545 }
33546 {
33547 PyThreadState* __tstate = wxPyBeginAllowThreads();
33548 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 {
33553 resultobj = wxPyMake_wxObject(result, 0);
33554 }
33555 return resultobj;
33556 fail:
33557 return NULL;
33558 }
33559
33560
33561 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33562 PyObject *resultobj = 0;
33563 wxWindow *arg1 = (wxWindow *) 0 ;
33564 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33565 bool result;
33566 void *argp1 = 0 ;
33567 int res1 = 0 ;
33568 void *argp2 = 0 ;
33569 int res2 = 0 ;
33570 PyObject * obj0 = 0 ;
33571 PyObject * obj1 = 0 ;
33572 char * kwnames[] = {
33573 (char *) "self",(char *) "handler", NULL
33574 };
33575
33576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33578 if (!SWIG_IsOK(res1)) {
33579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33580 }
33581 arg1 = reinterpret_cast< wxWindow * >(argp1);
33582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33583 if (!SWIG_IsOK(res2)) {
33584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33585 }
33586 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33587 {
33588 PyThreadState* __tstate = wxPyBeginAllowThreads();
33589 result = (bool)(arg1)->RemoveEventHandler(arg2);
33590 wxPyEndAllowThreads(__tstate);
33591 if (PyErr_Occurred()) SWIG_fail;
33592 }
33593 {
33594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33595 }
33596 return resultobj;
33597 fail:
33598 return NULL;
33599 }
33600
33601
33602 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33603 PyObject *resultobj = 0;
33604 wxWindow *arg1 = (wxWindow *) 0 ;
33605 wxValidator *arg2 = 0 ;
33606 void *argp1 = 0 ;
33607 int res1 = 0 ;
33608 void *argp2 = 0 ;
33609 int res2 = 0 ;
33610 PyObject * obj0 = 0 ;
33611 PyObject * obj1 = 0 ;
33612 char * kwnames[] = {
33613 (char *) "self",(char *) "validator", NULL
33614 };
33615
33616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33618 if (!SWIG_IsOK(res1)) {
33619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33620 }
33621 arg1 = reinterpret_cast< wxWindow * >(argp1);
33622 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33623 if (!SWIG_IsOK(res2)) {
33624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33625 }
33626 if (!argp2) {
33627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33628 }
33629 arg2 = reinterpret_cast< wxValidator * >(argp2);
33630 {
33631 PyThreadState* __tstate = wxPyBeginAllowThreads();
33632 (arg1)->SetValidator((wxValidator const &)*arg2);
33633 wxPyEndAllowThreads(__tstate);
33634 if (PyErr_Occurred()) SWIG_fail;
33635 }
33636 resultobj = SWIG_Py_Void();
33637 return resultobj;
33638 fail:
33639 return NULL;
33640 }
33641
33642
33643 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33644 PyObject *resultobj = 0;
33645 wxWindow *arg1 = (wxWindow *) 0 ;
33646 wxValidator *result = 0 ;
33647 void *argp1 = 0 ;
33648 int res1 = 0 ;
33649 PyObject *swig_obj[1] ;
33650
33651 if (!args) SWIG_fail;
33652 swig_obj[0] = args;
33653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33654 if (!SWIG_IsOK(res1)) {
33655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33656 }
33657 arg1 = reinterpret_cast< wxWindow * >(argp1);
33658 {
33659 PyThreadState* __tstate = wxPyBeginAllowThreads();
33660 result = (wxValidator *)(arg1)->GetValidator();
33661 wxPyEndAllowThreads(__tstate);
33662 if (PyErr_Occurred()) SWIG_fail;
33663 }
33664 {
33665 resultobj = wxPyMake_wxObject(result, (bool)0);
33666 }
33667 return resultobj;
33668 fail:
33669 return NULL;
33670 }
33671
33672
33673 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33674 PyObject *resultobj = 0;
33675 wxWindow *arg1 = (wxWindow *) 0 ;
33676 bool result;
33677 void *argp1 = 0 ;
33678 int res1 = 0 ;
33679 PyObject *swig_obj[1] ;
33680
33681 if (!args) SWIG_fail;
33682 swig_obj[0] = args;
33683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33684 if (!SWIG_IsOK(res1)) {
33685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33686 }
33687 arg1 = reinterpret_cast< wxWindow * >(argp1);
33688 {
33689 PyThreadState* __tstate = wxPyBeginAllowThreads();
33690 result = (bool)(arg1)->Validate();
33691 wxPyEndAllowThreads(__tstate);
33692 if (PyErr_Occurred()) SWIG_fail;
33693 }
33694 {
33695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33696 }
33697 return resultobj;
33698 fail:
33699 return NULL;
33700 }
33701
33702
33703 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33704 PyObject *resultobj = 0;
33705 wxWindow *arg1 = (wxWindow *) 0 ;
33706 bool result;
33707 void *argp1 = 0 ;
33708 int res1 = 0 ;
33709 PyObject *swig_obj[1] ;
33710
33711 if (!args) SWIG_fail;
33712 swig_obj[0] = args;
33713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33714 if (!SWIG_IsOK(res1)) {
33715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33716 }
33717 arg1 = reinterpret_cast< wxWindow * >(argp1);
33718 {
33719 PyThreadState* __tstate = wxPyBeginAllowThreads();
33720 result = (bool)(arg1)->TransferDataToWindow();
33721 wxPyEndAllowThreads(__tstate);
33722 if (PyErr_Occurred()) SWIG_fail;
33723 }
33724 {
33725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33726 }
33727 return resultobj;
33728 fail:
33729 return NULL;
33730 }
33731
33732
33733 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33734 PyObject *resultobj = 0;
33735 wxWindow *arg1 = (wxWindow *) 0 ;
33736 bool result;
33737 void *argp1 = 0 ;
33738 int res1 = 0 ;
33739 PyObject *swig_obj[1] ;
33740
33741 if (!args) SWIG_fail;
33742 swig_obj[0] = args;
33743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33744 if (!SWIG_IsOK(res1)) {
33745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33746 }
33747 arg1 = reinterpret_cast< wxWindow * >(argp1);
33748 {
33749 PyThreadState* __tstate = wxPyBeginAllowThreads();
33750 result = (bool)(arg1)->TransferDataFromWindow();
33751 wxPyEndAllowThreads(__tstate);
33752 if (PyErr_Occurred()) SWIG_fail;
33753 }
33754 {
33755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33756 }
33757 return resultobj;
33758 fail:
33759 return NULL;
33760 }
33761
33762
33763 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33764 PyObject *resultobj = 0;
33765 wxWindow *arg1 = (wxWindow *) 0 ;
33766 void *argp1 = 0 ;
33767 int res1 = 0 ;
33768 PyObject *swig_obj[1] ;
33769
33770 if (!args) SWIG_fail;
33771 swig_obj[0] = args;
33772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33773 if (!SWIG_IsOK(res1)) {
33774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33775 }
33776 arg1 = reinterpret_cast< wxWindow * >(argp1);
33777 {
33778 PyThreadState* __tstate = wxPyBeginAllowThreads();
33779 (arg1)->InitDialog();
33780 wxPyEndAllowThreads(__tstate);
33781 if (PyErr_Occurred()) SWIG_fail;
33782 }
33783 resultobj = SWIG_Py_Void();
33784 return resultobj;
33785 fail:
33786 return NULL;
33787 }
33788
33789
33790 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33791 PyObject *resultobj = 0;
33792 wxWindow *arg1 = (wxWindow *) 0 ;
33793 wxAcceleratorTable *arg2 = 0 ;
33794 void *argp1 = 0 ;
33795 int res1 = 0 ;
33796 void *argp2 = 0 ;
33797 int res2 = 0 ;
33798 PyObject * obj0 = 0 ;
33799 PyObject * obj1 = 0 ;
33800 char * kwnames[] = {
33801 (char *) "self",(char *) "accel", NULL
33802 };
33803
33804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33806 if (!SWIG_IsOK(res1)) {
33807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33808 }
33809 arg1 = reinterpret_cast< wxWindow * >(argp1);
33810 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33811 if (!SWIG_IsOK(res2)) {
33812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33813 }
33814 if (!argp2) {
33815 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33816 }
33817 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33818 {
33819 PyThreadState* __tstate = wxPyBeginAllowThreads();
33820 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33821 wxPyEndAllowThreads(__tstate);
33822 if (PyErr_Occurred()) SWIG_fail;
33823 }
33824 resultobj = SWIG_Py_Void();
33825 return resultobj;
33826 fail:
33827 return NULL;
33828 }
33829
33830
33831 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33832 PyObject *resultobj = 0;
33833 wxWindow *arg1 = (wxWindow *) 0 ;
33834 wxAcceleratorTable *result = 0 ;
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_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33844 }
33845 arg1 = reinterpret_cast< wxWindow * >(argp1);
33846 {
33847 PyThreadState* __tstate = wxPyBeginAllowThreads();
33848 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33849 wxPyEndAllowThreads(__tstate);
33850 if (PyErr_Occurred()) SWIG_fail;
33851 }
33852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33853 return resultobj;
33854 fail:
33855 return NULL;
33856 }
33857
33858
33859 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33860 PyObject *resultobj = 0;
33861 wxWindow *arg1 = (wxWindow *) 0 ;
33862 int arg2 ;
33863 int arg3 ;
33864 int arg4 ;
33865 bool result;
33866 void *argp1 = 0 ;
33867 int res1 = 0 ;
33868 int val2 ;
33869 int ecode2 = 0 ;
33870 int val3 ;
33871 int ecode3 = 0 ;
33872 int val4 ;
33873 int ecode4 = 0 ;
33874 PyObject * obj0 = 0 ;
33875 PyObject * obj1 = 0 ;
33876 PyObject * obj2 = 0 ;
33877 PyObject * obj3 = 0 ;
33878 char * kwnames[] = {
33879 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33880 };
33881
33882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33884 if (!SWIG_IsOK(res1)) {
33885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33886 }
33887 arg1 = reinterpret_cast< wxWindow * >(argp1);
33888 ecode2 = SWIG_AsVal_int(obj1, &val2);
33889 if (!SWIG_IsOK(ecode2)) {
33890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33891 }
33892 arg2 = static_cast< int >(val2);
33893 ecode3 = SWIG_AsVal_int(obj2, &val3);
33894 if (!SWIG_IsOK(ecode3)) {
33895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33896 }
33897 arg3 = static_cast< int >(val3);
33898 ecode4 = SWIG_AsVal_int(obj3, &val4);
33899 if (!SWIG_IsOK(ecode4)) {
33900 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33901 }
33902 arg4 = static_cast< int >(val4);
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 {
33910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33911 }
33912 return resultobj;
33913 fail:
33914 return NULL;
33915 }
33916
33917
33918 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33919 PyObject *resultobj = 0;
33920 wxWindow *arg1 = (wxWindow *) 0 ;
33921 int arg2 ;
33922 bool result;
33923 void *argp1 = 0 ;
33924 int res1 = 0 ;
33925 int val2 ;
33926 int ecode2 = 0 ;
33927 PyObject * obj0 = 0 ;
33928 PyObject * obj1 = 0 ;
33929 char * kwnames[] = {
33930 (char *) "self",(char *) "hotkeyId", NULL
33931 };
33932
33933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33935 if (!SWIG_IsOK(res1)) {
33936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33937 }
33938 arg1 = reinterpret_cast< wxWindow * >(argp1);
33939 ecode2 = SWIG_AsVal_int(obj1, &val2);
33940 if (!SWIG_IsOK(ecode2)) {
33941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33942 }
33943 arg2 = static_cast< int >(val2);
33944 {
33945 PyThreadState* __tstate = wxPyBeginAllowThreads();
33946 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33947 wxPyEndAllowThreads(__tstate);
33948 if (PyErr_Occurred()) SWIG_fail;
33949 }
33950 {
33951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33952 }
33953 return resultobj;
33954 fail:
33955 return NULL;
33956 }
33957
33958
33959 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33960 PyObject *resultobj = 0;
33961 wxWindow *arg1 = (wxWindow *) 0 ;
33962 wxPoint *arg2 = 0 ;
33963 wxPoint result;
33964 void *argp1 = 0 ;
33965 int res1 = 0 ;
33966 wxPoint temp2 ;
33967 PyObject * obj0 = 0 ;
33968 PyObject * obj1 = 0 ;
33969 char * kwnames[] = {
33970 (char *) "self",(char *) "pt", NULL
33971 };
33972
33973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33975 if (!SWIG_IsOK(res1)) {
33976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33977 }
33978 arg1 = reinterpret_cast< wxWindow * >(argp1);
33979 {
33980 arg2 = &temp2;
33981 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33982 }
33983 {
33984 PyThreadState* __tstate = wxPyBeginAllowThreads();
33985 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33986 wxPyEndAllowThreads(__tstate);
33987 if (PyErr_Occurred()) SWIG_fail;
33988 }
33989 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33997 PyObject *resultobj = 0;
33998 wxWindow *arg1 = (wxWindow *) 0 ;
33999 wxSize *arg2 = 0 ;
34000 wxSize result;
34001 void *argp1 = 0 ;
34002 int res1 = 0 ;
34003 wxSize temp2 ;
34004 PyObject * obj0 = 0 ;
34005 PyObject * obj1 = 0 ;
34006 char * kwnames[] = {
34007 (char *) "self",(char *) "sz", NULL
34008 };
34009
34010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34012 if (!SWIG_IsOK(res1)) {
34013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34014 }
34015 arg1 = reinterpret_cast< wxWindow * >(argp1);
34016 {
34017 arg2 = &temp2;
34018 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34019 }
34020 {
34021 PyThreadState* __tstate = wxPyBeginAllowThreads();
34022 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34023 wxPyEndAllowThreads(__tstate);
34024 if (PyErr_Occurred()) SWIG_fail;
34025 }
34026 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34034 PyObject *resultobj = 0;
34035 wxWindow *arg1 = (wxWindow *) 0 ;
34036 wxPoint *arg2 = 0 ;
34037 wxPoint result;
34038 void *argp1 = 0 ;
34039 int res1 = 0 ;
34040 wxPoint temp2 ;
34041 PyObject * obj0 = 0 ;
34042 PyObject * obj1 = 0 ;
34043 char * kwnames[] = {
34044 (char *) "self",(char *) "pt", NULL
34045 };
34046
34047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34049 if (!SWIG_IsOK(res1)) {
34050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34051 }
34052 arg1 = reinterpret_cast< wxWindow * >(argp1);
34053 {
34054 arg2 = &temp2;
34055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34056 }
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34064 return resultobj;
34065 fail:
34066 return NULL;
34067 }
34068
34069
34070 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj = 0;
34072 wxWindow *arg1 = (wxWindow *) 0 ;
34073 wxSize *arg2 = 0 ;
34074 wxSize result;
34075 void *argp1 = 0 ;
34076 int res1 = 0 ;
34077 wxSize temp2 ;
34078 PyObject * obj0 = 0 ;
34079 PyObject * obj1 = 0 ;
34080 char * kwnames[] = {
34081 (char *) "self",(char *) "sz", NULL
34082 };
34083
34084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34088 }
34089 arg1 = reinterpret_cast< wxWindow * >(argp1);
34090 {
34091 arg2 = &temp2;
34092 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34093 }
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 wxPoint *arg2 = 0 ;
34111 wxPoint result;
34112 void *argp1 = 0 ;
34113 int res1 = 0 ;
34114 wxPoint temp2 ;
34115 PyObject * obj0 = 0 ;
34116 PyObject * obj1 = 0 ;
34117 char * kwnames[] = {
34118 (char *) "self",(char *) "pt", NULL
34119 };
34120
34121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34123 if (!SWIG_IsOK(res1)) {
34124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34125 }
34126 arg1 = reinterpret_cast< wxWindow * >(argp1);
34127 {
34128 arg2 = &temp2;
34129 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34130 }
34131 {
34132 PyThreadState* __tstate = wxPyBeginAllowThreads();
34133 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34134 wxPyEndAllowThreads(__tstate);
34135 if (PyErr_Occurred()) SWIG_fail;
34136 }
34137 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34138 return resultobj;
34139 fail:
34140 return NULL;
34141 }
34142
34143
34144 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34145 PyObject *resultobj = 0;
34146 wxWindow *arg1 = (wxWindow *) 0 ;
34147 wxSize *arg2 = 0 ;
34148 wxSize result;
34149 void *argp1 = 0 ;
34150 int res1 = 0 ;
34151 wxSize temp2 ;
34152 PyObject * obj0 = 0 ;
34153 PyObject * obj1 = 0 ;
34154 char * kwnames[] = {
34155 (char *) "self",(char *) "sz", NULL
34156 };
34157
34158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34160 if (!SWIG_IsOK(res1)) {
34161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34162 }
34163 arg1 = reinterpret_cast< wxWindow * >(argp1);
34164 {
34165 arg2 = &temp2;
34166 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34167 }
34168 {
34169 PyThreadState* __tstate = wxPyBeginAllowThreads();
34170 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34171 wxPyEndAllowThreads(__tstate);
34172 if (PyErr_Occurred()) SWIG_fail;
34173 }
34174 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34175 return resultobj;
34176 fail:
34177 return NULL;
34178 }
34179
34180
34181 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34182 PyObject *resultobj = 0;
34183 wxWindow *arg1 = (wxWindow *) 0 ;
34184 int arg2 ;
34185 int arg3 ;
34186 void *argp1 = 0 ;
34187 int res1 = 0 ;
34188 int val2 ;
34189 int ecode2 = 0 ;
34190 int val3 ;
34191 int ecode3 = 0 ;
34192 PyObject * obj0 = 0 ;
34193 PyObject * obj1 = 0 ;
34194 PyObject * obj2 = 0 ;
34195 char * kwnames[] = {
34196 (char *) "self",(char *) "x",(char *) "y", NULL
34197 };
34198
34199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34201 if (!SWIG_IsOK(res1)) {
34202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34203 }
34204 arg1 = reinterpret_cast< wxWindow * >(argp1);
34205 ecode2 = SWIG_AsVal_int(obj1, &val2);
34206 if (!SWIG_IsOK(ecode2)) {
34207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34208 }
34209 arg2 = static_cast< int >(val2);
34210 ecode3 = SWIG_AsVal_int(obj2, &val3);
34211 if (!SWIG_IsOK(ecode3)) {
34212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34213 }
34214 arg3 = static_cast< int >(val3);
34215 {
34216 PyThreadState* __tstate = wxPyBeginAllowThreads();
34217 (arg1)->WarpPointer(arg2,arg3);
34218 wxPyEndAllowThreads(__tstate);
34219 if (PyErr_Occurred()) SWIG_fail;
34220 }
34221 resultobj = SWIG_Py_Void();
34222 return resultobj;
34223 fail:
34224 return NULL;
34225 }
34226
34227
34228 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34229 PyObject *resultobj = 0;
34230 wxWindow *arg1 = (wxWindow *) 0 ;
34231 void *argp1 = 0 ;
34232 int res1 = 0 ;
34233 PyObject *swig_obj[1] ;
34234
34235 if (!args) SWIG_fail;
34236 swig_obj[0] = args;
34237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34238 if (!SWIG_IsOK(res1)) {
34239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34240 }
34241 arg1 = reinterpret_cast< wxWindow * >(argp1);
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 (arg1)->CaptureMouse();
34245 wxPyEndAllowThreads(__tstate);
34246 if (PyErr_Occurred()) SWIG_fail;
34247 }
34248 resultobj = SWIG_Py_Void();
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34256 PyObject *resultobj = 0;
34257 wxWindow *arg1 = (wxWindow *) 0 ;
34258 void *argp1 = 0 ;
34259 int res1 = 0 ;
34260 PyObject *swig_obj[1] ;
34261
34262 if (!args) SWIG_fail;
34263 swig_obj[0] = args;
34264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34265 if (!SWIG_IsOK(res1)) {
34266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34267 }
34268 arg1 = reinterpret_cast< wxWindow * >(argp1);
34269 {
34270 PyThreadState* __tstate = wxPyBeginAllowThreads();
34271 (arg1)->ReleaseMouse();
34272 wxPyEndAllowThreads(__tstate);
34273 if (PyErr_Occurred()) SWIG_fail;
34274 }
34275 resultobj = SWIG_Py_Void();
34276 return resultobj;
34277 fail:
34278 return NULL;
34279 }
34280
34281
34282 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34283 PyObject *resultobj = 0;
34284 wxWindow *result = 0 ;
34285
34286 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34287 {
34288 if (!wxPyCheckForApp()) SWIG_fail;
34289 PyThreadState* __tstate = wxPyBeginAllowThreads();
34290 result = (wxWindow *)wxWindow::GetCapture();
34291 wxPyEndAllowThreads(__tstate);
34292 if (PyErr_Occurred()) SWIG_fail;
34293 }
34294 {
34295 resultobj = wxPyMake_wxObject(result, 0);
34296 }
34297 return resultobj;
34298 fail:
34299 return NULL;
34300 }
34301
34302
34303 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34304 PyObject *resultobj = 0;
34305 wxWindow *arg1 = (wxWindow *) 0 ;
34306 bool result;
34307 void *argp1 = 0 ;
34308 int res1 = 0 ;
34309 PyObject *swig_obj[1] ;
34310
34311 if (!args) SWIG_fail;
34312 swig_obj[0] = args;
34313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34314 if (!SWIG_IsOK(res1)) {
34315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34316 }
34317 arg1 = reinterpret_cast< wxWindow * >(argp1);
34318 {
34319 PyThreadState* __tstate = wxPyBeginAllowThreads();
34320 result = (bool)((wxWindow const *)arg1)->HasCapture();
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 {
34325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34326 }
34327 return resultobj;
34328 fail:
34329 return NULL;
34330 }
34331
34332
34333 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34334 PyObject *resultobj = 0;
34335 wxWindow *arg1 = (wxWindow *) 0 ;
34336 bool arg2 = (bool) true ;
34337 wxRect *arg3 = (wxRect *) NULL ;
34338 void *argp1 = 0 ;
34339 int res1 = 0 ;
34340 bool val2 ;
34341 int ecode2 = 0 ;
34342 void *argp3 = 0 ;
34343 int res3 = 0 ;
34344 PyObject * obj0 = 0 ;
34345 PyObject * obj1 = 0 ;
34346 PyObject * obj2 = 0 ;
34347 char * kwnames[] = {
34348 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34349 };
34350
34351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34353 if (!SWIG_IsOK(res1)) {
34354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34355 }
34356 arg1 = reinterpret_cast< wxWindow * >(argp1);
34357 if (obj1) {
34358 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34359 if (!SWIG_IsOK(ecode2)) {
34360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34361 }
34362 arg2 = static_cast< bool >(val2);
34363 }
34364 if (obj2) {
34365 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34366 if (!SWIG_IsOK(res3)) {
34367 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34368 }
34369 arg3 = reinterpret_cast< wxRect * >(argp3);
34370 }
34371 {
34372 PyThreadState* __tstate = wxPyBeginAllowThreads();
34373 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34374 wxPyEndAllowThreads(__tstate);
34375 if (PyErr_Occurred()) SWIG_fail;
34376 }
34377 resultobj = SWIG_Py_Void();
34378 return resultobj;
34379 fail:
34380 return NULL;
34381 }
34382
34383
34384 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34385 PyObject *resultobj = 0;
34386 wxWindow *arg1 = (wxWindow *) 0 ;
34387 wxRect *arg2 = 0 ;
34388 bool arg3 = (bool) true ;
34389 void *argp1 = 0 ;
34390 int res1 = 0 ;
34391 wxRect temp2 ;
34392 bool val3 ;
34393 int ecode3 = 0 ;
34394 PyObject * obj0 = 0 ;
34395 PyObject * obj1 = 0 ;
34396 PyObject * obj2 = 0 ;
34397 char * kwnames[] = {
34398 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34399 };
34400
34401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34403 if (!SWIG_IsOK(res1)) {
34404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34405 }
34406 arg1 = reinterpret_cast< wxWindow * >(argp1);
34407 {
34408 arg2 = &temp2;
34409 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34410 }
34411 if (obj2) {
34412 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34413 if (!SWIG_IsOK(ecode3)) {
34414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34415 }
34416 arg3 = static_cast< bool >(val3);
34417 }
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_Py_Void();
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 PyObject *resultobj = 0;
34433 wxWindow *arg1 = (wxWindow *) 0 ;
34434 void *argp1 = 0 ;
34435 int res1 = 0 ;
34436 PyObject *swig_obj[1] ;
34437
34438 if (!args) SWIG_fail;
34439 swig_obj[0] = args;
34440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34441 if (!SWIG_IsOK(res1)) {
34442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34443 }
34444 arg1 = reinterpret_cast< wxWindow * >(argp1);
34445 {
34446 PyThreadState* __tstate = wxPyBeginAllowThreads();
34447 (arg1)->Update();
34448 wxPyEndAllowThreads(__tstate);
34449 if (PyErr_Occurred()) SWIG_fail;
34450 }
34451 resultobj = SWIG_Py_Void();
34452 return resultobj;
34453 fail:
34454 return NULL;
34455 }
34456
34457
34458 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34459 PyObject *resultobj = 0;
34460 wxWindow *arg1 = (wxWindow *) 0 ;
34461 void *argp1 = 0 ;
34462 int res1 = 0 ;
34463 PyObject *swig_obj[1] ;
34464
34465 if (!args) SWIG_fail;
34466 swig_obj[0] = args;
34467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34468 if (!SWIG_IsOK(res1)) {
34469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34470 }
34471 arg1 = reinterpret_cast< wxWindow * >(argp1);
34472 {
34473 PyThreadState* __tstate = wxPyBeginAllowThreads();
34474 (arg1)->ClearBackground();
34475 wxPyEndAllowThreads(__tstate);
34476 if (PyErr_Occurred()) SWIG_fail;
34477 }
34478 resultobj = SWIG_Py_Void();
34479 return resultobj;
34480 fail:
34481 return NULL;
34482 }
34483
34484
34485 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34486 PyObject *resultobj = 0;
34487 wxWindow *arg1 = (wxWindow *) 0 ;
34488 void *argp1 = 0 ;
34489 int res1 = 0 ;
34490 PyObject *swig_obj[1] ;
34491
34492 if (!args) SWIG_fail;
34493 swig_obj[0] = args;
34494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34495 if (!SWIG_IsOK(res1)) {
34496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34497 }
34498 arg1 = reinterpret_cast< wxWindow * >(argp1);
34499 {
34500 PyThreadState* __tstate = wxPyBeginAllowThreads();
34501 (arg1)->Freeze();
34502 wxPyEndAllowThreads(__tstate);
34503 if (PyErr_Occurred()) SWIG_fail;
34504 }
34505 resultobj = SWIG_Py_Void();
34506 return resultobj;
34507 fail:
34508 return NULL;
34509 }
34510
34511
34512 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34513 PyObject *resultobj = 0;
34514 wxWindow *arg1 = (wxWindow *) 0 ;
34515 void *argp1 = 0 ;
34516 int res1 = 0 ;
34517 PyObject *swig_obj[1] ;
34518
34519 if (!args) SWIG_fail;
34520 swig_obj[0] = args;
34521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34522 if (!SWIG_IsOK(res1)) {
34523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34524 }
34525 arg1 = reinterpret_cast< wxWindow * >(argp1);
34526 {
34527 PyThreadState* __tstate = wxPyBeginAllowThreads();
34528 (arg1)->Thaw();
34529 wxPyEndAllowThreads(__tstate);
34530 if (PyErr_Occurred()) SWIG_fail;
34531 }
34532 resultobj = SWIG_Py_Void();
34533 return resultobj;
34534 fail:
34535 return NULL;
34536 }
34537
34538
34539 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34540 PyObject *resultobj = 0;
34541 wxWindow *arg1 = (wxWindow *) 0 ;
34542 wxDC *arg2 = 0 ;
34543 void *argp1 = 0 ;
34544 int res1 = 0 ;
34545 void *argp2 = 0 ;
34546 int res2 = 0 ;
34547 PyObject * obj0 = 0 ;
34548 PyObject * obj1 = 0 ;
34549 char * kwnames[] = {
34550 (char *) "self",(char *) "dc", NULL
34551 };
34552
34553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34555 if (!SWIG_IsOK(res1)) {
34556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34557 }
34558 arg1 = reinterpret_cast< wxWindow * >(argp1);
34559 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34560 if (!SWIG_IsOK(res2)) {
34561 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34562 }
34563 if (!argp2) {
34564 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34565 }
34566 arg2 = reinterpret_cast< wxDC * >(argp2);
34567 {
34568 PyThreadState* __tstate = wxPyBeginAllowThreads();
34569 (arg1)->PrepareDC(*arg2);
34570 wxPyEndAllowThreads(__tstate);
34571 if (PyErr_Occurred()) SWIG_fail;
34572 }
34573 resultobj = SWIG_Py_Void();
34574 return resultobj;
34575 fail:
34576 return NULL;
34577 }
34578
34579
34580 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34581 PyObject *resultobj = 0;
34582 wxWindow *arg1 = (wxWindow *) 0 ;
34583 wxRegion *result = 0 ;
34584 void *argp1 = 0 ;
34585 int res1 = 0 ;
34586 PyObject *swig_obj[1] ;
34587
34588 if (!args) SWIG_fail;
34589 swig_obj[0] = args;
34590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34591 if (!SWIG_IsOK(res1)) {
34592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34593 }
34594 arg1 = reinterpret_cast< wxWindow * >(argp1);
34595 {
34596 PyThreadState* __tstate = wxPyBeginAllowThreads();
34597 {
34598 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34599 result = (wxRegion *) &_result_ref;
34600 }
34601 wxPyEndAllowThreads(__tstate);
34602 if (PyErr_Occurred()) SWIG_fail;
34603 }
34604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34605 return resultobj;
34606 fail:
34607 return NULL;
34608 }
34609
34610
34611 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34612 PyObject *resultobj = 0;
34613 wxWindow *arg1 = (wxWindow *) 0 ;
34614 wxRect result;
34615 void *argp1 = 0 ;
34616 int res1 = 0 ;
34617 PyObject *swig_obj[1] ;
34618
34619 if (!args) SWIG_fail;
34620 swig_obj[0] = args;
34621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34622 if (!SWIG_IsOK(res1)) {
34623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34624 }
34625 arg1 = reinterpret_cast< wxWindow * >(argp1);
34626 {
34627 PyThreadState* __tstate = wxPyBeginAllowThreads();
34628 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34629 wxPyEndAllowThreads(__tstate);
34630 if (PyErr_Occurred()) SWIG_fail;
34631 }
34632 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34633 return resultobj;
34634 fail:
34635 return NULL;
34636 }
34637
34638
34639 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34640 PyObject *resultobj = 0;
34641 wxWindow *arg1 = (wxWindow *) 0 ;
34642 int arg2 ;
34643 int arg3 ;
34644 int arg4 = (int) 1 ;
34645 int arg5 = (int) 1 ;
34646 bool result;
34647 void *argp1 = 0 ;
34648 int res1 = 0 ;
34649 int val2 ;
34650 int ecode2 = 0 ;
34651 int val3 ;
34652 int ecode3 = 0 ;
34653 int val4 ;
34654 int ecode4 = 0 ;
34655 int val5 ;
34656 int ecode5 = 0 ;
34657 PyObject * obj0 = 0 ;
34658 PyObject * obj1 = 0 ;
34659 PyObject * obj2 = 0 ;
34660 PyObject * obj3 = 0 ;
34661 PyObject * obj4 = 0 ;
34662 char * kwnames[] = {
34663 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34664 };
34665
34666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34668 if (!SWIG_IsOK(res1)) {
34669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34670 }
34671 arg1 = reinterpret_cast< wxWindow * >(argp1);
34672 ecode2 = SWIG_AsVal_int(obj1, &val2);
34673 if (!SWIG_IsOK(ecode2)) {
34674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34675 }
34676 arg2 = static_cast< int >(val2);
34677 ecode3 = SWIG_AsVal_int(obj2, &val3);
34678 if (!SWIG_IsOK(ecode3)) {
34679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34680 }
34681 arg3 = static_cast< int >(val3);
34682 if (obj3) {
34683 ecode4 = SWIG_AsVal_int(obj3, &val4);
34684 if (!SWIG_IsOK(ecode4)) {
34685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34686 }
34687 arg4 = static_cast< int >(val4);
34688 }
34689 if (obj4) {
34690 ecode5 = SWIG_AsVal_int(obj4, &val5);
34691 if (!SWIG_IsOK(ecode5)) {
34692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34693 }
34694 arg5 = static_cast< int >(val5);
34695 }
34696 {
34697 PyThreadState* __tstate = wxPyBeginAllowThreads();
34698 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34699 wxPyEndAllowThreads(__tstate);
34700 if (PyErr_Occurred()) SWIG_fail;
34701 }
34702 {
34703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34704 }
34705 return resultobj;
34706 fail:
34707 return NULL;
34708 }
34709
34710
34711 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34712 PyObject *resultobj = 0;
34713 wxWindow *arg1 = (wxWindow *) 0 ;
34714 wxPoint *arg2 = 0 ;
34715 bool result;
34716 void *argp1 = 0 ;
34717 int res1 = 0 ;
34718 wxPoint temp2 ;
34719 PyObject * obj0 = 0 ;
34720 PyObject * obj1 = 0 ;
34721 char * kwnames[] = {
34722 (char *) "self",(char *) "pt", NULL
34723 };
34724
34725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34727 if (!SWIG_IsOK(res1)) {
34728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34729 }
34730 arg1 = reinterpret_cast< wxWindow * >(argp1);
34731 {
34732 arg2 = &temp2;
34733 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34734 }
34735 {
34736 PyThreadState* __tstate = wxPyBeginAllowThreads();
34737 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34738 wxPyEndAllowThreads(__tstate);
34739 if (PyErr_Occurred()) SWIG_fail;
34740 }
34741 {
34742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34743 }
34744 return resultobj;
34745 fail:
34746 return NULL;
34747 }
34748
34749
34750 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34751 PyObject *resultobj = 0;
34752 wxWindow *arg1 = (wxWindow *) 0 ;
34753 wxRect *arg2 = 0 ;
34754 bool result;
34755 void *argp1 = 0 ;
34756 int res1 = 0 ;
34757 wxRect temp2 ;
34758 PyObject * obj0 = 0 ;
34759 PyObject * obj1 = 0 ;
34760 char * kwnames[] = {
34761 (char *) "self",(char *) "rect", NULL
34762 };
34763
34764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34766 if (!SWIG_IsOK(res1)) {
34767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34768 }
34769 arg1 = reinterpret_cast< wxWindow * >(argp1);
34770 {
34771 arg2 = &temp2;
34772 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34773 }
34774 {
34775 PyThreadState* __tstate = wxPyBeginAllowThreads();
34776 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34777 wxPyEndAllowThreads(__tstate);
34778 if (PyErr_Occurred()) SWIG_fail;
34779 }
34780 {
34781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34782 }
34783 return resultobj;
34784 fail:
34785 return NULL;
34786 }
34787
34788
34789 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34790 PyObject *resultobj = 0;
34791 wxWindow *arg1 = (wxWindow *) 0 ;
34792 SwigValueWrapper<wxVisualAttributes > result;
34793 void *argp1 = 0 ;
34794 int res1 = 0 ;
34795 PyObject *swig_obj[1] ;
34796
34797 if (!args) SWIG_fail;
34798 swig_obj[0] = args;
34799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34800 if (!SWIG_IsOK(res1)) {
34801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34802 }
34803 arg1 = reinterpret_cast< wxWindow * >(argp1);
34804 {
34805 PyThreadState* __tstate = wxPyBeginAllowThreads();
34806 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34807 wxPyEndAllowThreads(__tstate);
34808 if (PyErr_Occurred()) SWIG_fail;
34809 }
34810 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34811 return resultobj;
34812 fail:
34813 return NULL;
34814 }
34815
34816
34817 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34818 PyObject *resultobj = 0;
34819 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34820 SwigValueWrapper<wxVisualAttributes > result;
34821 int val1 ;
34822 int ecode1 = 0 ;
34823 PyObject * obj0 = 0 ;
34824 char * kwnames[] = {
34825 (char *) "variant", NULL
34826 };
34827
34828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34829 if (obj0) {
34830 ecode1 = SWIG_AsVal_int(obj0, &val1);
34831 if (!SWIG_IsOK(ecode1)) {
34832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34833 }
34834 arg1 = static_cast< wxWindowVariant >(val1);
34835 }
34836 {
34837 if (!wxPyCheckForApp()) SWIG_fail;
34838 PyThreadState* __tstate = wxPyBeginAllowThreads();
34839 result = wxWindow::GetClassDefaultAttributes(arg1);
34840 wxPyEndAllowThreads(__tstate);
34841 if (PyErr_Occurred()) SWIG_fail;
34842 }
34843 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34844 return resultobj;
34845 fail:
34846 return NULL;
34847 }
34848
34849
34850 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34851 PyObject *resultobj = 0;
34852 wxWindow *arg1 = (wxWindow *) 0 ;
34853 wxColour *arg2 = 0 ;
34854 bool result;
34855 void *argp1 = 0 ;
34856 int res1 = 0 ;
34857 wxColour temp2 ;
34858 PyObject * obj0 = 0 ;
34859 PyObject * obj1 = 0 ;
34860 char * kwnames[] = {
34861 (char *) "self",(char *) "colour", NULL
34862 };
34863
34864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34866 if (!SWIG_IsOK(res1)) {
34867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34868 }
34869 arg1 = reinterpret_cast< wxWindow * >(argp1);
34870 {
34871 arg2 = &temp2;
34872 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34873 }
34874 {
34875 PyThreadState* __tstate = wxPyBeginAllowThreads();
34876 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34877 wxPyEndAllowThreads(__tstate);
34878 if (PyErr_Occurred()) SWIG_fail;
34879 }
34880 {
34881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34882 }
34883 return resultobj;
34884 fail:
34885 return NULL;
34886 }
34887
34888
34889 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34890 PyObject *resultobj = 0;
34891 wxWindow *arg1 = (wxWindow *) 0 ;
34892 wxColour *arg2 = 0 ;
34893 void *argp1 = 0 ;
34894 int res1 = 0 ;
34895 wxColour temp2 ;
34896 PyObject * obj0 = 0 ;
34897 PyObject * obj1 = 0 ;
34898 char * kwnames[] = {
34899 (char *) "self",(char *) "colour", NULL
34900 };
34901
34902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34904 if (!SWIG_IsOK(res1)) {
34905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34906 }
34907 arg1 = reinterpret_cast< wxWindow * >(argp1);
34908 {
34909 arg2 = &temp2;
34910 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34911 }
34912 {
34913 PyThreadState* __tstate = wxPyBeginAllowThreads();
34914 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34915 wxPyEndAllowThreads(__tstate);
34916 if (PyErr_Occurred()) SWIG_fail;
34917 }
34918 resultobj = SWIG_Py_Void();
34919 return resultobj;
34920 fail:
34921 return NULL;
34922 }
34923
34924
34925 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34926 PyObject *resultobj = 0;
34927 wxWindow *arg1 = (wxWindow *) 0 ;
34928 wxColour *arg2 = 0 ;
34929 bool result;
34930 void *argp1 = 0 ;
34931 int res1 = 0 ;
34932 wxColour temp2 ;
34933 PyObject * obj0 = 0 ;
34934 PyObject * obj1 = 0 ;
34935 char * kwnames[] = {
34936 (char *) "self",(char *) "colour", NULL
34937 };
34938
34939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34941 if (!SWIG_IsOK(res1)) {
34942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34943 }
34944 arg1 = reinterpret_cast< wxWindow * >(argp1);
34945 {
34946 arg2 = &temp2;
34947 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34948 }
34949 {
34950 PyThreadState* __tstate = wxPyBeginAllowThreads();
34951 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34952 wxPyEndAllowThreads(__tstate);
34953 if (PyErr_Occurred()) SWIG_fail;
34954 }
34955 {
34956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34957 }
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34965 PyObject *resultobj = 0;
34966 wxWindow *arg1 = (wxWindow *) 0 ;
34967 wxColour *arg2 = 0 ;
34968 void *argp1 = 0 ;
34969 int res1 = 0 ;
34970 wxColour temp2 ;
34971 PyObject * obj0 = 0 ;
34972 PyObject * obj1 = 0 ;
34973 char * kwnames[] = {
34974 (char *) "self",(char *) "colour", NULL
34975 };
34976
34977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34979 if (!SWIG_IsOK(res1)) {
34980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34981 }
34982 arg1 = reinterpret_cast< wxWindow * >(argp1);
34983 {
34984 arg2 = &temp2;
34985 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34986 }
34987 {
34988 PyThreadState* __tstate = wxPyBeginAllowThreads();
34989 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34990 wxPyEndAllowThreads(__tstate);
34991 if (PyErr_Occurred()) SWIG_fail;
34992 }
34993 resultobj = SWIG_Py_Void();
34994 return resultobj;
34995 fail:
34996 return NULL;
34997 }
34998
34999
35000 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35001 PyObject *resultobj = 0;
35002 wxWindow *arg1 = (wxWindow *) 0 ;
35003 wxColour result;
35004 void *argp1 = 0 ;
35005 int res1 = 0 ;
35006 PyObject *swig_obj[1] ;
35007
35008 if (!args) SWIG_fail;
35009 swig_obj[0] = args;
35010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35011 if (!SWIG_IsOK(res1)) {
35012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35013 }
35014 arg1 = reinterpret_cast< wxWindow * >(argp1);
35015 {
35016 PyThreadState* __tstate = wxPyBeginAllowThreads();
35017 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35018 wxPyEndAllowThreads(__tstate);
35019 if (PyErr_Occurred()) SWIG_fail;
35020 }
35021 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35022 return resultobj;
35023 fail:
35024 return NULL;
35025 }
35026
35027
35028 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35029 PyObject *resultobj = 0;
35030 wxWindow *arg1 = (wxWindow *) 0 ;
35031 wxColour result;
35032 void *argp1 = 0 ;
35033 int res1 = 0 ;
35034 PyObject *swig_obj[1] ;
35035
35036 if (!args) SWIG_fail;
35037 swig_obj[0] = args;
35038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35039 if (!SWIG_IsOK(res1)) {
35040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35041 }
35042 arg1 = reinterpret_cast< wxWindow * >(argp1);
35043 {
35044 PyThreadState* __tstate = wxPyBeginAllowThreads();
35045 result = ((wxWindow const *)arg1)->GetForegroundColour();
35046 wxPyEndAllowThreads(__tstate);
35047 if (PyErr_Occurred()) SWIG_fail;
35048 }
35049 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35050 return resultobj;
35051 fail:
35052 return NULL;
35053 }
35054
35055
35056 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35057 PyObject *resultobj = 0;
35058 wxWindow *arg1 = (wxWindow *) 0 ;
35059 bool result;
35060 void *argp1 = 0 ;
35061 int res1 = 0 ;
35062 PyObject *swig_obj[1] ;
35063
35064 if (!args) SWIG_fail;
35065 swig_obj[0] = args;
35066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35067 if (!SWIG_IsOK(res1)) {
35068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35069 }
35070 arg1 = reinterpret_cast< wxWindow * >(argp1);
35071 {
35072 PyThreadState* __tstate = wxPyBeginAllowThreads();
35073 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35074 wxPyEndAllowThreads(__tstate);
35075 if (PyErr_Occurred()) SWIG_fail;
35076 }
35077 {
35078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35079 }
35080 return resultobj;
35081 fail:
35082 return NULL;
35083 }
35084
35085
35086 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35087 PyObject *resultobj = 0;
35088 wxWindow *arg1 = (wxWindow *) 0 ;
35089 bool result;
35090 void *argp1 = 0 ;
35091 int res1 = 0 ;
35092 PyObject *swig_obj[1] ;
35093
35094 if (!args) SWIG_fail;
35095 swig_obj[0] = args;
35096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35097 if (!SWIG_IsOK(res1)) {
35098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35099 }
35100 arg1 = reinterpret_cast< wxWindow * >(argp1);
35101 {
35102 PyThreadState* __tstate = wxPyBeginAllowThreads();
35103 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35104 wxPyEndAllowThreads(__tstate);
35105 if (PyErr_Occurred()) SWIG_fail;
35106 }
35107 {
35108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35109 }
35110 return resultobj;
35111 fail:
35112 return NULL;
35113 }
35114
35115
35116 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35117 PyObject *resultobj = 0;
35118 wxWindow *arg1 = (wxWindow *) 0 ;
35119 wxBackgroundStyle arg2 ;
35120 bool result;
35121 void *argp1 = 0 ;
35122 int res1 = 0 ;
35123 int val2 ;
35124 int ecode2 = 0 ;
35125 PyObject * obj0 = 0 ;
35126 PyObject * obj1 = 0 ;
35127 char * kwnames[] = {
35128 (char *) "self",(char *) "style", NULL
35129 };
35130
35131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35133 if (!SWIG_IsOK(res1)) {
35134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35135 }
35136 arg1 = reinterpret_cast< wxWindow * >(argp1);
35137 ecode2 = SWIG_AsVal_int(obj1, &val2);
35138 if (!SWIG_IsOK(ecode2)) {
35139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35140 }
35141 arg2 = static_cast< wxBackgroundStyle >(val2);
35142 {
35143 PyThreadState* __tstate = wxPyBeginAllowThreads();
35144 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35145 wxPyEndAllowThreads(__tstate);
35146 if (PyErr_Occurred()) SWIG_fail;
35147 }
35148 {
35149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35150 }
35151 return resultobj;
35152 fail:
35153 return NULL;
35154 }
35155
35156
35157 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35158 PyObject *resultobj = 0;
35159 wxWindow *arg1 = (wxWindow *) 0 ;
35160 wxBackgroundStyle result;
35161 void *argp1 = 0 ;
35162 int res1 = 0 ;
35163 PyObject *swig_obj[1] ;
35164
35165 if (!args) SWIG_fail;
35166 swig_obj[0] = args;
35167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35168 if (!SWIG_IsOK(res1)) {
35169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35170 }
35171 arg1 = reinterpret_cast< wxWindow * >(argp1);
35172 {
35173 PyThreadState* __tstate = wxPyBeginAllowThreads();
35174 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35175 wxPyEndAllowThreads(__tstate);
35176 if (PyErr_Occurred()) SWIG_fail;
35177 }
35178 resultobj = SWIG_From_int(static_cast< int >(result));
35179 return resultobj;
35180 fail:
35181 return NULL;
35182 }
35183
35184
35185 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35186 PyObject *resultobj = 0;
35187 wxWindow *arg1 = (wxWindow *) 0 ;
35188 bool result;
35189 void *argp1 = 0 ;
35190 int res1 = 0 ;
35191 PyObject *swig_obj[1] ;
35192
35193 if (!args) SWIG_fail;
35194 swig_obj[0] = args;
35195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35196 if (!SWIG_IsOK(res1)) {
35197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35198 }
35199 arg1 = reinterpret_cast< wxWindow * >(argp1);
35200 {
35201 PyThreadState* __tstate = wxPyBeginAllowThreads();
35202 result = (bool)(arg1)->HasTransparentBackground();
35203 wxPyEndAllowThreads(__tstate);
35204 if (PyErr_Occurred()) SWIG_fail;
35205 }
35206 {
35207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35208 }
35209 return resultobj;
35210 fail:
35211 return NULL;
35212 }
35213
35214
35215 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35216 PyObject *resultobj = 0;
35217 wxWindow *arg1 = (wxWindow *) 0 ;
35218 wxCursor *arg2 = 0 ;
35219 bool result;
35220 void *argp1 = 0 ;
35221 int res1 = 0 ;
35222 void *argp2 = 0 ;
35223 int res2 = 0 ;
35224 PyObject * obj0 = 0 ;
35225 PyObject * obj1 = 0 ;
35226 char * kwnames[] = {
35227 (char *) "self",(char *) "cursor", NULL
35228 };
35229
35230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35232 if (!SWIG_IsOK(res1)) {
35233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35234 }
35235 arg1 = reinterpret_cast< wxWindow * >(argp1);
35236 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35237 if (!SWIG_IsOK(res2)) {
35238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35239 }
35240 if (!argp2) {
35241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35242 }
35243 arg2 = reinterpret_cast< wxCursor * >(argp2);
35244 {
35245 PyThreadState* __tstate = wxPyBeginAllowThreads();
35246 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 {
35251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35252 }
35253 return resultobj;
35254 fail:
35255 return NULL;
35256 }
35257
35258
35259 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35260 PyObject *resultobj = 0;
35261 wxWindow *arg1 = (wxWindow *) 0 ;
35262 wxCursor result;
35263 void *argp1 = 0 ;
35264 int res1 = 0 ;
35265 PyObject *swig_obj[1] ;
35266
35267 if (!args) SWIG_fail;
35268 swig_obj[0] = args;
35269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35270 if (!SWIG_IsOK(res1)) {
35271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35272 }
35273 arg1 = reinterpret_cast< wxWindow * >(argp1);
35274 {
35275 PyThreadState* __tstate = wxPyBeginAllowThreads();
35276 result = (arg1)->GetCursor();
35277 wxPyEndAllowThreads(__tstate);
35278 if (PyErr_Occurred()) SWIG_fail;
35279 }
35280 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35288 PyObject *resultobj = 0;
35289 wxWindow *arg1 = (wxWindow *) 0 ;
35290 wxFont *arg2 = 0 ;
35291 bool result;
35292 void *argp1 = 0 ;
35293 int res1 = 0 ;
35294 void *argp2 = 0 ;
35295 int res2 = 0 ;
35296 PyObject * obj0 = 0 ;
35297 PyObject * obj1 = 0 ;
35298 char * kwnames[] = {
35299 (char *) "self",(char *) "font", NULL
35300 };
35301
35302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35304 if (!SWIG_IsOK(res1)) {
35305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35306 }
35307 arg1 = reinterpret_cast< wxWindow * >(argp1);
35308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35309 if (!SWIG_IsOK(res2)) {
35310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35311 }
35312 if (!argp2) {
35313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35314 }
35315 arg2 = reinterpret_cast< wxFont * >(argp2);
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35319 wxPyEndAllowThreads(__tstate);
35320 if (PyErr_Occurred()) SWIG_fail;
35321 }
35322 {
35323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35324 }
35325 return resultobj;
35326 fail:
35327 return NULL;
35328 }
35329
35330
35331 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35332 PyObject *resultobj = 0;
35333 wxWindow *arg1 = (wxWindow *) 0 ;
35334 wxFont *arg2 = 0 ;
35335 void *argp1 = 0 ;
35336 int res1 = 0 ;
35337 void *argp2 = 0 ;
35338 int res2 = 0 ;
35339 PyObject * obj0 = 0 ;
35340 PyObject * obj1 = 0 ;
35341 char * kwnames[] = {
35342 (char *) "self",(char *) "font", NULL
35343 };
35344
35345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35347 if (!SWIG_IsOK(res1)) {
35348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35349 }
35350 arg1 = reinterpret_cast< wxWindow * >(argp1);
35351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35352 if (!SWIG_IsOK(res2)) {
35353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35354 }
35355 if (!argp2) {
35356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35357 }
35358 arg2 = reinterpret_cast< wxFont * >(argp2);
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 (arg1)->SetOwnFont((wxFont const &)*arg2);
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 resultobj = SWIG_Py_Void();
35366 return resultobj;
35367 fail:
35368 return NULL;
35369 }
35370
35371
35372 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35373 PyObject *resultobj = 0;
35374 wxWindow *arg1 = (wxWindow *) 0 ;
35375 wxFont result;
35376 void *argp1 = 0 ;
35377 int res1 = 0 ;
35378 PyObject *swig_obj[1] ;
35379
35380 if (!args) SWIG_fail;
35381 swig_obj[0] = args;
35382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35383 if (!SWIG_IsOK(res1)) {
35384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35385 }
35386 arg1 = reinterpret_cast< wxWindow * >(argp1);
35387 {
35388 PyThreadState* __tstate = wxPyBeginAllowThreads();
35389 result = (arg1)->GetFont();
35390 wxPyEndAllowThreads(__tstate);
35391 if (PyErr_Occurred()) SWIG_fail;
35392 }
35393 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35394 return resultobj;
35395 fail:
35396 return NULL;
35397 }
35398
35399
35400 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35401 PyObject *resultobj = 0;
35402 wxWindow *arg1 = (wxWindow *) 0 ;
35403 wxCaret *arg2 = (wxCaret *) 0 ;
35404 void *argp1 = 0 ;
35405 int res1 = 0 ;
35406 int res2 = 0 ;
35407 PyObject * obj0 = 0 ;
35408 PyObject * obj1 = 0 ;
35409 char * kwnames[] = {
35410 (char *) "self",(char *) "caret", NULL
35411 };
35412
35413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35415 if (!SWIG_IsOK(res1)) {
35416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35417 }
35418 arg1 = reinterpret_cast< wxWindow * >(argp1);
35419 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35420 if (!SWIG_IsOK(res2)) {
35421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35422 }
35423 {
35424 PyThreadState* __tstate = wxPyBeginAllowThreads();
35425 (arg1)->SetCaret(arg2);
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 resultobj = SWIG_Py_Void();
35430 return resultobj;
35431 fail:
35432 return NULL;
35433 }
35434
35435
35436 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35437 PyObject *resultobj = 0;
35438 wxWindow *arg1 = (wxWindow *) 0 ;
35439 wxCaret *result = 0 ;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 PyObject *swig_obj[1] ;
35443
35444 if (!args) SWIG_fail;
35445 swig_obj[0] = args;
35446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35449 }
35450 arg1 = reinterpret_cast< wxWindow * >(argp1);
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35458 return resultobj;
35459 fail:
35460 return NULL;
35461 }
35462
35463
35464 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35465 PyObject *resultobj = 0;
35466 wxWindow *arg1 = (wxWindow *) 0 ;
35467 int result;
35468 void *argp1 = 0 ;
35469 int res1 = 0 ;
35470 PyObject *swig_obj[1] ;
35471
35472 if (!args) SWIG_fail;
35473 swig_obj[0] = args;
35474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35475 if (!SWIG_IsOK(res1)) {
35476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35477 }
35478 arg1 = reinterpret_cast< wxWindow * >(argp1);
35479 {
35480 PyThreadState* __tstate = wxPyBeginAllowThreads();
35481 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35482 wxPyEndAllowThreads(__tstate);
35483 if (PyErr_Occurred()) SWIG_fail;
35484 }
35485 resultobj = SWIG_From_int(static_cast< int >(result));
35486 return resultobj;
35487 fail:
35488 return NULL;
35489 }
35490
35491
35492 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35493 PyObject *resultobj = 0;
35494 wxWindow *arg1 = (wxWindow *) 0 ;
35495 int result;
35496 void *argp1 = 0 ;
35497 int res1 = 0 ;
35498 PyObject *swig_obj[1] ;
35499
35500 if (!args) SWIG_fail;
35501 swig_obj[0] = args;
35502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35503 if (!SWIG_IsOK(res1)) {
35504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35505 }
35506 arg1 = reinterpret_cast< wxWindow * >(argp1);
35507 {
35508 PyThreadState* __tstate = wxPyBeginAllowThreads();
35509 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35510 wxPyEndAllowThreads(__tstate);
35511 if (PyErr_Occurred()) SWIG_fail;
35512 }
35513 resultobj = SWIG_From_int(static_cast< int >(result));
35514 return resultobj;
35515 fail:
35516 return NULL;
35517 }
35518
35519
35520 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35521 PyObject *resultobj = 0;
35522 wxWindow *arg1 = (wxWindow *) 0 ;
35523 wxString *arg2 = 0 ;
35524 int *arg3 = (int *) 0 ;
35525 int *arg4 = (int *) 0 ;
35526 void *argp1 = 0 ;
35527 int res1 = 0 ;
35528 bool temp2 = false ;
35529 int temp3 ;
35530 int res3 = SWIG_TMPOBJ ;
35531 int temp4 ;
35532 int res4 = SWIG_TMPOBJ ;
35533 PyObject * obj0 = 0 ;
35534 PyObject * obj1 = 0 ;
35535 char * kwnames[] = {
35536 (char *) "self",(char *) "string", NULL
35537 };
35538
35539 arg3 = &temp3;
35540 arg4 = &temp4;
35541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35543 if (!SWIG_IsOK(res1)) {
35544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35545 }
35546 arg1 = reinterpret_cast< wxWindow * >(argp1);
35547 {
35548 arg2 = wxString_in_helper(obj1);
35549 if (arg2 == NULL) SWIG_fail;
35550 temp2 = true;
35551 }
35552 {
35553 PyThreadState* __tstate = wxPyBeginAllowThreads();
35554 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35555 wxPyEndAllowThreads(__tstate);
35556 if (PyErr_Occurred()) SWIG_fail;
35557 }
35558 resultobj = SWIG_Py_Void();
35559 if (SWIG_IsTmpObj(res3)) {
35560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35561 } else {
35562 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35564 }
35565 if (SWIG_IsTmpObj(res4)) {
35566 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35567 } else {
35568 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35569 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35570 }
35571 {
35572 if (temp2)
35573 delete arg2;
35574 }
35575 return resultobj;
35576 fail:
35577 {
35578 if (temp2)
35579 delete arg2;
35580 }
35581 return NULL;
35582 }
35583
35584
35585 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35586 PyObject *resultobj = 0;
35587 wxWindow *arg1 = (wxWindow *) 0 ;
35588 wxString *arg2 = 0 ;
35589 int *arg3 = (int *) 0 ;
35590 int *arg4 = (int *) 0 ;
35591 int *arg5 = (int *) 0 ;
35592 int *arg6 = (int *) 0 ;
35593 wxFont *arg7 = (wxFont *) NULL ;
35594 void *argp1 = 0 ;
35595 int res1 = 0 ;
35596 bool temp2 = false ;
35597 int temp3 ;
35598 int res3 = SWIG_TMPOBJ ;
35599 int temp4 ;
35600 int res4 = SWIG_TMPOBJ ;
35601 int temp5 ;
35602 int res5 = SWIG_TMPOBJ ;
35603 int temp6 ;
35604 int res6 = SWIG_TMPOBJ ;
35605 void *argp7 = 0 ;
35606 int res7 = 0 ;
35607 PyObject * obj0 = 0 ;
35608 PyObject * obj1 = 0 ;
35609 PyObject * obj2 = 0 ;
35610 char * kwnames[] = {
35611 (char *) "self",(char *) "string",(char *) "font", NULL
35612 };
35613
35614 arg3 = &temp3;
35615 arg4 = &temp4;
35616 arg5 = &temp5;
35617 arg6 = &temp6;
35618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35620 if (!SWIG_IsOK(res1)) {
35621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35622 }
35623 arg1 = reinterpret_cast< wxWindow * >(argp1);
35624 {
35625 arg2 = wxString_in_helper(obj1);
35626 if (arg2 == NULL) SWIG_fail;
35627 temp2 = true;
35628 }
35629 if (obj2) {
35630 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35631 if (!SWIG_IsOK(res7)) {
35632 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35633 }
35634 arg7 = reinterpret_cast< wxFont * >(argp7);
35635 }
35636 {
35637 PyThreadState* __tstate = wxPyBeginAllowThreads();
35638 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35639 wxPyEndAllowThreads(__tstate);
35640 if (PyErr_Occurred()) SWIG_fail;
35641 }
35642 resultobj = SWIG_Py_Void();
35643 if (SWIG_IsTmpObj(res3)) {
35644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35645 } else {
35646 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35648 }
35649 if (SWIG_IsTmpObj(res4)) {
35650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35651 } else {
35652 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35653 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35654 }
35655 if (SWIG_IsTmpObj(res5)) {
35656 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35657 } else {
35658 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35659 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35660 }
35661 if (SWIG_IsTmpObj(res6)) {
35662 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35663 } else {
35664 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35665 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35666 }
35667 {
35668 if (temp2)
35669 delete arg2;
35670 }
35671 return resultobj;
35672 fail:
35673 {
35674 if (temp2)
35675 delete arg2;
35676 }
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35682 PyObject *resultobj = 0;
35683 wxWindow *arg1 = (wxWindow *) 0 ;
35684 int *arg2 = (int *) 0 ;
35685 int *arg3 = (int *) 0 ;
35686 void *argp1 = 0 ;
35687 int res1 = 0 ;
35688 int temp2 ;
35689 int res2 = 0 ;
35690 int temp3 ;
35691 int res3 = 0 ;
35692 PyObject * obj0 = 0 ;
35693 PyObject * obj1 = 0 ;
35694 PyObject * obj2 = 0 ;
35695 char * kwnames[] = {
35696 (char *) "self",(char *) "x",(char *) "y", NULL
35697 };
35698
35699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) 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_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35703 }
35704 arg1 = reinterpret_cast< wxWindow * >(argp1);
35705 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35706 int val;
35707 int ecode = SWIG_AsVal_int(obj1, &val);
35708 if (!SWIG_IsOK(ecode)) {
35709 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35710 }
35711 temp2 = static_cast< int >(val);
35712 arg2 = &temp2;
35713 res2 = SWIG_AddTmpMask(ecode);
35714 }
35715 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35716 int val;
35717 int ecode = SWIG_AsVal_int(obj2, &val);
35718 if (!SWIG_IsOK(ecode)) {
35719 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35720 }
35721 temp3 = static_cast< int >(val);
35722 arg3 = &temp3;
35723 res3 = SWIG_AddTmpMask(ecode);
35724 }
35725 {
35726 PyThreadState* __tstate = wxPyBeginAllowThreads();
35727 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35728 wxPyEndAllowThreads(__tstate);
35729 if (PyErr_Occurred()) SWIG_fail;
35730 }
35731 resultobj = SWIG_Py_Void();
35732 if (SWIG_IsTmpObj(res2)) {
35733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35734 } else {
35735 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35737 }
35738 if (SWIG_IsTmpObj(res3)) {
35739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35740 } else {
35741 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35743 }
35744 return resultobj;
35745 fail:
35746 return NULL;
35747 }
35748
35749
35750 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35751 PyObject *resultobj = 0;
35752 wxWindow *arg1 = (wxWindow *) 0 ;
35753 int *arg2 = (int *) 0 ;
35754 int *arg3 = (int *) 0 ;
35755 void *argp1 = 0 ;
35756 int res1 = 0 ;
35757 int temp2 ;
35758 int res2 = 0 ;
35759 int temp3 ;
35760 int res3 = 0 ;
35761 PyObject * obj0 = 0 ;
35762 PyObject * obj1 = 0 ;
35763 PyObject * obj2 = 0 ;
35764 char * kwnames[] = {
35765 (char *) "self",(char *) "x",(char *) "y", NULL
35766 };
35767
35768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35770 if (!SWIG_IsOK(res1)) {
35771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35772 }
35773 arg1 = reinterpret_cast< wxWindow * >(argp1);
35774 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35775 int val;
35776 int ecode = SWIG_AsVal_int(obj1, &val);
35777 if (!SWIG_IsOK(ecode)) {
35778 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35779 }
35780 temp2 = static_cast< int >(val);
35781 arg2 = &temp2;
35782 res2 = SWIG_AddTmpMask(ecode);
35783 }
35784 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35785 int val;
35786 int ecode = SWIG_AsVal_int(obj2, &val);
35787 if (!SWIG_IsOK(ecode)) {
35788 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35789 }
35790 temp3 = static_cast< int >(val);
35791 arg3 = &temp3;
35792 res3 = SWIG_AddTmpMask(ecode);
35793 }
35794 {
35795 PyThreadState* __tstate = wxPyBeginAllowThreads();
35796 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35797 wxPyEndAllowThreads(__tstate);
35798 if (PyErr_Occurred()) SWIG_fail;
35799 }
35800 resultobj = SWIG_Py_Void();
35801 if (SWIG_IsTmpObj(res2)) {
35802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35803 } else {
35804 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35806 }
35807 if (SWIG_IsTmpObj(res3)) {
35808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35809 } else {
35810 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35812 }
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj = 0;
35821 wxWindow *arg1 = (wxWindow *) 0 ;
35822 wxPoint *arg2 = 0 ;
35823 wxPoint result;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 wxPoint temp2 ;
35827 PyObject * obj0 = 0 ;
35828 PyObject * obj1 = 0 ;
35829 char * kwnames[] = {
35830 (char *) "self",(char *) "pt", NULL
35831 };
35832
35833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35835 if (!SWIG_IsOK(res1)) {
35836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35837 }
35838 arg1 = reinterpret_cast< wxWindow * >(argp1);
35839 {
35840 arg2 = &temp2;
35841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35842 }
35843 {
35844 PyThreadState* __tstate = wxPyBeginAllowThreads();
35845 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35850 return resultobj;
35851 fail:
35852 return NULL;
35853 }
35854
35855
35856 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35857 PyObject *resultobj = 0;
35858 wxWindow *arg1 = (wxWindow *) 0 ;
35859 wxPoint *arg2 = 0 ;
35860 wxPoint result;
35861 void *argp1 = 0 ;
35862 int res1 = 0 ;
35863 wxPoint temp2 ;
35864 PyObject * obj0 = 0 ;
35865 PyObject * obj1 = 0 ;
35866 char * kwnames[] = {
35867 (char *) "self",(char *) "pt", NULL
35868 };
35869
35870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35872 if (!SWIG_IsOK(res1)) {
35873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35874 }
35875 arg1 = reinterpret_cast< wxWindow * >(argp1);
35876 {
35877 arg2 = &temp2;
35878 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35879 }
35880 {
35881 PyThreadState* __tstate = wxPyBeginAllowThreads();
35882 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35883 wxPyEndAllowThreads(__tstate);
35884 if (PyErr_Occurred()) SWIG_fail;
35885 }
35886 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35887 return resultobj;
35888 fail:
35889 return NULL;
35890 }
35891
35892
35893 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35894 PyObject *resultobj = 0;
35895 wxWindow *arg1 = (wxWindow *) 0 ;
35896 int arg2 ;
35897 int arg3 ;
35898 wxHitTest result;
35899 void *argp1 = 0 ;
35900 int res1 = 0 ;
35901 int val2 ;
35902 int ecode2 = 0 ;
35903 int val3 ;
35904 int ecode3 = 0 ;
35905 PyObject * obj0 = 0 ;
35906 PyObject * obj1 = 0 ;
35907 PyObject * obj2 = 0 ;
35908 char * kwnames[] = {
35909 (char *) "self",(char *) "x",(char *) "y", NULL
35910 };
35911
35912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35914 if (!SWIG_IsOK(res1)) {
35915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35916 }
35917 arg1 = reinterpret_cast< wxWindow * >(argp1);
35918 ecode2 = SWIG_AsVal_int(obj1, &val2);
35919 if (!SWIG_IsOK(ecode2)) {
35920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35921 }
35922 arg2 = static_cast< int >(val2);
35923 ecode3 = SWIG_AsVal_int(obj2, &val3);
35924 if (!SWIG_IsOK(ecode3)) {
35925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35926 }
35927 arg3 = static_cast< int >(val3);
35928 {
35929 PyThreadState* __tstate = wxPyBeginAllowThreads();
35930 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 resultobj = SWIG_From_int(static_cast< int >(result));
35935 return resultobj;
35936 fail:
35937 return NULL;
35938 }
35939
35940
35941 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35942 PyObject *resultobj = 0;
35943 wxWindow *arg1 = (wxWindow *) 0 ;
35944 wxPoint *arg2 = 0 ;
35945 wxHitTest result;
35946 void *argp1 = 0 ;
35947 int res1 = 0 ;
35948 wxPoint temp2 ;
35949 PyObject * obj0 = 0 ;
35950 PyObject * obj1 = 0 ;
35951 char * kwnames[] = {
35952 (char *) "self",(char *) "pt", NULL
35953 };
35954
35955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35957 if (!SWIG_IsOK(res1)) {
35958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35959 }
35960 arg1 = reinterpret_cast< wxWindow * >(argp1);
35961 {
35962 arg2 = &temp2;
35963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35964 }
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 resultobj = SWIG_From_int(static_cast< int >(result));
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35979 PyObject *resultobj = 0;
35980 wxWindow *arg1 = (wxWindow *) 0 ;
35981 long arg2 ;
35982 wxBorder result;
35983 void *argp1 = 0 ;
35984 int res1 = 0 ;
35985 long val2 ;
35986 int ecode2 = 0 ;
35987
35988 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35990 if (!SWIG_IsOK(res1)) {
35991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35992 }
35993 arg1 = reinterpret_cast< wxWindow * >(argp1);
35994 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35995 if (!SWIG_IsOK(ecode2)) {
35996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35997 }
35998 arg2 = static_cast< long >(val2);
35999 {
36000 PyThreadState* __tstate = wxPyBeginAllowThreads();
36001 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36002 wxPyEndAllowThreads(__tstate);
36003 if (PyErr_Occurred()) SWIG_fail;
36004 }
36005 resultobj = SWIG_From_int(static_cast< int >(result));
36006 return resultobj;
36007 fail:
36008 return NULL;
36009 }
36010
36011
36012 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36013 PyObject *resultobj = 0;
36014 wxWindow *arg1 = (wxWindow *) 0 ;
36015 wxBorder result;
36016 void *argp1 = 0 ;
36017 int res1 = 0 ;
36018
36019 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36021 if (!SWIG_IsOK(res1)) {
36022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36023 }
36024 arg1 = reinterpret_cast< wxWindow * >(argp1);
36025 {
36026 PyThreadState* __tstate = wxPyBeginAllowThreads();
36027 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36028 wxPyEndAllowThreads(__tstate);
36029 if (PyErr_Occurred()) SWIG_fail;
36030 }
36031 resultobj = SWIG_From_int(static_cast< int >(result));
36032 return resultobj;
36033 fail:
36034 return NULL;
36035 }
36036
36037
36038 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36039 int argc;
36040 PyObject *argv[3];
36041
36042 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36043 --argc;
36044 if (argc == 1) {
36045 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36046 }
36047 if (argc == 2) {
36048 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36049 }
36050
36051 fail:
36052 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36053 return NULL;
36054 }
36055
36056
36057 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36058 PyObject *resultobj = 0;
36059 wxWindow *arg1 = (wxWindow *) 0 ;
36060 long arg2 = (long) wxUPDATE_UI_NONE ;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 long val2 ;
36064 int ecode2 = 0 ;
36065 PyObject * obj0 = 0 ;
36066 PyObject * obj1 = 0 ;
36067 char * kwnames[] = {
36068 (char *) "self",(char *) "flags", NULL
36069 };
36070
36071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36073 if (!SWIG_IsOK(res1)) {
36074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36075 }
36076 arg1 = reinterpret_cast< wxWindow * >(argp1);
36077 if (obj1) {
36078 ecode2 = SWIG_AsVal_long(obj1, &val2);
36079 if (!SWIG_IsOK(ecode2)) {
36080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36081 }
36082 arg2 = static_cast< long >(val2);
36083 }
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 (arg1)->UpdateWindowUI(arg2);
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 resultobj = SWIG_Py_Void();
36091 return resultobj;
36092 fail:
36093 return NULL;
36094 }
36095
36096
36097 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36098 PyObject *resultobj = 0;
36099 wxWindow *arg1 = (wxWindow *) 0 ;
36100 wxMenu *arg2 = (wxMenu *) 0 ;
36101 int arg3 = (int) -1 ;
36102 int arg4 = (int) -1 ;
36103 bool result;
36104 void *argp1 = 0 ;
36105 int res1 = 0 ;
36106 void *argp2 = 0 ;
36107 int res2 = 0 ;
36108 int val3 ;
36109 int ecode3 = 0 ;
36110 int val4 ;
36111 int ecode4 = 0 ;
36112 PyObject * obj0 = 0 ;
36113 PyObject * obj1 = 0 ;
36114 PyObject * obj2 = 0 ;
36115 PyObject * obj3 = 0 ;
36116 char * kwnames[] = {
36117 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36118 };
36119
36120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36122 if (!SWIG_IsOK(res1)) {
36123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36124 }
36125 arg1 = reinterpret_cast< wxWindow * >(argp1);
36126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36127 if (!SWIG_IsOK(res2)) {
36128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36129 }
36130 arg2 = reinterpret_cast< wxMenu * >(argp2);
36131 if (obj2) {
36132 ecode3 = SWIG_AsVal_int(obj2, &val3);
36133 if (!SWIG_IsOK(ecode3)) {
36134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36135 }
36136 arg3 = static_cast< int >(val3);
36137 }
36138 if (obj3) {
36139 ecode4 = SWIG_AsVal_int(obj3, &val4);
36140 if (!SWIG_IsOK(ecode4)) {
36141 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36142 }
36143 arg4 = static_cast< int >(val4);
36144 }
36145 {
36146 PyThreadState* __tstate = wxPyBeginAllowThreads();
36147 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36148 wxPyEndAllowThreads(__tstate);
36149 if (PyErr_Occurred()) SWIG_fail;
36150 }
36151 {
36152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36153 }
36154 return resultobj;
36155 fail:
36156 return NULL;
36157 }
36158
36159
36160 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36161 PyObject *resultobj = 0;
36162 wxWindow *arg1 = (wxWindow *) 0 ;
36163 wxMenu *arg2 = (wxMenu *) 0 ;
36164 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36165 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36166 bool result;
36167 void *argp1 = 0 ;
36168 int res1 = 0 ;
36169 void *argp2 = 0 ;
36170 int res2 = 0 ;
36171 wxPoint temp3 ;
36172 PyObject * obj0 = 0 ;
36173 PyObject * obj1 = 0 ;
36174 PyObject * obj2 = 0 ;
36175 char * kwnames[] = {
36176 (char *) "self",(char *) "menu",(char *) "pos", NULL
36177 };
36178
36179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36181 if (!SWIG_IsOK(res1)) {
36182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36183 }
36184 arg1 = reinterpret_cast< wxWindow * >(argp1);
36185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36186 if (!SWIG_IsOK(res2)) {
36187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36188 }
36189 arg2 = reinterpret_cast< wxMenu * >(argp2);
36190 if (obj2) {
36191 {
36192 arg3 = &temp3;
36193 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36194 }
36195 }
36196 {
36197 PyThreadState* __tstate = wxPyBeginAllowThreads();
36198 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36199 wxPyEndAllowThreads(__tstate);
36200 if (PyErr_Occurred()) SWIG_fail;
36201 }
36202 {
36203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36204 }
36205 return resultobj;
36206 fail:
36207 return NULL;
36208 }
36209
36210
36211 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36212 PyObject *resultobj = 0;
36213 wxWindow *arg1 = (wxWindow *) 0 ;
36214 bool result;
36215 void *argp1 = 0 ;
36216 int res1 = 0 ;
36217 PyObject *swig_obj[1] ;
36218
36219 if (!args) SWIG_fail;
36220 swig_obj[0] = args;
36221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36222 if (!SWIG_IsOK(res1)) {
36223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36224 }
36225 arg1 = reinterpret_cast< wxWindow * >(argp1);
36226 {
36227 PyThreadState* __tstate = wxPyBeginAllowThreads();
36228 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36229 wxPyEndAllowThreads(__tstate);
36230 if (PyErr_Occurred()) SWIG_fail;
36231 }
36232 {
36233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36234 }
36235 return resultobj;
36236 fail:
36237 return NULL;
36238 }
36239
36240
36241 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36242 PyObject *resultobj = 0;
36243 wxWindow *arg1 = (wxWindow *) 0 ;
36244 long result;
36245 void *argp1 = 0 ;
36246 int res1 = 0 ;
36247 PyObject *swig_obj[1] ;
36248
36249 if (!args) SWIG_fail;
36250 swig_obj[0] = args;
36251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36252 if (!SWIG_IsOK(res1)) {
36253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36254 }
36255 arg1 = reinterpret_cast< wxWindow * >(argp1);
36256 {
36257 PyThreadState* __tstate = wxPyBeginAllowThreads();
36258 result = (long)wxWindow_GetHandle(arg1);
36259 wxPyEndAllowThreads(__tstate);
36260 if (PyErr_Occurred()) SWIG_fail;
36261 }
36262 resultobj = SWIG_From_long(static_cast< long >(result));
36263 return resultobj;
36264 fail:
36265 return NULL;
36266 }
36267
36268
36269 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36270 PyObject *resultobj = 0;
36271 wxWindow *arg1 = (wxWindow *) 0 ;
36272 long arg2 ;
36273 void *argp1 = 0 ;
36274 int res1 = 0 ;
36275 long val2 ;
36276 int ecode2 = 0 ;
36277 PyObject * obj0 = 0 ;
36278 PyObject * obj1 = 0 ;
36279 char * kwnames[] = {
36280 (char *) "self",(char *) "handle", NULL
36281 };
36282
36283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36285 if (!SWIG_IsOK(res1)) {
36286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36287 }
36288 arg1 = reinterpret_cast< wxWindow * >(argp1);
36289 ecode2 = SWIG_AsVal_long(obj1, &val2);
36290 if (!SWIG_IsOK(ecode2)) {
36291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36292 }
36293 arg2 = static_cast< long >(val2);
36294 {
36295 PyThreadState* __tstate = wxPyBeginAllowThreads();
36296 wxWindow_AssociateHandle(arg1,arg2);
36297 wxPyEndAllowThreads(__tstate);
36298 if (PyErr_Occurred()) SWIG_fail;
36299 }
36300 resultobj = SWIG_Py_Void();
36301 return resultobj;
36302 fail:
36303 return NULL;
36304 }
36305
36306
36307 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36308 PyObject *resultobj = 0;
36309 wxWindow *arg1 = (wxWindow *) 0 ;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 PyObject *swig_obj[1] ;
36313
36314 if (!args) SWIG_fail;
36315 swig_obj[0] = args;
36316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36317 if (!SWIG_IsOK(res1)) {
36318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36319 }
36320 arg1 = reinterpret_cast< wxWindow * >(argp1);
36321 {
36322 PyThreadState* __tstate = wxPyBeginAllowThreads();
36323 (arg1)->DissociateHandle();
36324 wxPyEndAllowThreads(__tstate);
36325 if (PyErr_Occurred()) SWIG_fail;
36326 }
36327 resultobj = SWIG_Py_Void();
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36335 PyObject *resultobj = 0;
36336 wxWindow *arg1 = (wxWindow *) 0 ;
36337 int arg2 ;
36338 bool result;
36339 void *argp1 = 0 ;
36340 int res1 = 0 ;
36341 int val2 ;
36342 int ecode2 = 0 ;
36343 PyObject * obj0 = 0 ;
36344 PyObject * obj1 = 0 ;
36345 char * kwnames[] = {
36346 (char *) "self",(char *) "orient", NULL
36347 };
36348
36349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36351 if (!SWIG_IsOK(res1)) {
36352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36353 }
36354 arg1 = reinterpret_cast< wxWindow * >(argp1);
36355 ecode2 = SWIG_AsVal_int(obj1, &val2);
36356 if (!SWIG_IsOK(ecode2)) {
36357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36358 }
36359 arg2 = static_cast< int >(val2);
36360 {
36361 PyThreadState* __tstate = wxPyBeginAllowThreads();
36362 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36363 wxPyEndAllowThreads(__tstate);
36364 if (PyErr_Occurred()) SWIG_fail;
36365 }
36366 {
36367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36368 }
36369 return resultobj;
36370 fail:
36371 return NULL;
36372 }
36373
36374
36375 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36376 PyObject *resultobj = 0;
36377 wxWindow *arg1 = (wxWindow *) 0 ;
36378 int arg2 ;
36379 int arg3 ;
36380 int arg4 ;
36381 int arg5 ;
36382 bool arg6 = (bool) true ;
36383 void *argp1 = 0 ;
36384 int res1 = 0 ;
36385 int val2 ;
36386 int ecode2 = 0 ;
36387 int val3 ;
36388 int ecode3 = 0 ;
36389 int val4 ;
36390 int ecode4 = 0 ;
36391 int val5 ;
36392 int ecode5 = 0 ;
36393 bool val6 ;
36394 int ecode6 = 0 ;
36395 PyObject * obj0 = 0 ;
36396 PyObject * obj1 = 0 ;
36397 PyObject * obj2 = 0 ;
36398 PyObject * obj3 = 0 ;
36399 PyObject * obj4 = 0 ;
36400 PyObject * obj5 = 0 ;
36401 char * kwnames[] = {
36402 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36403 };
36404
36405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36407 if (!SWIG_IsOK(res1)) {
36408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36409 }
36410 arg1 = reinterpret_cast< wxWindow * >(argp1);
36411 ecode2 = SWIG_AsVal_int(obj1, &val2);
36412 if (!SWIG_IsOK(ecode2)) {
36413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36414 }
36415 arg2 = static_cast< int >(val2);
36416 ecode3 = SWIG_AsVal_int(obj2, &val3);
36417 if (!SWIG_IsOK(ecode3)) {
36418 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36419 }
36420 arg3 = static_cast< int >(val3);
36421 ecode4 = SWIG_AsVal_int(obj3, &val4);
36422 if (!SWIG_IsOK(ecode4)) {
36423 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36424 }
36425 arg4 = static_cast< int >(val4);
36426 ecode5 = SWIG_AsVal_int(obj4, &val5);
36427 if (!SWIG_IsOK(ecode5)) {
36428 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36429 }
36430 arg5 = static_cast< int >(val5);
36431 if (obj5) {
36432 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36433 if (!SWIG_IsOK(ecode6)) {
36434 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36435 }
36436 arg6 = static_cast< bool >(val6);
36437 }
36438 {
36439 PyThreadState* __tstate = wxPyBeginAllowThreads();
36440 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36441 wxPyEndAllowThreads(__tstate);
36442 if (PyErr_Occurred()) SWIG_fail;
36443 }
36444 resultobj = SWIG_Py_Void();
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj = 0;
36453 wxWindow *arg1 = (wxWindow *) 0 ;
36454 int arg2 ;
36455 int arg3 ;
36456 bool arg4 = (bool) true ;
36457 void *argp1 = 0 ;
36458 int res1 = 0 ;
36459 int val2 ;
36460 int ecode2 = 0 ;
36461 int val3 ;
36462 int ecode3 = 0 ;
36463 bool val4 ;
36464 int ecode4 = 0 ;
36465 PyObject * obj0 = 0 ;
36466 PyObject * obj1 = 0 ;
36467 PyObject * obj2 = 0 ;
36468 PyObject * obj3 = 0 ;
36469 char * kwnames[] = {
36470 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36471 };
36472
36473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36475 if (!SWIG_IsOK(res1)) {
36476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36477 }
36478 arg1 = reinterpret_cast< wxWindow * >(argp1);
36479 ecode2 = SWIG_AsVal_int(obj1, &val2);
36480 if (!SWIG_IsOK(ecode2)) {
36481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36482 }
36483 arg2 = static_cast< int >(val2);
36484 ecode3 = SWIG_AsVal_int(obj2, &val3);
36485 if (!SWIG_IsOK(ecode3)) {
36486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36487 }
36488 arg3 = static_cast< int >(val3);
36489 if (obj3) {
36490 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36491 if (!SWIG_IsOK(ecode4)) {
36492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36493 }
36494 arg4 = static_cast< bool >(val4);
36495 }
36496 {
36497 PyThreadState* __tstate = wxPyBeginAllowThreads();
36498 (arg1)->SetScrollPos(arg2,arg3,arg4);
36499 wxPyEndAllowThreads(__tstate);
36500 if (PyErr_Occurred()) SWIG_fail;
36501 }
36502 resultobj = SWIG_Py_Void();
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36510 PyObject *resultobj = 0;
36511 wxWindow *arg1 = (wxWindow *) 0 ;
36512 int arg2 ;
36513 int result;
36514 void *argp1 = 0 ;
36515 int res1 = 0 ;
36516 int val2 ;
36517 int ecode2 = 0 ;
36518 PyObject * obj0 = 0 ;
36519 PyObject * obj1 = 0 ;
36520 char * kwnames[] = {
36521 (char *) "self",(char *) "orientation", NULL
36522 };
36523
36524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36526 if (!SWIG_IsOK(res1)) {
36527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36528 }
36529 arg1 = reinterpret_cast< wxWindow * >(argp1);
36530 ecode2 = SWIG_AsVal_int(obj1, &val2);
36531 if (!SWIG_IsOK(ecode2)) {
36532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36533 }
36534 arg2 = static_cast< int >(val2);
36535 {
36536 PyThreadState* __tstate = wxPyBeginAllowThreads();
36537 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 resultobj = SWIG_From_int(static_cast< int >(result));
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36549 PyObject *resultobj = 0;
36550 wxWindow *arg1 = (wxWindow *) 0 ;
36551 int arg2 ;
36552 int result;
36553 void *argp1 = 0 ;
36554 int res1 = 0 ;
36555 int val2 ;
36556 int ecode2 = 0 ;
36557 PyObject * obj0 = 0 ;
36558 PyObject * obj1 = 0 ;
36559 char * kwnames[] = {
36560 (char *) "self",(char *) "orientation", NULL
36561 };
36562
36563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) 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_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
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_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36572 }
36573 arg2 = static_cast< int >(val2);
36574 {
36575 PyThreadState* __tstate = wxPyBeginAllowThreads();
36576 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36577 wxPyEndAllowThreads(__tstate);
36578 if (PyErr_Occurred()) SWIG_fail;
36579 }
36580 resultobj = SWIG_From_int(static_cast< int >(result));
36581 return resultobj;
36582 fail:
36583 return NULL;
36584 }
36585
36586
36587 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36588 PyObject *resultobj = 0;
36589 wxWindow *arg1 = (wxWindow *) 0 ;
36590 int arg2 ;
36591 int result;
36592 void *argp1 = 0 ;
36593 int res1 = 0 ;
36594 int val2 ;
36595 int ecode2 = 0 ;
36596 PyObject * obj0 = 0 ;
36597 PyObject * obj1 = 0 ;
36598 char * kwnames[] = {
36599 (char *) "self",(char *) "orientation", NULL
36600 };
36601
36602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36604 if (!SWIG_IsOK(res1)) {
36605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36606 }
36607 arg1 = reinterpret_cast< wxWindow * >(argp1);
36608 ecode2 = SWIG_AsVal_int(obj1, &val2);
36609 if (!SWIG_IsOK(ecode2)) {
36610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36611 }
36612 arg2 = static_cast< int >(val2);
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36616 wxPyEndAllowThreads(__tstate);
36617 if (PyErr_Occurred()) SWIG_fail;
36618 }
36619 resultobj = SWIG_From_int(static_cast< int >(result));
36620 return resultobj;
36621 fail:
36622 return NULL;
36623 }
36624
36625
36626 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36627 PyObject *resultobj = 0;
36628 wxWindow *arg1 = (wxWindow *) 0 ;
36629 int arg2 ;
36630 int arg3 ;
36631 wxRect *arg4 = (wxRect *) NULL ;
36632 void *argp1 = 0 ;
36633 int res1 = 0 ;
36634 int val2 ;
36635 int ecode2 = 0 ;
36636 int val3 ;
36637 int ecode3 = 0 ;
36638 void *argp4 = 0 ;
36639 int res4 = 0 ;
36640 PyObject * obj0 = 0 ;
36641 PyObject * obj1 = 0 ;
36642 PyObject * obj2 = 0 ;
36643 PyObject * obj3 = 0 ;
36644 char * kwnames[] = {
36645 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36646 };
36647
36648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36650 if (!SWIG_IsOK(res1)) {
36651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36652 }
36653 arg1 = reinterpret_cast< wxWindow * >(argp1);
36654 ecode2 = SWIG_AsVal_int(obj1, &val2);
36655 if (!SWIG_IsOK(ecode2)) {
36656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36657 }
36658 arg2 = static_cast< int >(val2);
36659 ecode3 = SWIG_AsVal_int(obj2, &val3);
36660 if (!SWIG_IsOK(ecode3)) {
36661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36662 }
36663 arg3 = static_cast< int >(val3);
36664 if (obj3) {
36665 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36666 if (!SWIG_IsOK(res4)) {
36667 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36668 }
36669 arg4 = reinterpret_cast< wxRect * >(argp4);
36670 }
36671 {
36672 PyThreadState* __tstate = wxPyBeginAllowThreads();
36673 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36674 wxPyEndAllowThreads(__tstate);
36675 if (PyErr_Occurred()) SWIG_fail;
36676 }
36677 resultobj = SWIG_Py_Void();
36678 return resultobj;
36679 fail:
36680 return NULL;
36681 }
36682
36683
36684 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36685 PyObject *resultobj = 0;
36686 wxWindow *arg1 = (wxWindow *) 0 ;
36687 int arg2 ;
36688 bool result;
36689 void *argp1 = 0 ;
36690 int res1 = 0 ;
36691 int val2 ;
36692 int ecode2 = 0 ;
36693 PyObject * obj0 = 0 ;
36694 PyObject * obj1 = 0 ;
36695 char * kwnames[] = {
36696 (char *) "self",(char *) "lines", NULL
36697 };
36698
36699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36701 if (!SWIG_IsOK(res1)) {
36702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36703 }
36704 arg1 = reinterpret_cast< wxWindow * >(argp1);
36705 ecode2 = SWIG_AsVal_int(obj1, &val2);
36706 if (!SWIG_IsOK(ecode2)) {
36707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36708 }
36709 arg2 = static_cast< int >(val2);
36710 {
36711 PyThreadState* __tstate = wxPyBeginAllowThreads();
36712 result = (bool)(arg1)->ScrollLines(arg2);
36713 wxPyEndAllowThreads(__tstate);
36714 if (PyErr_Occurred()) SWIG_fail;
36715 }
36716 {
36717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36718 }
36719 return resultobj;
36720 fail:
36721 return NULL;
36722 }
36723
36724
36725 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36726 PyObject *resultobj = 0;
36727 wxWindow *arg1 = (wxWindow *) 0 ;
36728 int arg2 ;
36729 bool result;
36730 void *argp1 = 0 ;
36731 int res1 = 0 ;
36732 int val2 ;
36733 int ecode2 = 0 ;
36734 PyObject * obj0 = 0 ;
36735 PyObject * obj1 = 0 ;
36736 char * kwnames[] = {
36737 (char *) "self",(char *) "pages", NULL
36738 };
36739
36740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36742 if (!SWIG_IsOK(res1)) {
36743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36744 }
36745 arg1 = reinterpret_cast< wxWindow * >(argp1);
36746 ecode2 = SWIG_AsVal_int(obj1, &val2);
36747 if (!SWIG_IsOK(ecode2)) {
36748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36749 }
36750 arg2 = static_cast< int >(val2);
36751 {
36752 PyThreadState* __tstate = wxPyBeginAllowThreads();
36753 result = (bool)(arg1)->ScrollPages(arg2);
36754 wxPyEndAllowThreads(__tstate);
36755 if (PyErr_Occurred()) SWIG_fail;
36756 }
36757 {
36758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36759 }
36760 return resultobj;
36761 fail:
36762 return NULL;
36763 }
36764
36765
36766 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36767 PyObject *resultobj = 0;
36768 wxWindow *arg1 = (wxWindow *) 0 ;
36769 bool result;
36770 void *argp1 = 0 ;
36771 int res1 = 0 ;
36772 PyObject *swig_obj[1] ;
36773
36774 if (!args) SWIG_fail;
36775 swig_obj[0] = args;
36776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36777 if (!SWIG_IsOK(res1)) {
36778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36779 }
36780 arg1 = reinterpret_cast< wxWindow * >(argp1);
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 result = (bool)(arg1)->LineUp();
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 {
36788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36789 }
36790 return resultobj;
36791 fail:
36792 return NULL;
36793 }
36794
36795
36796 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36797 PyObject *resultobj = 0;
36798 wxWindow *arg1 = (wxWindow *) 0 ;
36799 bool result;
36800 void *argp1 = 0 ;
36801 int res1 = 0 ;
36802 PyObject *swig_obj[1] ;
36803
36804 if (!args) SWIG_fail;
36805 swig_obj[0] = args;
36806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36807 if (!SWIG_IsOK(res1)) {
36808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36809 }
36810 arg1 = reinterpret_cast< wxWindow * >(argp1);
36811 {
36812 PyThreadState* __tstate = wxPyBeginAllowThreads();
36813 result = (bool)(arg1)->LineDown();
36814 wxPyEndAllowThreads(__tstate);
36815 if (PyErr_Occurred()) SWIG_fail;
36816 }
36817 {
36818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36819 }
36820 return resultobj;
36821 fail:
36822 return NULL;
36823 }
36824
36825
36826 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36827 PyObject *resultobj = 0;
36828 wxWindow *arg1 = (wxWindow *) 0 ;
36829 bool result;
36830 void *argp1 = 0 ;
36831 int res1 = 0 ;
36832 PyObject *swig_obj[1] ;
36833
36834 if (!args) SWIG_fail;
36835 swig_obj[0] = args;
36836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36837 if (!SWIG_IsOK(res1)) {
36838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36839 }
36840 arg1 = reinterpret_cast< wxWindow * >(argp1);
36841 {
36842 PyThreadState* __tstate = wxPyBeginAllowThreads();
36843 result = (bool)(arg1)->PageUp();
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 {
36848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36849 }
36850 return resultobj;
36851 fail:
36852 return NULL;
36853 }
36854
36855
36856 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36857 PyObject *resultobj = 0;
36858 wxWindow *arg1 = (wxWindow *) 0 ;
36859 bool result;
36860 void *argp1 = 0 ;
36861 int res1 = 0 ;
36862 PyObject *swig_obj[1] ;
36863
36864 if (!args) SWIG_fail;
36865 swig_obj[0] = args;
36866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36869 }
36870 arg1 = reinterpret_cast< wxWindow * >(argp1);
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 result = (bool)(arg1)->PageDown();
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 {
36878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36879 }
36880 return resultobj;
36881 fail:
36882 return NULL;
36883 }
36884
36885
36886 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36887 PyObject *resultobj = 0;
36888 wxWindow *arg1 = (wxWindow *) 0 ;
36889 wxString *arg2 = 0 ;
36890 void *argp1 = 0 ;
36891 int res1 = 0 ;
36892 bool temp2 = false ;
36893 PyObject * obj0 = 0 ;
36894 PyObject * obj1 = 0 ;
36895 char * kwnames[] = {
36896 (char *) "self",(char *) "text", NULL
36897 };
36898
36899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36903 }
36904 arg1 = reinterpret_cast< wxWindow * >(argp1);
36905 {
36906 arg2 = wxString_in_helper(obj1);
36907 if (arg2 == NULL) SWIG_fail;
36908 temp2 = true;
36909 }
36910 {
36911 PyThreadState* __tstate = wxPyBeginAllowThreads();
36912 (arg1)->SetHelpText((wxString const &)*arg2);
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 resultobj = SWIG_Py_Void();
36917 {
36918 if (temp2)
36919 delete arg2;
36920 }
36921 return resultobj;
36922 fail:
36923 {
36924 if (temp2)
36925 delete arg2;
36926 }
36927 return NULL;
36928 }
36929
36930
36931 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36932 PyObject *resultobj = 0;
36933 wxWindow *arg1 = (wxWindow *) 0 ;
36934 wxString *arg2 = 0 ;
36935 void *argp1 = 0 ;
36936 int res1 = 0 ;
36937 bool temp2 = false ;
36938 PyObject * obj0 = 0 ;
36939 PyObject * obj1 = 0 ;
36940 char * kwnames[] = {
36941 (char *) "self",(char *) "text", NULL
36942 };
36943
36944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36946 if (!SWIG_IsOK(res1)) {
36947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36948 }
36949 arg1 = reinterpret_cast< wxWindow * >(argp1);
36950 {
36951 arg2 = wxString_in_helper(obj1);
36952 if (arg2 == NULL) SWIG_fail;
36953 temp2 = true;
36954 }
36955 {
36956 PyThreadState* __tstate = wxPyBeginAllowThreads();
36957 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 resultobj = SWIG_Py_Void();
36962 {
36963 if (temp2)
36964 delete arg2;
36965 }
36966 return resultobj;
36967 fail:
36968 {
36969 if (temp2)
36970 delete arg2;
36971 }
36972 return NULL;
36973 }
36974
36975
36976 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36977 PyObject *resultobj = 0;
36978 wxWindow *arg1 = (wxWindow *) 0 ;
36979 wxPoint *arg2 = 0 ;
36980 wxHelpEvent::Origin arg3 ;
36981 wxString result;
36982 void *argp1 = 0 ;
36983 int res1 = 0 ;
36984 wxPoint temp2 ;
36985 void *argp3 ;
36986 int res3 = 0 ;
36987 PyObject * obj0 = 0 ;
36988 PyObject * obj1 = 0 ;
36989 PyObject * obj2 = 0 ;
36990 char * kwnames[] = {
36991 (char *) "self",(char *) "pt",(char *) "origin", NULL
36992 };
36993
36994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36996 if (!SWIG_IsOK(res1)) {
36997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36998 }
36999 arg1 = reinterpret_cast< wxWindow * >(argp1);
37000 {
37001 arg2 = &temp2;
37002 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37003 }
37004 {
37005 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37006 if (!SWIG_IsOK(res3)) {
37007 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37008 }
37009 if (!argp3) {
37010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37011 } else {
37012 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37013 arg3 = *temp;
37014 if (SWIG_IsNewObj(res3)) delete temp;
37015 }
37016 }
37017 {
37018 PyThreadState* __tstate = wxPyBeginAllowThreads();
37019 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37020 wxPyEndAllowThreads(__tstate);
37021 if (PyErr_Occurred()) SWIG_fail;
37022 }
37023 {
37024 #if wxUSE_UNICODE
37025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37026 #else
37027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37028 #endif
37029 }
37030 return resultobj;
37031 fail:
37032 return NULL;
37033 }
37034
37035
37036 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37037 PyObject *resultobj = 0;
37038 wxWindow *arg1 = (wxWindow *) 0 ;
37039 wxString result;
37040 void *argp1 = 0 ;
37041 int res1 = 0 ;
37042 PyObject *swig_obj[1] ;
37043
37044 if (!args) SWIG_fail;
37045 swig_obj[0] = args;
37046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37047 if (!SWIG_IsOK(res1)) {
37048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37049 }
37050 arg1 = reinterpret_cast< wxWindow * >(argp1);
37051 {
37052 PyThreadState* __tstate = wxPyBeginAllowThreads();
37053 result = ((wxWindow const *)arg1)->GetHelpText();
37054 wxPyEndAllowThreads(__tstate);
37055 if (PyErr_Occurred()) SWIG_fail;
37056 }
37057 {
37058 #if wxUSE_UNICODE
37059 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37060 #else
37061 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37062 #endif
37063 }
37064 return resultobj;
37065 fail:
37066 return NULL;
37067 }
37068
37069
37070 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj = 0;
37072 wxWindow *arg1 = (wxWindow *) 0 ;
37073 wxString *arg2 = 0 ;
37074 void *argp1 = 0 ;
37075 int res1 = 0 ;
37076 bool temp2 = false ;
37077 PyObject * obj0 = 0 ;
37078 PyObject * obj1 = 0 ;
37079 char * kwnames[] = {
37080 (char *) "self",(char *) "tip", NULL
37081 };
37082
37083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37085 if (!SWIG_IsOK(res1)) {
37086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37087 }
37088 arg1 = reinterpret_cast< wxWindow * >(argp1);
37089 {
37090 arg2 = wxString_in_helper(obj1);
37091 if (arg2 == NULL) SWIG_fail;
37092 temp2 = true;
37093 }
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 (arg1)->SetToolTip((wxString const &)*arg2);
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 resultobj = SWIG_Py_Void();
37101 {
37102 if (temp2)
37103 delete arg2;
37104 }
37105 return resultobj;
37106 fail:
37107 {
37108 if (temp2)
37109 delete arg2;
37110 }
37111 return NULL;
37112 }
37113
37114
37115 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37116 PyObject *resultobj = 0;
37117 wxWindow *arg1 = (wxWindow *) 0 ;
37118 wxToolTip *arg2 = (wxToolTip *) 0 ;
37119 void *argp1 = 0 ;
37120 int res1 = 0 ;
37121 int res2 = 0 ;
37122 PyObject * obj0 = 0 ;
37123 PyObject * obj1 = 0 ;
37124 char * kwnames[] = {
37125 (char *) "self",(char *) "tip", NULL
37126 };
37127
37128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37130 if (!SWIG_IsOK(res1)) {
37131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37132 }
37133 arg1 = reinterpret_cast< wxWindow * >(argp1);
37134 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37135 if (!SWIG_IsOK(res2)) {
37136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37137 }
37138 {
37139 PyThreadState* __tstate = wxPyBeginAllowThreads();
37140 (arg1)->SetToolTip(arg2);
37141 wxPyEndAllowThreads(__tstate);
37142 if (PyErr_Occurred()) SWIG_fail;
37143 }
37144 resultobj = SWIG_Py_Void();
37145 return resultobj;
37146 fail:
37147 return NULL;
37148 }
37149
37150
37151 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37152 PyObject *resultobj = 0;
37153 wxWindow *arg1 = (wxWindow *) 0 ;
37154 wxToolTip *result = 0 ;
37155 void *argp1 = 0 ;
37156 int res1 = 0 ;
37157 PyObject *swig_obj[1] ;
37158
37159 if (!args) SWIG_fail;
37160 swig_obj[0] = args;
37161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37162 if (!SWIG_IsOK(res1)) {
37163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37164 }
37165 arg1 = reinterpret_cast< wxWindow * >(argp1);
37166 {
37167 PyThreadState* __tstate = wxPyBeginAllowThreads();
37168 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37169 wxPyEndAllowThreads(__tstate);
37170 if (PyErr_Occurred()) SWIG_fail;
37171 }
37172 {
37173 resultobj = wxPyMake_wxObject(result, (bool)0);
37174 }
37175 return resultobj;
37176 fail:
37177 return NULL;
37178 }
37179
37180
37181 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37182 PyObject *resultobj = 0;
37183 wxWindow *arg1 = (wxWindow *) 0 ;
37184 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37185 void *argp1 = 0 ;
37186 int res1 = 0 ;
37187 int res2 = 0 ;
37188 PyObject * obj0 = 0 ;
37189 PyObject * obj1 = 0 ;
37190 char * kwnames[] = {
37191 (char *) "self",(char *) "dropTarget", NULL
37192 };
37193
37194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37196 if (!SWIG_IsOK(res1)) {
37197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37198 }
37199 arg1 = reinterpret_cast< wxWindow * >(argp1);
37200 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37201 if (!SWIG_IsOK(res2)) {
37202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37203 }
37204 {
37205 PyThreadState* __tstate = wxPyBeginAllowThreads();
37206 (arg1)->SetDropTarget(arg2);
37207 wxPyEndAllowThreads(__tstate);
37208 if (PyErr_Occurred()) SWIG_fail;
37209 }
37210 resultobj = SWIG_Py_Void();
37211 return resultobj;
37212 fail:
37213 return NULL;
37214 }
37215
37216
37217 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37218 PyObject *resultobj = 0;
37219 wxWindow *arg1 = (wxWindow *) 0 ;
37220 wxPyDropTarget *result = 0 ;
37221 void *argp1 = 0 ;
37222 int res1 = 0 ;
37223 PyObject *swig_obj[1] ;
37224
37225 if (!args) SWIG_fail;
37226 swig_obj[0] = args;
37227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37228 if (!SWIG_IsOK(res1)) {
37229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37230 }
37231 arg1 = reinterpret_cast< wxWindow * >(argp1);
37232 {
37233 PyThreadState* __tstate = wxPyBeginAllowThreads();
37234 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37235 wxPyEndAllowThreads(__tstate);
37236 if (PyErr_Occurred()) SWIG_fail;
37237 }
37238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37239 return resultobj;
37240 fail:
37241 return NULL;
37242 }
37243
37244
37245 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37246 PyObject *resultobj = 0;
37247 wxWindow *arg1 = (wxWindow *) 0 ;
37248 bool arg2 ;
37249 void *argp1 = 0 ;
37250 int res1 = 0 ;
37251 bool val2 ;
37252 int ecode2 = 0 ;
37253 PyObject * obj0 = 0 ;
37254 PyObject * obj1 = 0 ;
37255 char * kwnames[] = {
37256 (char *) "self",(char *) "accept", NULL
37257 };
37258
37259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37261 if (!SWIG_IsOK(res1)) {
37262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37263 }
37264 arg1 = reinterpret_cast< wxWindow * >(argp1);
37265 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37266 if (!SWIG_IsOK(ecode2)) {
37267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37268 }
37269 arg2 = static_cast< bool >(val2);
37270 {
37271 PyThreadState* __tstate = wxPyBeginAllowThreads();
37272 wxWindow_DragAcceptFiles(arg1,arg2);
37273 wxPyEndAllowThreads(__tstate);
37274 if (PyErr_Occurred()) SWIG_fail;
37275 }
37276 resultobj = SWIG_Py_Void();
37277 return resultobj;
37278 fail:
37279 return NULL;
37280 }
37281
37282
37283 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37284 PyObject *resultobj = 0;
37285 wxWindow *arg1 = (wxWindow *) 0 ;
37286 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37287 void *argp1 = 0 ;
37288 int res1 = 0 ;
37289 int res2 = 0 ;
37290 PyObject * obj0 = 0 ;
37291 PyObject * obj1 = 0 ;
37292 char * kwnames[] = {
37293 (char *) "self",(char *) "constraints", NULL
37294 };
37295
37296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37298 if (!SWIG_IsOK(res1)) {
37299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37300 }
37301 arg1 = reinterpret_cast< wxWindow * >(argp1);
37302 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37303 if (!SWIG_IsOK(res2)) {
37304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37305 }
37306 {
37307 PyThreadState* __tstate = wxPyBeginAllowThreads();
37308 (arg1)->SetConstraints(arg2);
37309 wxPyEndAllowThreads(__tstate);
37310 if (PyErr_Occurred()) SWIG_fail;
37311 }
37312 resultobj = SWIG_Py_Void();
37313 return resultobj;
37314 fail:
37315 return NULL;
37316 }
37317
37318
37319 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37320 PyObject *resultobj = 0;
37321 wxWindow *arg1 = (wxWindow *) 0 ;
37322 wxLayoutConstraints *result = 0 ;
37323 void *argp1 = 0 ;
37324 int res1 = 0 ;
37325 PyObject *swig_obj[1] ;
37326
37327 if (!args) SWIG_fail;
37328 swig_obj[0] = args;
37329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37330 if (!SWIG_IsOK(res1)) {
37331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37332 }
37333 arg1 = reinterpret_cast< wxWindow * >(argp1);
37334 {
37335 PyThreadState* __tstate = wxPyBeginAllowThreads();
37336 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37337 wxPyEndAllowThreads(__tstate);
37338 if (PyErr_Occurred()) SWIG_fail;
37339 }
37340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37341 return resultobj;
37342 fail:
37343 return NULL;
37344 }
37345
37346
37347 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37348 PyObject *resultobj = 0;
37349 wxWindow *arg1 = (wxWindow *) 0 ;
37350 bool arg2 ;
37351 void *argp1 = 0 ;
37352 int res1 = 0 ;
37353 bool val2 ;
37354 int ecode2 = 0 ;
37355 PyObject * obj0 = 0 ;
37356 PyObject * obj1 = 0 ;
37357 char * kwnames[] = {
37358 (char *) "self",(char *) "autoLayout", NULL
37359 };
37360
37361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37363 if (!SWIG_IsOK(res1)) {
37364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37365 }
37366 arg1 = reinterpret_cast< wxWindow * >(argp1);
37367 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37368 if (!SWIG_IsOK(ecode2)) {
37369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37370 }
37371 arg2 = static_cast< bool >(val2);
37372 {
37373 PyThreadState* __tstate = wxPyBeginAllowThreads();
37374 (arg1)->SetAutoLayout(arg2);
37375 wxPyEndAllowThreads(__tstate);
37376 if (PyErr_Occurred()) SWIG_fail;
37377 }
37378 resultobj = SWIG_Py_Void();
37379 return resultobj;
37380 fail:
37381 return NULL;
37382 }
37383
37384
37385 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37386 PyObject *resultobj = 0;
37387 wxWindow *arg1 = (wxWindow *) 0 ;
37388 bool result;
37389 void *argp1 = 0 ;
37390 int res1 = 0 ;
37391 PyObject *swig_obj[1] ;
37392
37393 if (!args) SWIG_fail;
37394 swig_obj[0] = args;
37395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37396 if (!SWIG_IsOK(res1)) {
37397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37398 }
37399 arg1 = reinterpret_cast< wxWindow * >(argp1);
37400 {
37401 PyThreadState* __tstate = wxPyBeginAllowThreads();
37402 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37403 wxPyEndAllowThreads(__tstate);
37404 if (PyErr_Occurred()) SWIG_fail;
37405 }
37406 {
37407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37408 }
37409 return resultobj;
37410 fail:
37411 return NULL;
37412 }
37413
37414
37415 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37416 PyObject *resultobj = 0;
37417 wxWindow *arg1 = (wxWindow *) 0 ;
37418 bool result;
37419 void *argp1 = 0 ;
37420 int res1 = 0 ;
37421 PyObject *swig_obj[1] ;
37422
37423 if (!args) SWIG_fail;
37424 swig_obj[0] = args;
37425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37426 if (!SWIG_IsOK(res1)) {
37427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37428 }
37429 arg1 = reinterpret_cast< wxWindow * >(argp1);
37430 {
37431 PyThreadState* __tstate = wxPyBeginAllowThreads();
37432 result = (bool)(arg1)->Layout();
37433 wxPyEndAllowThreads(__tstate);
37434 if (PyErr_Occurred()) SWIG_fail;
37435 }
37436 {
37437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37438 }
37439 return resultobj;
37440 fail:
37441 return NULL;
37442 }
37443
37444
37445 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37446 PyObject *resultobj = 0;
37447 wxWindow *arg1 = (wxWindow *) 0 ;
37448 wxSizer *arg2 = (wxSizer *) 0 ;
37449 bool arg3 = (bool) true ;
37450 void *argp1 = 0 ;
37451 int res1 = 0 ;
37452 int res2 = 0 ;
37453 bool val3 ;
37454 int ecode3 = 0 ;
37455 PyObject * obj0 = 0 ;
37456 PyObject * obj1 = 0 ;
37457 PyObject * obj2 = 0 ;
37458 char * kwnames[] = {
37459 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37460 };
37461
37462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37464 if (!SWIG_IsOK(res1)) {
37465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37466 }
37467 arg1 = reinterpret_cast< wxWindow * >(argp1);
37468 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37469 if (!SWIG_IsOK(res2)) {
37470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37471 }
37472 if (obj2) {
37473 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37474 if (!SWIG_IsOK(ecode3)) {
37475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37476 }
37477 arg3 = static_cast< bool >(val3);
37478 }
37479 {
37480 PyThreadState* __tstate = wxPyBeginAllowThreads();
37481 (arg1)->SetSizer(arg2,arg3);
37482 wxPyEndAllowThreads(__tstate);
37483 if (PyErr_Occurred()) SWIG_fail;
37484 }
37485 resultobj = SWIG_Py_Void();
37486 return resultobj;
37487 fail:
37488 return NULL;
37489 }
37490
37491
37492 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37493 PyObject *resultobj = 0;
37494 wxWindow *arg1 = (wxWindow *) 0 ;
37495 wxSizer *arg2 = (wxSizer *) 0 ;
37496 bool arg3 = (bool) true ;
37497 void *argp1 = 0 ;
37498 int res1 = 0 ;
37499 int res2 = 0 ;
37500 bool val3 ;
37501 int ecode3 = 0 ;
37502 PyObject * obj0 = 0 ;
37503 PyObject * obj1 = 0 ;
37504 PyObject * obj2 = 0 ;
37505 char * kwnames[] = {
37506 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37507 };
37508
37509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37511 if (!SWIG_IsOK(res1)) {
37512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37513 }
37514 arg1 = reinterpret_cast< wxWindow * >(argp1);
37515 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37516 if (!SWIG_IsOK(res2)) {
37517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37518 }
37519 if (obj2) {
37520 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37521 if (!SWIG_IsOK(ecode3)) {
37522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37523 }
37524 arg3 = static_cast< bool >(val3);
37525 }
37526 {
37527 PyThreadState* __tstate = wxPyBeginAllowThreads();
37528 (arg1)->SetSizerAndFit(arg2,arg3);
37529 wxPyEndAllowThreads(__tstate);
37530 if (PyErr_Occurred()) SWIG_fail;
37531 }
37532 resultobj = SWIG_Py_Void();
37533 return resultobj;
37534 fail:
37535 return NULL;
37536 }
37537
37538
37539 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37540 PyObject *resultobj = 0;
37541 wxWindow *arg1 = (wxWindow *) 0 ;
37542 wxSizer *result = 0 ;
37543 void *argp1 = 0 ;
37544 int res1 = 0 ;
37545 PyObject *swig_obj[1] ;
37546
37547 if (!args) SWIG_fail;
37548 swig_obj[0] = args;
37549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37550 if (!SWIG_IsOK(res1)) {
37551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37552 }
37553 arg1 = reinterpret_cast< wxWindow * >(argp1);
37554 {
37555 PyThreadState* __tstate = wxPyBeginAllowThreads();
37556 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37557 wxPyEndAllowThreads(__tstate);
37558 if (PyErr_Occurred()) SWIG_fail;
37559 }
37560 {
37561 resultobj = wxPyMake_wxObject(result, (bool)0);
37562 }
37563 return resultobj;
37564 fail:
37565 return NULL;
37566 }
37567
37568
37569 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37570 PyObject *resultobj = 0;
37571 wxWindow *arg1 = (wxWindow *) 0 ;
37572 wxSizer *arg2 = (wxSizer *) 0 ;
37573 void *argp1 = 0 ;
37574 int res1 = 0 ;
37575 void *argp2 = 0 ;
37576 int res2 = 0 ;
37577 PyObject * obj0 = 0 ;
37578 PyObject * obj1 = 0 ;
37579 char * kwnames[] = {
37580 (char *) "self",(char *) "sizer", NULL
37581 };
37582
37583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37585 if (!SWIG_IsOK(res1)) {
37586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37587 }
37588 arg1 = reinterpret_cast< wxWindow * >(argp1);
37589 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37590 if (!SWIG_IsOK(res2)) {
37591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37592 }
37593 arg2 = reinterpret_cast< wxSizer * >(argp2);
37594 {
37595 PyThreadState* __tstate = wxPyBeginAllowThreads();
37596 (arg1)->SetContainingSizer(arg2);
37597 wxPyEndAllowThreads(__tstate);
37598 if (PyErr_Occurred()) SWIG_fail;
37599 }
37600 resultobj = SWIG_Py_Void();
37601 return resultobj;
37602 fail:
37603 return NULL;
37604 }
37605
37606
37607 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37608 PyObject *resultobj = 0;
37609 wxWindow *arg1 = (wxWindow *) 0 ;
37610 wxSizer *result = 0 ;
37611 void *argp1 = 0 ;
37612 int res1 = 0 ;
37613 PyObject *swig_obj[1] ;
37614
37615 if (!args) SWIG_fail;
37616 swig_obj[0] = args;
37617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37618 if (!SWIG_IsOK(res1)) {
37619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37620 }
37621 arg1 = reinterpret_cast< wxWindow * >(argp1);
37622 {
37623 PyThreadState* __tstate = wxPyBeginAllowThreads();
37624 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37625 wxPyEndAllowThreads(__tstate);
37626 if (PyErr_Occurred()) SWIG_fail;
37627 }
37628 {
37629 resultobj = wxPyMake_wxObject(result, (bool)0);
37630 }
37631 return resultobj;
37632 fail:
37633 return NULL;
37634 }
37635
37636
37637 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37638 PyObject *resultobj = 0;
37639 wxWindow *arg1 = (wxWindow *) 0 ;
37640 void *argp1 = 0 ;
37641 int res1 = 0 ;
37642 PyObject *swig_obj[1] ;
37643
37644 if (!args) SWIG_fail;
37645 swig_obj[0] = args;
37646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37647 if (!SWIG_IsOK(res1)) {
37648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37649 }
37650 arg1 = reinterpret_cast< wxWindow * >(argp1);
37651 {
37652 PyThreadState* __tstate = wxPyBeginAllowThreads();
37653 (arg1)->InheritAttributes();
37654 wxPyEndAllowThreads(__tstate);
37655 if (PyErr_Occurred()) SWIG_fail;
37656 }
37657 resultobj = SWIG_Py_Void();
37658 return resultobj;
37659 fail:
37660 return NULL;
37661 }
37662
37663
37664 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37665 PyObject *resultobj = 0;
37666 wxWindow *arg1 = (wxWindow *) 0 ;
37667 bool result;
37668 void *argp1 = 0 ;
37669 int res1 = 0 ;
37670 PyObject *swig_obj[1] ;
37671
37672 if (!args) SWIG_fail;
37673 swig_obj[0] = args;
37674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37675 if (!SWIG_IsOK(res1)) {
37676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37677 }
37678 arg1 = reinterpret_cast< wxWindow * >(argp1);
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37682 wxPyEndAllowThreads(__tstate);
37683 if (PyErr_Occurred()) SWIG_fail;
37684 }
37685 {
37686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37687 }
37688 return resultobj;
37689 fail:
37690 return NULL;
37691 }
37692
37693
37694 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37695 PyObject *obj;
37696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37697 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37698 return SWIG_Py_Void();
37699 }
37700
37701 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37702 return SWIG_Python_InitShadowInstance(args);
37703 }
37704
37705 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37706 PyObject *resultobj = 0;
37707 long arg1 ;
37708 wxWindow *arg2 = (wxWindow *) NULL ;
37709 wxWindow *result = 0 ;
37710 long val1 ;
37711 int ecode1 = 0 ;
37712 void *argp2 = 0 ;
37713 int res2 = 0 ;
37714 PyObject * obj0 = 0 ;
37715 PyObject * obj1 = 0 ;
37716 char * kwnames[] = {
37717 (char *) "id",(char *) "parent", NULL
37718 };
37719
37720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37721 ecode1 = SWIG_AsVal_long(obj0, &val1);
37722 if (!SWIG_IsOK(ecode1)) {
37723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37724 }
37725 arg1 = static_cast< long >(val1);
37726 if (obj1) {
37727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37728 if (!SWIG_IsOK(res2)) {
37729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37730 }
37731 arg2 = reinterpret_cast< wxWindow * >(argp2);
37732 }
37733 {
37734 if (!wxPyCheckForApp()) SWIG_fail;
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 {
37741 resultobj = wxPyMake_wxObject(result, 0);
37742 }
37743 return resultobj;
37744 fail:
37745 return NULL;
37746 }
37747
37748
37749 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37750 PyObject *resultobj = 0;
37751 wxString *arg1 = 0 ;
37752 wxWindow *arg2 = (wxWindow *) NULL ;
37753 wxWindow *result = 0 ;
37754 bool temp1 = false ;
37755 void *argp2 = 0 ;
37756 int res2 = 0 ;
37757 PyObject * obj0 = 0 ;
37758 PyObject * obj1 = 0 ;
37759 char * kwnames[] = {
37760 (char *) "name",(char *) "parent", NULL
37761 };
37762
37763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37764 {
37765 arg1 = wxString_in_helper(obj0);
37766 if (arg1 == NULL) SWIG_fail;
37767 temp1 = true;
37768 }
37769 if (obj1) {
37770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37771 if (!SWIG_IsOK(res2)) {
37772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37773 }
37774 arg2 = reinterpret_cast< wxWindow * >(argp2);
37775 }
37776 {
37777 if (!wxPyCheckForApp()) SWIG_fail;
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37780 wxPyEndAllowThreads(__tstate);
37781 if (PyErr_Occurred()) SWIG_fail;
37782 }
37783 {
37784 resultobj = wxPyMake_wxObject(result, 0);
37785 }
37786 {
37787 if (temp1)
37788 delete arg1;
37789 }
37790 return resultobj;
37791 fail:
37792 {
37793 if (temp1)
37794 delete arg1;
37795 }
37796 return NULL;
37797 }
37798
37799
37800 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37801 PyObject *resultobj = 0;
37802 wxString *arg1 = 0 ;
37803 wxWindow *arg2 = (wxWindow *) NULL ;
37804 wxWindow *result = 0 ;
37805 bool temp1 = false ;
37806 void *argp2 = 0 ;
37807 int res2 = 0 ;
37808 PyObject * obj0 = 0 ;
37809 PyObject * obj1 = 0 ;
37810 char * kwnames[] = {
37811 (char *) "label",(char *) "parent", NULL
37812 };
37813
37814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37815 {
37816 arg1 = wxString_in_helper(obj0);
37817 if (arg1 == NULL) SWIG_fail;
37818 temp1 = true;
37819 }
37820 if (obj1) {
37821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37822 if (!SWIG_IsOK(res2)) {
37823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37824 }
37825 arg2 = reinterpret_cast< wxWindow * >(argp2);
37826 }
37827 {
37828 if (!wxPyCheckForApp()) SWIG_fail;
37829 PyThreadState* __tstate = wxPyBeginAllowThreads();
37830 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37831 wxPyEndAllowThreads(__tstate);
37832 if (PyErr_Occurred()) SWIG_fail;
37833 }
37834 {
37835 resultobj = wxPyMake_wxObject(result, 0);
37836 }
37837 {
37838 if (temp1)
37839 delete arg1;
37840 }
37841 return resultobj;
37842 fail:
37843 {
37844 if (temp1)
37845 delete arg1;
37846 }
37847 return NULL;
37848 }
37849
37850
37851 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37852 PyObject *resultobj = 0;
37853 wxWindow *arg1 = (wxWindow *) 0 ;
37854 unsigned long arg2 ;
37855 wxWindow *result = 0 ;
37856 void *argp1 = 0 ;
37857 int res1 = 0 ;
37858 unsigned long val2 ;
37859 int ecode2 = 0 ;
37860 PyObject * obj0 = 0 ;
37861 PyObject * obj1 = 0 ;
37862 char * kwnames[] = {
37863 (char *) "parent",(char *) "_hWnd", NULL
37864 };
37865
37866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37868 if (!SWIG_IsOK(res1)) {
37869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37870 }
37871 arg1 = reinterpret_cast< wxWindow * >(argp1);
37872 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37873 if (!SWIG_IsOK(ecode2)) {
37874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37875 }
37876 arg2 = static_cast< unsigned long >(val2);
37877 {
37878 PyThreadState* __tstate = wxPyBeginAllowThreads();
37879 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37880 wxPyEndAllowThreads(__tstate);
37881 if (PyErr_Occurred()) SWIG_fail;
37882 }
37883 {
37884 resultobj = wxPyMake_wxObject(result, 0);
37885 }
37886 return resultobj;
37887 fail:
37888 return NULL;
37889 }
37890
37891
37892 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37893 PyObject *resultobj = 0;
37894 PyObject *result = 0 ;
37895
37896 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37897 {
37898 PyThreadState* __tstate = wxPyBeginAllowThreads();
37899 result = (PyObject *)GetTopLevelWindows();
37900 wxPyEndAllowThreads(__tstate);
37901 if (PyErr_Occurred()) SWIG_fail;
37902 }
37903 resultobj = result;
37904 return resultobj;
37905 fail:
37906 return NULL;
37907 }
37908
37909
37910 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37911 PyObject *resultobj = 0;
37912 wxValidator *result = 0 ;
37913
37914 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37915 {
37916 PyThreadState* __tstate = wxPyBeginAllowThreads();
37917 result = (wxValidator *)new wxValidator();
37918 wxPyEndAllowThreads(__tstate);
37919 if (PyErr_Occurred()) SWIG_fail;
37920 }
37921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37922 return resultobj;
37923 fail:
37924 return NULL;
37925 }
37926
37927
37928 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37929 PyObject *resultobj = 0;
37930 wxValidator *arg1 = (wxValidator *) 0 ;
37931 wxValidator *result = 0 ;
37932 void *argp1 = 0 ;
37933 int res1 = 0 ;
37934 PyObject *swig_obj[1] ;
37935
37936 if (!args) SWIG_fail;
37937 swig_obj[0] = args;
37938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37939 if (!SWIG_IsOK(res1)) {
37940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37941 }
37942 arg1 = reinterpret_cast< wxValidator * >(argp1);
37943 {
37944 PyThreadState* __tstate = wxPyBeginAllowThreads();
37945 result = (wxValidator *)(arg1)->Clone();
37946 wxPyEndAllowThreads(__tstate);
37947 if (PyErr_Occurred()) SWIG_fail;
37948 }
37949 {
37950 resultobj = wxPyMake_wxObject(result, 0);
37951 }
37952 return resultobj;
37953 fail:
37954 return NULL;
37955 }
37956
37957
37958 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37959 PyObject *resultobj = 0;
37960 wxValidator *arg1 = (wxValidator *) 0 ;
37961 wxWindow *arg2 = (wxWindow *) 0 ;
37962 bool result;
37963 void *argp1 = 0 ;
37964 int res1 = 0 ;
37965 void *argp2 = 0 ;
37966 int res2 = 0 ;
37967 PyObject * obj0 = 0 ;
37968 PyObject * obj1 = 0 ;
37969 char * kwnames[] = {
37970 (char *) "self",(char *) "parent", NULL
37971 };
37972
37973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37975 if (!SWIG_IsOK(res1)) {
37976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37977 }
37978 arg1 = reinterpret_cast< wxValidator * >(argp1);
37979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37980 if (!SWIG_IsOK(res2)) {
37981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37982 }
37983 arg2 = reinterpret_cast< wxWindow * >(argp2);
37984 {
37985 PyThreadState* __tstate = wxPyBeginAllowThreads();
37986 result = (bool)(arg1)->Validate(arg2);
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 {
37991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37992 }
37993 return resultobj;
37994 fail:
37995 return NULL;
37996 }
37997
37998
37999 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38000 PyObject *resultobj = 0;
38001 wxValidator *arg1 = (wxValidator *) 0 ;
38002 bool result;
38003 void *argp1 = 0 ;
38004 int res1 = 0 ;
38005 PyObject *swig_obj[1] ;
38006
38007 if (!args) SWIG_fail;
38008 swig_obj[0] = args;
38009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38010 if (!SWIG_IsOK(res1)) {
38011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38012 }
38013 arg1 = reinterpret_cast< wxValidator * >(argp1);
38014 {
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 result = (bool)(arg1)->TransferToWindow();
38017 wxPyEndAllowThreads(__tstate);
38018 if (PyErr_Occurred()) SWIG_fail;
38019 }
38020 {
38021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38022 }
38023 return resultobj;
38024 fail:
38025 return NULL;
38026 }
38027
38028
38029 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38030 PyObject *resultobj = 0;
38031 wxValidator *arg1 = (wxValidator *) 0 ;
38032 bool result;
38033 void *argp1 = 0 ;
38034 int res1 = 0 ;
38035 PyObject *swig_obj[1] ;
38036
38037 if (!args) SWIG_fail;
38038 swig_obj[0] = args;
38039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38040 if (!SWIG_IsOK(res1)) {
38041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38042 }
38043 arg1 = reinterpret_cast< wxValidator * >(argp1);
38044 {
38045 PyThreadState* __tstate = wxPyBeginAllowThreads();
38046 result = (bool)(arg1)->TransferFromWindow();
38047 wxPyEndAllowThreads(__tstate);
38048 if (PyErr_Occurred()) SWIG_fail;
38049 }
38050 {
38051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38052 }
38053 return resultobj;
38054 fail:
38055 return NULL;
38056 }
38057
38058
38059 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38060 PyObject *resultobj = 0;
38061 wxValidator *arg1 = (wxValidator *) 0 ;
38062 wxWindow *result = 0 ;
38063 void *argp1 = 0 ;
38064 int res1 = 0 ;
38065 PyObject *swig_obj[1] ;
38066
38067 if (!args) SWIG_fail;
38068 swig_obj[0] = args;
38069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38070 if (!SWIG_IsOK(res1)) {
38071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38072 }
38073 arg1 = reinterpret_cast< wxValidator * >(argp1);
38074 {
38075 PyThreadState* __tstate = wxPyBeginAllowThreads();
38076 result = (wxWindow *)(arg1)->GetWindow();
38077 wxPyEndAllowThreads(__tstate);
38078 if (PyErr_Occurred()) SWIG_fail;
38079 }
38080 {
38081 resultobj = wxPyMake_wxObject(result, 0);
38082 }
38083 return resultobj;
38084 fail:
38085 return NULL;
38086 }
38087
38088
38089 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38090 PyObject *resultobj = 0;
38091 wxValidator *arg1 = (wxValidator *) 0 ;
38092 wxWindow *arg2 = (wxWindow *) 0 ;
38093 void *argp1 = 0 ;
38094 int res1 = 0 ;
38095 void *argp2 = 0 ;
38096 int res2 = 0 ;
38097 PyObject * obj0 = 0 ;
38098 PyObject * obj1 = 0 ;
38099 char * kwnames[] = {
38100 (char *) "self",(char *) "window", NULL
38101 };
38102
38103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38105 if (!SWIG_IsOK(res1)) {
38106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38107 }
38108 arg1 = reinterpret_cast< wxValidator * >(argp1);
38109 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38110 if (!SWIG_IsOK(res2)) {
38111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38112 }
38113 arg2 = reinterpret_cast< wxWindow * >(argp2);
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 (arg1)->SetWindow(arg2);
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 resultobj = SWIG_Py_Void();
38121 return resultobj;
38122 fail:
38123 return NULL;
38124 }
38125
38126
38127 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38128 PyObject *resultobj = 0;
38129 bool result;
38130
38131 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38132 {
38133 PyThreadState* __tstate = wxPyBeginAllowThreads();
38134 result = (bool)wxValidator::IsSilent();
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 {
38139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38140 }
38141 return resultobj;
38142 fail:
38143 return NULL;
38144 }
38145
38146
38147 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38148 PyObject *resultobj = 0;
38149 int arg1 = (int) true ;
38150 int val1 ;
38151 int ecode1 = 0 ;
38152 PyObject * obj0 = 0 ;
38153 char * kwnames[] = {
38154 (char *) "doIt", NULL
38155 };
38156
38157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38158 if (obj0) {
38159 ecode1 = SWIG_AsVal_int(obj0, &val1);
38160 if (!SWIG_IsOK(ecode1)) {
38161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38162 }
38163 arg1 = static_cast< int >(val1);
38164 }
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 wxValidator::SetBellOnError(arg1);
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 resultobj = SWIG_Py_Void();
38172 return resultobj;
38173 fail:
38174 return NULL;
38175 }
38176
38177
38178 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38179 PyObject *obj;
38180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38181 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38182 return SWIG_Py_Void();
38183 }
38184
38185 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38186 return SWIG_Python_InitShadowInstance(args);
38187 }
38188
38189 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38190 PyObject *resultobj = 0;
38191 wxPyValidator *result = 0 ;
38192
38193 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38194 {
38195 PyThreadState* __tstate = wxPyBeginAllowThreads();
38196 result = (wxPyValidator *)new wxPyValidator();
38197 wxPyEndAllowThreads(__tstate);
38198 if (PyErr_Occurred()) SWIG_fail;
38199 }
38200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38201 return resultobj;
38202 fail:
38203 return NULL;
38204 }
38205
38206
38207 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38208 PyObject *resultobj = 0;
38209 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38210 PyObject *arg2 = (PyObject *) 0 ;
38211 PyObject *arg3 = (PyObject *) 0 ;
38212 int arg4 = (int) true ;
38213 void *argp1 = 0 ;
38214 int res1 = 0 ;
38215 int val4 ;
38216 int ecode4 = 0 ;
38217 PyObject * obj0 = 0 ;
38218 PyObject * obj1 = 0 ;
38219 PyObject * obj2 = 0 ;
38220 PyObject * obj3 = 0 ;
38221 char * kwnames[] = {
38222 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38223 };
38224
38225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38227 if (!SWIG_IsOK(res1)) {
38228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38229 }
38230 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38231 arg2 = obj1;
38232 arg3 = obj2;
38233 if (obj3) {
38234 ecode4 = SWIG_AsVal_int(obj3, &val4);
38235 if (!SWIG_IsOK(ecode4)) {
38236 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38237 }
38238 arg4 = static_cast< int >(val4);
38239 }
38240 {
38241 PyThreadState* __tstate = wxPyBeginAllowThreads();
38242 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38243 wxPyEndAllowThreads(__tstate);
38244 if (PyErr_Occurred()) SWIG_fail;
38245 }
38246 resultobj = SWIG_Py_Void();
38247 return resultobj;
38248 fail:
38249 return NULL;
38250 }
38251
38252
38253 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38254 PyObject *obj;
38255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38256 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38257 return SWIG_Py_Void();
38258 }
38259
38260 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38261 return SWIG_Python_InitShadowInstance(args);
38262 }
38263
38264 SWIGINTERN int DefaultValidator_set(PyObject *) {
38265 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38266 return 1;
38267 }
38268
38269
38270 SWIGINTERN PyObject *DefaultValidator_get(void) {
38271 PyObject *pyobj = 0;
38272
38273 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38274 return pyobj;
38275 }
38276
38277
38278 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38279 PyObject *resultobj = 0;
38280 wxString const &arg1_defvalue = wxPyEmptyString ;
38281 wxString *arg1 = (wxString *) &arg1_defvalue ;
38282 long arg2 = (long) 0 ;
38283 wxMenu *result = 0 ;
38284 bool temp1 = false ;
38285 long val2 ;
38286 int ecode2 = 0 ;
38287 PyObject * obj0 = 0 ;
38288 PyObject * obj1 = 0 ;
38289 char * kwnames[] = {
38290 (char *) "title",(char *) "style", NULL
38291 };
38292
38293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38294 if (obj0) {
38295 {
38296 arg1 = wxString_in_helper(obj0);
38297 if (arg1 == NULL) SWIG_fail;
38298 temp1 = true;
38299 }
38300 }
38301 if (obj1) {
38302 ecode2 = SWIG_AsVal_long(obj1, &val2);
38303 if (!SWIG_IsOK(ecode2)) {
38304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38305 }
38306 arg2 = static_cast< long >(val2);
38307 }
38308 {
38309 if (!wxPyCheckForApp()) SWIG_fail;
38310 PyThreadState* __tstate = wxPyBeginAllowThreads();
38311 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38312 wxPyEndAllowThreads(__tstate);
38313 if (PyErr_Occurred()) SWIG_fail;
38314 }
38315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38316 {
38317 if (temp1)
38318 delete arg1;
38319 }
38320 return resultobj;
38321 fail:
38322 {
38323 if (temp1)
38324 delete arg1;
38325 }
38326 return NULL;
38327 }
38328
38329
38330 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38331 PyObject *resultobj = 0;
38332 wxMenu *arg1 = (wxMenu *) 0 ;
38333 int arg2 ;
38334 wxString *arg3 = 0 ;
38335 wxString const &arg4_defvalue = wxPyEmptyString ;
38336 wxString *arg4 = (wxString *) &arg4_defvalue ;
38337 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38338 wxMenuItem *result = 0 ;
38339 void *argp1 = 0 ;
38340 int res1 = 0 ;
38341 int val2 ;
38342 int ecode2 = 0 ;
38343 bool temp3 = false ;
38344 bool temp4 = false ;
38345 int val5 ;
38346 int ecode5 = 0 ;
38347 PyObject * obj0 = 0 ;
38348 PyObject * obj1 = 0 ;
38349 PyObject * obj2 = 0 ;
38350 PyObject * obj3 = 0 ;
38351 PyObject * obj4 = 0 ;
38352 char * kwnames[] = {
38353 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38354 };
38355
38356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38358 if (!SWIG_IsOK(res1)) {
38359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38360 }
38361 arg1 = reinterpret_cast< wxMenu * >(argp1);
38362 ecode2 = SWIG_AsVal_int(obj1, &val2);
38363 if (!SWIG_IsOK(ecode2)) {
38364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38365 }
38366 arg2 = static_cast< int >(val2);
38367 {
38368 arg3 = wxString_in_helper(obj2);
38369 if (arg3 == NULL) SWIG_fail;
38370 temp3 = true;
38371 }
38372 if (obj3) {
38373 {
38374 arg4 = wxString_in_helper(obj3);
38375 if (arg4 == NULL) SWIG_fail;
38376 temp4 = true;
38377 }
38378 }
38379 if (obj4) {
38380 ecode5 = SWIG_AsVal_int(obj4, &val5);
38381 if (!SWIG_IsOK(ecode5)) {
38382 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38383 }
38384 arg5 = static_cast< wxItemKind >(val5);
38385 }
38386 {
38387 PyThreadState* __tstate = wxPyBeginAllowThreads();
38388 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38389 wxPyEndAllowThreads(__tstate);
38390 if (PyErr_Occurred()) SWIG_fail;
38391 }
38392 {
38393 resultobj = wxPyMake_wxObject(result, (bool)0);
38394 }
38395 {
38396 if (temp3)
38397 delete arg3;
38398 }
38399 {
38400 if (temp4)
38401 delete arg4;
38402 }
38403 return resultobj;
38404 fail:
38405 {
38406 if (temp3)
38407 delete arg3;
38408 }
38409 {
38410 if (temp4)
38411 delete arg4;
38412 }
38413 return NULL;
38414 }
38415
38416
38417 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38418 PyObject *resultobj = 0;
38419 wxMenu *arg1 = (wxMenu *) 0 ;
38420 wxMenuItem *result = 0 ;
38421 void *argp1 = 0 ;
38422 int res1 = 0 ;
38423 PyObject *swig_obj[1] ;
38424
38425 if (!args) SWIG_fail;
38426 swig_obj[0] = args;
38427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38428 if (!SWIG_IsOK(res1)) {
38429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38430 }
38431 arg1 = reinterpret_cast< wxMenu * >(argp1);
38432 {
38433 PyThreadState* __tstate = wxPyBeginAllowThreads();
38434 result = (wxMenuItem *)(arg1)->AppendSeparator();
38435 wxPyEndAllowThreads(__tstate);
38436 if (PyErr_Occurred()) SWIG_fail;
38437 }
38438 {
38439 resultobj = wxPyMake_wxObject(result, (bool)0);
38440 }
38441 return resultobj;
38442 fail:
38443 return NULL;
38444 }
38445
38446
38447 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38448 PyObject *resultobj = 0;
38449 wxMenu *arg1 = (wxMenu *) 0 ;
38450 int arg2 ;
38451 wxString *arg3 = 0 ;
38452 wxString const &arg4_defvalue = wxPyEmptyString ;
38453 wxString *arg4 = (wxString *) &arg4_defvalue ;
38454 wxMenuItem *result = 0 ;
38455 void *argp1 = 0 ;
38456 int res1 = 0 ;
38457 int val2 ;
38458 int ecode2 = 0 ;
38459 bool temp3 = false ;
38460 bool temp4 = false ;
38461 PyObject * obj0 = 0 ;
38462 PyObject * obj1 = 0 ;
38463 PyObject * obj2 = 0 ;
38464 PyObject * obj3 = 0 ;
38465 char * kwnames[] = {
38466 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38467 };
38468
38469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38471 if (!SWIG_IsOK(res1)) {
38472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38473 }
38474 arg1 = reinterpret_cast< wxMenu * >(argp1);
38475 ecode2 = SWIG_AsVal_int(obj1, &val2);
38476 if (!SWIG_IsOK(ecode2)) {
38477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38478 }
38479 arg2 = static_cast< int >(val2);
38480 {
38481 arg3 = wxString_in_helper(obj2);
38482 if (arg3 == NULL) SWIG_fail;
38483 temp3 = true;
38484 }
38485 if (obj3) {
38486 {
38487 arg4 = wxString_in_helper(obj3);
38488 if (arg4 == NULL) SWIG_fail;
38489 temp4 = true;
38490 }
38491 }
38492 {
38493 PyThreadState* __tstate = wxPyBeginAllowThreads();
38494 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38495 wxPyEndAllowThreads(__tstate);
38496 if (PyErr_Occurred()) SWIG_fail;
38497 }
38498 {
38499 resultobj = wxPyMake_wxObject(result, (bool)0);
38500 }
38501 {
38502 if (temp3)
38503 delete arg3;
38504 }
38505 {
38506 if (temp4)
38507 delete arg4;
38508 }
38509 return resultobj;
38510 fail:
38511 {
38512 if (temp3)
38513 delete arg3;
38514 }
38515 {
38516 if (temp4)
38517 delete arg4;
38518 }
38519 return NULL;
38520 }
38521
38522
38523 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38524 PyObject *resultobj = 0;
38525 wxMenu *arg1 = (wxMenu *) 0 ;
38526 int arg2 ;
38527 wxString *arg3 = 0 ;
38528 wxString const &arg4_defvalue = wxPyEmptyString ;
38529 wxString *arg4 = (wxString *) &arg4_defvalue ;
38530 wxMenuItem *result = 0 ;
38531 void *argp1 = 0 ;
38532 int res1 = 0 ;
38533 int val2 ;
38534 int ecode2 = 0 ;
38535 bool temp3 = false ;
38536 bool temp4 = false ;
38537 PyObject * obj0 = 0 ;
38538 PyObject * obj1 = 0 ;
38539 PyObject * obj2 = 0 ;
38540 PyObject * obj3 = 0 ;
38541 char * kwnames[] = {
38542 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38543 };
38544
38545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38547 if (!SWIG_IsOK(res1)) {
38548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38549 }
38550 arg1 = reinterpret_cast< wxMenu * >(argp1);
38551 ecode2 = SWIG_AsVal_int(obj1, &val2);
38552 if (!SWIG_IsOK(ecode2)) {
38553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38554 }
38555 arg2 = static_cast< int >(val2);
38556 {
38557 arg3 = wxString_in_helper(obj2);
38558 if (arg3 == NULL) SWIG_fail;
38559 temp3 = true;
38560 }
38561 if (obj3) {
38562 {
38563 arg4 = wxString_in_helper(obj3);
38564 if (arg4 == NULL) SWIG_fail;
38565 temp4 = true;
38566 }
38567 }
38568 {
38569 PyThreadState* __tstate = wxPyBeginAllowThreads();
38570 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38571 wxPyEndAllowThreads(__tstate);
38572 if (PyErr_Occurred()) SWIG_fail;
38573 }
38574 {
38575 resultobj = wxPyMake_wxObject(result, (bool)0);
38576 }
38577 {
38578 if (temp3)
38579 delete arg3;
38580 }
38581 {
38582 if (temp4)
38583 delete arg4;
38584 }
38585 return resultobj;
38586 fail:
38587 {
38588 if (temp3)
38589 delete arg3;
38590 }
38591 {
38592 if (temp4)
38593 delete arg4;
38594 }
38595 return NULL;
38596 }
38597
38598
38599 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38600 PyObject *resultobj = 0;
38601 wxMenu *arg1 = (wxMenu *) 0 ;
38602 int arg2 ;
38603 wxString *arg3 = 0 ;
38604 wxMenu *arg4 = (wxMenu *) 0 ;
38605 wxString const &arg5_defvalue = wxPyEmptyString ;
38606 wxString *arg5 = (wxString *) &arg5_defvalue ;
38607 wxMenuItem *result = 0 ;
38608 void *argp1 = 0 ;
38609 int res1 = 0 ;
38610 int val2 ;
38611 int ecode2 = 0 ;
38612 bool temp3 = false ;
38613 void *argp4 = 0 ;
38614 int res4 = 0 ;
38615 bool temp5 = false ;
38616 PyObject * obj0 = 0 ;
38617 PyObject * obj1 = 0 ;
38618 PyObject * obj2 = 0 ;
38619 PyObject * obj3 = 0 ;
38620 PyObject * obj4 = 0 ;
38621 char * kwnames[] = {
38622 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38623 };
38624
38625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38627 if (!SWIG_IsOK(res1)) {
38628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38629 }
38630 arg1 = reinterpret_cast< wxMenu * >(argp1);
38631 ecode2 = SWIG_AsVal_int(obj1, &val2);
38632 if (!SWIG_IsOK(ecode2)) {
38633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38634 }
38635 arg2 = static_cast< int >(val2);
38636 {
38637 arg3 = wxString_in_helper(obj2);
38638 if (arg3 == NULL) SWIG_fail;
38639 temp3 = true;
38640 }
38641 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38642 if (!SWIG_IsOK(res4)) {
38643 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38644 }
38645 arg4 = reinterpret_cast< wxMenu * >(argp4);
38646 if (obj4) {
38647 {
38648 arg5 = wxString_in_helper(obj4);
38649 if (arg5 == NULL) SWIG_fail;
38650 temp5 = true;
38651 }
38652 }
38653 {
38654 PyThreadState* __tstate = wxPyBeginAllowThreads();
38655 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38656 wxPyEndAllowThreads(__tstate);
38657 if (PyErr_Occurred()) SWIG_fail;
38658 }
38659 {
38660 resultobj = wxPyMake_wxObject(result, (bool)0);
38661 }
38662 {
38663 if (temp3)
38664 delete arg3;
38665 }
38666 {
38667 if (temp5)
38668 delete arg5;
38669 }
38670 return resultobj;
38671 fail:
38672 {
38673 if (temp3)
38674 delete arg3;
38675 }
38676 {
38677 if (temp5)
38678 delete arg5;
38679 }
38680 return NULL;
38681 }
38682
38683
38684 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38685 PyObject *resultobj = 0;
38686 wxMenu *arg1 = (wxMenu *) 0 ;
38687 wxMenu *arg2 = (wxMenu *) 0 ;
38688 wxString *arg3 = 0 ;
38689 wxString const &arg4_defvalue = wxPyEmptyString ;
38690 wxString *arg4 = (wxString *) &arg4_defvalue ;
38691 wxMenuItem *result = 0 ;
38692 void *argp1 = 0 ;
38693 int res1 = 0 ;
38694 void *argp2 = 0 ;
38695 int res2 = 0 ;
38696 bool temp3 = false ;
38697 bool temp4 = false ;
38698 PyObject * obj0 = 0 ;
38699 PyObject * obj1 = 0 ;
38700 PyObject * obj2 = 0 ;
38701 PyObject * obj3 = 0 ;
38702 char * kwnames[] = {
38703 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38704 };
38705
38706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38708 if (!SWIG_IsOK(res1)) {
38709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38710 }
38711 arg1 = reinterpret_cast< wxMenu * >(argp1);
38712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38713 if (!SWIG_IsOK(res2)) {
38714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38715 }
38716 arg2 = reinterpret_cast< wxMenu * >(argp2);
38717 {
38718 arg3 = wxString_in_helper(obj2);
38719 if (arg3 == NULL) SWIG_fail;
38720 temp3 = true;
38721 }
38722 if (obj3) {
38723 {
38724 arg4 = wxString_in_helper(obj3);
38725 if (arg4 == NULL) SWIG_fail;
38726 temp4 = true;
38727 }
38728 }
38729 {
38730 PyThreadState* __tstate = wxPyBeginAllowThreads();
38731 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38732 wxPyEndAllowThreads(__tstate);
38733 if (PyErr_Occurred()) SWIG_fail;
38734 }
38735 {
38736 resultobj = wxPyMake_wxObject(result, (bool)0);
38737 }
38738 {
38739 if (temp3)
38740 delete arg3;
38741 }
38742 {
38743 if (temp4)
38744 delete arg4;
38745 }
38746 return resultobj;
38747 fail:
38748 {
38749 if (temp3)
38750 delete arg3;
38751 }
38752 {
38753 if (temp4)
38754 delete arg4;
38755 }
38756 return NULL;
38757 }
38758
38759
38760 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38761 PyObject *resultobj = 0;
38762 wxMenu *arg1 = (wxMenu *) 0 ;
38763 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38764 wxMenuItem *result = 0 ;
38765 void *argp1 = 0 ;
38766 int res1 = 0 ;
38767 int res2 = 0 ;
38768 PyObject * obj0 = 0 ;
38769 PyObject * obj1 = 0 ;
38770 char * kwnames[] = {
38771 (char *) "self",(char *) "item", NULL
38772 };
38773
38774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) 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_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38778 }
38779 arg1 = reinterpret_cast< wxMenu * >(argp1);
38780 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38781 if (!SWIG_IsOK(res2)) {
38782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38783 }
38784 {
38785 PyThreadState* __tstate = wxPyBeginAllowThreads();
38786 result = (wxMenuItem *)(arg1)->Append(arg2);
38787 wxPyEndAllowThreads(__tstate);
38788 if (PyErr_Occurred()) SWIG_fail;
38789 }
38790 {
38791 resultobj = wxPyMake_wxObject(result, (bool)0);
38792 }
38793 return resultobj;
38794 fail:
38795 return NULL;
38796 }
38797
38798
38799 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38800 PyObject *resultobj = 0;
38801 wxMenu *arg1 = (wxMenu *) 0 ;
38802 size_t arg2 ;
38803 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38804 wxMenuItem *result = 0 ;
38805 void *argp1 = 0 ;
38806 int res1 = 0 ;
38807 size_t val2 ;
38808 int ecode2 = 0 ;
38809 int res3 = 0 ;
38810 PyObject * obj0 = 0 ;
38811 PyObject * obj1 = 0 ;
38812 PyObject * obj2 = 0 ;
38813 char * kwnames[] = {
38814 (char *) "self",(char *) "pos",(char *) "item", NULL
38815 };
38816
38817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38819 if (!SWIG_IsOK(res1)) {
38820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38821 }
38822 arg1 = reinterpret_cast< wxMenu * >(argp1);
38823 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38824 if (!SWIG_IsOK(ecode2)) {
38825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38826 }
38827 arg2 = static_cast< size_t >(val2);
38828 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38829 if (!SWIG_IsOK(res3)) {
38830 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38831 }
38832 {
38833 PyThreadState* __tstate = wxPyBeginAllowThreads();
38834 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38835 wxPyEndAllowThreads(__tstate);
38836 if (PyErr_Occurred()) SWIG_fail;
38837 }
38838 {
38839 resultobj = wxPyMake_wxObject(result, (bool)0);
38840 }
38841 return resultobj;
38842 fail:
38843 return NULL;
38844 }
38845
38846
38847 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38848 PyObject *resultobj = 0;
38849 wxMenu *arg1 = (wxMenu *) 0 ;
38850 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38851 wxMenuItem *result = 0 ;
38852 void *argp1 = 0 ;
38853 int res1 = 0 ;
38854 int res2 = 0 ;
38855 PyObject * obj0 = 0 ;
38856 PyObject * obj1 = 0 ;
38857 char * kwnames[] = {
38858 (char *) "self",(char *) "item", NULL
38859 };
38860
38861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38863 if (!SWIG_IsOK(res1)) {
38864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38865 }
38866 arg1 = reinterpret_cast< wxMenu * >(argp1);
38867 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38868 if (!SWIG_IsOK(res2)) {
38869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38870 }
38871 {
38872 PyThreadState* __tstate = wxPyBeginAllowThreads();
38873 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38874 wxPyEndAllowThreads(__tstate);
38875 if (PyErr_Occurred()) SWIG_fail;
38876 }
38877 {
38878 resultobj = wxPyMake_wxObject(result, (bool)0);
38879 }
38880 return resultobj;
38881 fail:
38882 return NULL;
38883 }
38884
38885
38886 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38887 PyObject *resultobj = 0;
38888 wxMenu *arg1 = (wxMenu *) 0 ;
38889 void *argp1 = 0 ;
38890 int res1 = 0 ;
38891 PyObject *swig_obj[1] ;
38892
38893 if (!args) SWIG_fail;
38894 swig_obj[0] = args;
38895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38896 if (!SWIG_IsOK(res1)) {
38897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38898 }
38899 arg1 = reinterpret_cast< wxMenu * >(argp1);
38900 {
38901 PyThreadState* __tstate = wxPyBeginAllowThreads();
38902 (arg1)->Break();
38903 wxPyEndAllowThreads(__tstate);
38904 if (PyErr_Occurred()) SWIG_fail;
38905 }
38906 resultobj = SWIG_Py_Void();
38907 return resultobj;
38908 fail:
38909 return NULL;
38910 }
38911
38912
38913 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38914 PyObject *resultobj = 0;
38915 wxMenu *arg1 = (wxMenu *) 0 ;
38916 size_t arg2 ;
38917 int arg3 ;
38918 wxString *arg4 = 0 ;
38919 wxString const &arg5_defvalue = wxPyEmptyString ;
38920 wxString *arg5 = (wxString *) &arg5_defvalue ;
38921 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38922 wxMenuItem *result = 0 ;
38923 void *argp1 = 0 ;
38924 int res1 = 0 ;
38925 size_t val2 ;
38926 int ecode2 = 0 ;
38927 int val3 ;
38928 int ecode3 = 0 ;
38929 bool temp4 = false ;
38930 bool temp5 = false ;
38931 int val6 ;
38932 int ecode6 = 0 ;
38933 PyObject * obj0 = 0 ;
38934 PyObject * obj1 = 0 ;
38935 PyObject * obj2 = 0 ;
38936 PyObject * obj3 = 0 ;
38937 PyObject * obj4 = 0 ;
38938 PyObject * obj5 = 0 ;
38939 char * kwnames[] = {
38940 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38941 };
38942
38943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38945 if (!SWIG_IsOK(res1)) {
38946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38947 }
38948 arg1 = reinterpret_cast< wxMenu * >(argp1);
38949 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38950 if (!SWIG_IsOK(ecode2)) {
38951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38952 }
38953 arg2 = static_cast< size_t >(val2);
38954 ecode3 = SWIG_AsVal_int(obj2, &val3);
38955 if (!SWIG_IsOK(ecode3)) {
38956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38957 }
38958 arg3 = static_cast< int >(val3);
38959 {
38960 arg4 = wxString_in_helper(obj3);
38961 if (arg4 == NULL) SWIG_fail;
38962 temp4 = true;
38963 }
38964 if (obj4) {
38965 {
38966 arg5 = wxString_in_helper(obj4);
38967 if (arg5 == NULL) SWIG_fail;
38968 temp5 = true;
38969 }
38970 }
38971 if (obj5) {
38972 ecode6 = SWIG_AsVal_int(obj5, &val6);
38973 if (!SWIG_IsOK(ecode6)) {
38974 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38975 }
38976 arg6 = static_cast< wxItemKind >(val6);
38977 }
38978 {
38979 PyThreadState* __tstate = wxPyBeginAllowThreads();
38980 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38981 wxPyEndAllowThreads(__tstate);
38982 if (PyErr_Occurred()) SWIG_fail;
38983 }
38984 {
38985 resultobj = wxPyMake_wxObject(result, (bool)0);
38986 }
38987 {
38988 if (temp4)
38989 delete arg4;
38990 }
38991 {
38992 if (temp5)
38993 delete arg5;
38994 }
38995 return resultobj;
38996 fail:
38997 {
38998 if (temp4)
38999 delete arg4;
39000 }
39001 {
39002 if (temp5)
39003 delete arg5;
39004 }
39005 return NULL;
39006 }
39007
39008
39009 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39010 PyObject *resultobj = 0;
39011 wxMenu *arg1 = (wxMenu *) 0 ;
39012 size_t arg2 ;
39013 wxMenuItem *result = 0 ;
39014 void *argp1 = 0 ;
39015 int res1 = 0 ;
39016 size_t val2 ;
39017 int ecode2 = 0 ;
39018 PyObject * obj0 = 0 ;
39019 PyObject * obj1 = 0 ;
39020 char * kwnames[] = {
39021 (char *) "self",(char *) "pos", NULL
39022 };
39023
39024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39026 if (!SWIG_IsOK(res1)) {
39027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39028 }
39029 arg1 = reinterpret_cast< wxMenu * >(argp1);
39030 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39031 if (!SWIG_IsOK(ecode2)) {
39032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39033 }
39034 arg2 = static_cast< size_t >(val2);
39035 {
39036 PyThreadState* __tstate = wxPyBeginAllowThreads();
39037 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 {
39042 resultobj = wxPyMake_wxObject(result, (bool)0);
39043 }
39044 return resultobj;
39045 fail:
39046 return NULL;
39047 }
39048
39049
39050 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39051 PyObject *resultobj = 0;
39052 wxMenu *arg1 = (wxMenu *) 0 ;
39053 size_t arg2 ;
39054 int arg3 ;
39055 wxString *arg4 = 0 ;
39056 wxString const &arg5_defvalue = wxPyEmptyString ;
39057 wxString *arg5 = (wxString *) &arg5_defvalue ;
39058 wxMenuItem *result = 0 ;
39059 void *argp1 = 0 ;
39060 int res1 = 0 ;
39061 size_t val2 ;
39062 int ecode2 = 0 ;
39063 int val3 ;
39064 int ecode3 = 0 ;
39065 bool temp4 = false ;
39066 bool temp5 = false ;
39067 PyObject * obj0 = 0 ;
39068 PyObject * obj1 = 0 ;
39069 PyObject * obj2 = 0 ;
39070 PyObject * obj3 = 0 ;
39071 PyObject * obj4 = 0 ;
39072 char * kwnames[] = {
39073 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39074 };
39075
39076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39078 if (!SWIG_IsOK(res1)) {
39079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39080 }
39081 arg1 = reinterpret_cast< wxMenu * >(argp1);
39082 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39083 if (!SWIG_IsOK(ecode2)) {
39084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39085 }
39086 arg2 = static_cast< size_t >(val2);
39087 ecode3 = SWIG_AsVal_int(obj2, &val3);
39088 if (!SWIG_IsOK(ecode3)) {
39089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39090 }
39091 arg3 = static_cast< int >(val3);
39092 {
39093 arg4 = wxString_in_helper(obj3);
39094 if (arg4 == NULL) SWIG_fail;
39095 temp4 = true;
39096 }
39097 if (obj4) {
39098 {
39099 arg5 = wxString_in_helper(obj4);
39100 if (arg5 == NULL) SWIG_fail;
39101 temp5 = true;
39102 }
39103 }
39104 {
39105 PyThreadState* __tstate = wxPyBeginAllowThreads();
39106 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39107 wxPyEndAllowThreads(__tstate);
39108 if (PyErr_Occurred()) SWIG_fail;
39109 }
39110 {
39111 resultobj = wxPyMake_wxObject(result, (bool)0);
39112 }
39113 {
39114 if (temp4)
39115 delete arg4;
39116 }
39117 {
39118 if (temp5)
39119 delete arg5;
39120 }
39121 return resultobj;
39122 fail:
39123 {
39124 if (temp4)
39125 delete arg4;
39126 }
39127 {
39128 if (temp5)
39129 delete arg5;
39130 }
39131 return NULL;
39132 }
39133
39134
39135 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39136 PyObject *resultobj = 0;
39137 wxMenu *arg1 = (wxMenu *) 0 ;
39138 size_t arg2 ;
39139 int arg3 ;
39140 wxString *arg4 = 0 ;
39141 wxString const &arg5_defvalue = wxPyEmptyString ;
39142 wxString *arg5 = (wxString *) &arg5_defvalue ;
39143 wxMenuItem *result = 0 ;
39144 void *argp1 = 0 ;
39145 int res1 = 0 ;
39146 size_t val2 ;
39147 int ecode2 = 0 ;
39148 int val3 ;
39149 int ecode3 = 0 ;
39150 bool temp4 = false ;
39151 bool temp5 = false ;
39152 PyObject * obj0 = 0 ;
39153 PyObject * obj1 = 0 ;
39154 PyObject * obj2 = 0 ;
39155 PyObject * obj3 = 0 ;
39156 PyObject * obj4 = 0 ;
39157 char * kwnames[] = {
39158 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39159 };
39160
39161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39163 if (!SWIG_IsOK(res1)) {
39164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39165 }
39166 arg1 = reinterpret_cast< wxMenu * >(argp1);
39167 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39168 if (!SWIG_IsOK(ecode2)) {
39169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39170 }
39171 arg2 = static_cast< size_t >(val2);
39172 ecode3 = SWIG_AsVal_int(obj2, &val3);
39173 if (!SWIG_IsOK(ecode3)) {
39174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39175 }
39176 arg3 = static_cast< int >(val3);
39177 {
39178 arg4 = wxString_in_helper(obj3);
39179 if (arg4 == NULL) SWIG_fail;
39180 temp4 = true;
39181 }
39182 if (obj4) {
39183 {
39184 arg5 = wxString_in_helper(obj4);
39185 if (arg5 == NULL) SWIG_fail;
39186 temp5 = true;
39187 }
39188 }
39189 {
39190 PyThreadState* __tstate = wxPyBeginAllowThreads();
39191 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39192 wxPyEndAllowThreads(__tstate);
39193 if (PyErr_Occurred()) SWIG_fail;
39194 }
39195 {
39196 resultobj = wxPyMake_wxObject(result, (bool)0);
39197 }
39198 {
39199 if (temp4)
39200 delete arg4;
39201 }
39202 {
39203 if (temp5)
39204 delete arg5;
39205 }
39206 return resultobj;
39207 fail:
39208 {
39209 if (temp4)
39210 delete arg4;
39211 }
39212 {
39213 if (temp5)
39214 delete arg5;
39215 }
39216 return NULL;
39217 }
39218
39219
39220 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39221 PyObject *resultobj = 0;
39222 wxMenu *arg1 = (wxMenu *) 0 ;
39223 size_t arg2 ;
39224 int arg3 ;
39225 wxString *arg4 = 0 ;
39226 wxMenu *arg5 = (wxMenu *) 0 ;
39227 wxString const &arg6_defvalue = wxPyEmptyString ;
39228 wxString *arg6 = (wxString *) &arg6_defvalue ;
39229 wxMenuItem *result = 0 ;
39230 void *argp1 = 0 ;
39231 int res1 = 0 ;
39232 size_t val2 ;
39233 int ecode2 = 0 ;
39234 int val3 ;
39235 int ecode3 = 0 ;
39236 bool temp4 = false ;
39237 void *argp5 = 0 ;
39238 int res5 = 0 ;
39239 bool temp6 = false ;
39240 PyObject * obj0 = 0 ;
39241 PyObject * obj1 = 0 ;
39242 PyObject * obj2 = 0 ;
39243 PyObject * obj3 = 0 ;
39244 PyObject * obj4 = 0 ;
39245 PyObject * obj5 = 0 ;
39246 char * kwnames[] = {
39247 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39248 };
39249
39250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39252 if (!SWIG_IsOK(res1)) {
39253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39254 }
39255 arg1 = reinterpret_cast< wxMenu * >(argp1);
39256 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39257 if (!SWIG_IsOK(ecode2)) {
39258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39259 }
39260 arg2 = static_cast< size_t >(val2);
39261 ecode3 = SWIG_AsVal_int(obj2, &val3);
39262 if (!SWIG_IsOK(ecode3)) {
39263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39264 }
39265 arg3 = static_cast< int >(val3);
39266 {
39267 arg4 = wxString_in_helper(obj3);
39268 if (arg4 == NULL) SWIG_fail;
39269 temp4 = true;
39270 }
39271 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39272 if (!SWIG_IsOK(res5)) {
39273 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39274 }
39275 arg5 = reinterpret_cast< wxMenu * >(argp5);
39276 if (obj5) {
39277 {
39278 arg6 = wxString_in_helper(obj5);
39279 if (arg6 == NULL) SWIG_fail;
39280 temp6 = true;
39281 }
39282 }
39283 {
39284 PyThreadState* __tstate = wxPyBeginAllowThreads();
39285 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39286 wxPyEndAllowThreads(__tstate);
39287 if (PyErr_Occurred()) SWIG_fail;
39288 }
39289 {
39290 resultobj = wxPyMake_wxObject(result, (bool)0);
39291 }
39292 {
39293 if (temp4)
39294 delete arg4;
39295 }
39296 {
39297 if (temp6)
39298 delete arg6;
39299 }
39300 return resultobj;
39301 fail:
39302 {
39303 if (temp4)
39304 delete arg4;
39305 }
39306 {
39307 if (temp6)
39308 delete arg6;
39309 }
39310 return NULL;
39311 }
39312
39313
39314 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39315 PyObject *resultobj = 0;
39316 wxMenu *arg1 = (wxMenu *) 0 ;
39317 int arg2 ;
39318 wxString *arg3 = 0 ;
39319 wxString const &arg4_defvalue = wxPyEmptyString ;
39320 wxString *arg4 = (wxString *) &arg4_defvalue ;
39321 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39322 wxMenuItem *result = 0 ;
39323 void *argp1 = 0 ;
39324 int res1 = 0 ;
39325 int val2 ;
39326 int ecode2 = 0 ;
39327 bool temp3 = false ;
39328 bool temp4 = false ;
39329 int val5 ;
39330 int ecode5 = 0 ;
39331 PyObject * obj0 = 0 ;
39332 PyObject * obj1 = 0 ;
39333 PyObject * obj2 = 0 ;
39334 PyObject * obj3 = 0 ;
39335 PyObject * obj4 = 0 ;
39336 char * kwnames[] = {
39337 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39338 };
39339
39340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39342 if (!SWIG_IsOK(res1)) {
39343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39344 }
39345 arg1 = reinterpret_cast< wxMenu * >(argp1);
39346 ecode2 = SWIG_AsVal_int(obj1, &val2);
39347 if (!SWIG_IsOK(ecode2)) {
39348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39349 }
39350 arg2 = static_cast< int >(val2);
39351 {
39352 arg3 = wxString_in_helper(obj2);
39353 if (arg3 == NULL) SWIG_fail;
39354 temp3 = true;
39355 }
39356 if (obj3) {
39357 {
39358 arg4 = wxString_in_helper(obj3);
39359 if (arg4 == NULL) SWIG_fail;
39360 temp4 = true;
39361 }
39362 }
39363 if (obj4) {
39364 ecode5 = SWIG_AsVal_int(obj4, &val5);
39365 if (!SWIG_IsOK(ecode5)) {
39366 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39367 }
39368 arg5 = static_cast< wxItemKind >(val5);
39369 }
39370 {
39371 PyThreadState* __tstate = wxPyBeginAllowThreads();
39372 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39373 wxPyEndAllowThreads(__tstate);
39374 if (PyErr_Occurred()) SWIG_fail;
39375 }
39376 {
39377 resultobj = wxPyMake_wxObject(result, (bool)0);
39378 }
39379 {
39380 if (temp3)
39381 delete arg3;
39382 }
39383 {
39384 if (temp4)
39385 delete arg4;
39386 }
39387 return resultobj;
39388 fail:
39389 {
39390 if (temp3)
39391 delete arg3;
39392 }
39393 {
39394 if (temp4)
39395 delete arg4;
39396 }
39397 return NULL;
39398 }
39399
39400
39401 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39402 PyObject *resultobj = 0;
39403 wxMenu *arg1 = (wxMenu *) 0 ;
39404 wxMenuItem *result = 0 ;
39405 void *argp1 = 0 ;
39406 int res1 = 0 ;
39407 PyObject *swig_obj[1] ;
39408
39409 if (!args) SWIG_fail;
39410 swig_obj[0] = args;
39411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39412 if (!SWIG_IsOK(res1)) {
39413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39414 }
39415 arg1 = reinterpret_cast< wxMenu * >(argp1);
39416 {
39417 PyThreadState* __tstate = wxPyBeginAllowThreads();
39418 result = (wxMenuItem *)(arg1)->PrependSeparator();
39419 wxPyEndAllowThreads(__tstate);
39420 if (PyErr_Occurred()) SWIG_fail;
39421 }
39422 {
39423 resultobj = wxPyMake_wxObject(result, (bool)0);
39424 }
39425 return resultobj;
39426 fail:
39427 return NULL;
39428 }
39429
39430
39431 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39432 PyObject *resultobj = 0;
39433 wxMenu *arg1 = (wxMenu *) 0 ;
39434 int arg2 ;
39435 wxString *arg3 = 0 ;
39436 wxString const &arg4_defvalue = wxPyEmptyString ;
39437 wxString *arg4 = (wxString *) &arg4_defvalue ;
39438 wxMenuItem *result = 0 ;
39439 void *argp1 = 0 ;
39440 int res1 = 0 ;
39441 int val2 ;
39442 int ecode2 = 0 ;
39443 bool temp3 = false ;
39444 bool temp4 = false ;
39445 PyObject * obj0 = 0 ;
39446 PyObject * obj1 = 0 ;
39447 PyObject * obj2 = 0 ;
39448 PyObject * obj3 = 0 ;
39449 char * kwnames[] = {
39450 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39451 };
39452
39453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39455 if (!SWIG_IsOK(res1)) {
39456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39457 }
39458 arg1 = reinterpret_cast< wxMenu * >(argp1);
39459 ecode2 = SWIG_AsVal_int(obj1, &val2);
39460 if (!SWIG_IsOK(ecode2)) {
39461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39462 }
39463 arg2 = static_cast< int >(val2);
39464 {
39465 arg3 = wxString_in_helper(obj2);
39466 if (arg3 == NULL) SWIG_fail;
39467 temp3 = true;
39468 }
39469 if (obj3) {
39470 {
39471 arg4 = wxString_in_helper(obj3);
39472 if (arg4 == NULL) SWIG_fail;
39473 temp4 = true;
39474 }
39475 }
39476 {
39477 PyThreadState* __tstate = wxPyBeginAllowThreads();
39478 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39479 wxPyEndAllowThreads(__tstate);
39480 if (PyErr_Occurred()) SWIG_fail;
39481 }
39482 {
39483 resultobj = wxPyMake_wxObject(result, (bool)0);
39484 }
39485 {
39486 if (temp3)
39487 delete arg3;
39488 }
39489 {
39490 if (temp4)
39491 delete arg4;
39492 }
39493 return resultobj;
39494 fail:
39495 {
39496 if (temp3)
39497 delete arg3;
39498 }
39499 {
39500 if (temp4)
39501 delete arg4;
39502 }
39503 return NULL;
39504 }
39505
39506
39507 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39508 PyObject *resultobj = 0;
39509 wxMenu *arg1 = (wxMenu *) 0 ;
39510 int arg2 ;
39511 wxString *arg3 = 0 ;
39512 wxString const &arg4_defvalue = wxPyEmptyString ;
39513 wxString *arg4 = (wxString *) &arg4_defvalue ;
39514 wxMenuItem *result = 0 ;
39515 void *argp1 = 0 ;
39516 int res1 = 0 ;
39517 int val2 ;
39518 int ecode2 = 0 ;
39519 bool temp3 = false ;
39520 bool temp4 = false ;
39521 PyObject * obj0 = 0 ;
39522 PyObject * obj1 = 0 ;
39523 PyObject * obj2 = 0 ;
39524 PyObject * obj3 = 0 ;
39525 char * kwnames[] = {
39526 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39527 };
39528
39529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39531 if (!SWIG_IsOK(res1)) {
39532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39533 }
39534 arg1 = reinterpret_cast< wxMenu * >(argp1);
39535 ecode2 = SWIG_AsVal_int(obj1, &val2);
39536 if (!SWIG_IsOK(ecode2)) {
39537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39538 }
39539 arg2 = static_cast< int >(val2);
39540 {
39541 arg3 = wxString_in_helper(obj2);
39542 if (arg3 == NULL) SWIG_fail;
39543 temp3 = true;
39544 }
39545 if (obj3) {
39546 {
39547 arg4 = wxString_in_helper(obj3);
39548 if (arg4 == NULL) SWIG_fail;
39549 temp4 = true;
39550 }
39551 }
39552 {
39553 PyThreadState* __tstate = wxPyBeginAllowThreads();
39554 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39555 wxPyEndAllowThreads(__tstate);
39556 if (PyErr_Occurred()) SWIG_fail;
39557 }
39558 {
39559 resultobj = wxPyMake_wxObject(result, (bool)0);
39560 }
39561 {
39562 if (temp3)
39563 delete arg3;
39564 }
39565 {
39566 if (temp4)
39567 delete arg4;
39568 }
39569 return resultobj;
39570 fail:
39571 {
39572 if (temp3)
39573 delete arg3;
39574 }
39575 {
39576 if (temp4)
39577 delete arg4;
39578 }
39579 return NULL;
39580 }
39581
39582
39583 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39584 PyObject *resultobj = 0;
39585 wxMenu *arg1 = (wxMenu *) 0 ;
39586 int arg2 ;
39587 wxString *arg3 = 0 ;
39588 wxMenu *arg4 = (wxMenu *) 0 ;
39589 wxString const &arg5_defvalue = wxPyEmptyString ;
39590 wxString *arg5 = (wxString *) &arg5_defvalue ;
39591 wxMenuItem *result = 0 ;
39592 void *argp1 = 0 ;
39593 int res1 = 0 ;
39594 int val2 ;
39595 int ecode2 = 0 ;
39596 bool temp3 = false ;
39597 void *argp4 = 0 ;
39598 int res4 = 0 ;
39599 bool temp5 = false ;
39600 PyObject * obj0 = 0 ;
39601 PyObject * obj1 = 0 ;
39602 PyObject * obj2 = 0 ;
39603 PyObject * obj3 = 0 ;
39604 PyObject * obj4 = 0 ;
39605 char * kwnames[] = {
39606 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39607 };
39608
39609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39611 if (!SWIG_IsOK(res1)) {
39612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39613 }
39614 arg1 = reinterpret_cast< wxMenu * >(argp1);
39615 ecode2 = SWIG_AsVal_int(obj1, &val2);
39616 if (!SWIG_IsOK(ecode2)) {
39617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39618 }
39619 arg2 = static_cast< int >(val2);
39620 {
39621 arg3 = wxString_in_helper(obj2);
39622 if (arg3 == NULL) SWIG_fail;
39623 temp3 = true;
39624 }
39625 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39626 if (!SWIG_IsOK(res4)) {
39627 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39628 }
39629 arg4 = reinterpret_cast< wxMenu * >(argp4);
39630 if (obj4) {
39631 {
39632 arg5 = wxString_in_helper(obj4);
39633 if (arg5 == NULL) SWIG_fail;
39634 temp5 = true;
39635 }
39636 }
39637 {
39638 PyThreadState* __tstate = wxPyBeginAllowThreads();
39639 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39640 wxPyEndAllowThreads(__tstate);
39641 if (PyErr_Occurred()) SWIG_fail;
39642 }
39643 {
39644 resultobj = wxPyMake_wxObject(result, (bool)0);
39645 }
39646 {
39647 if (temp3)
39648 delete arg3;
39649 }
39650 {
39651 if (temp5)
39652 delete arg5;
39653 }
39654 return resultobj;
39655 fail:
39656 {
39657 if (temp3)
39658 delete arg3;
39659 }
39660 {
39661 if (temp5)
39662 delete arg5;
39663 }
39664 return NULL;
39665 }
39666
39667
39668 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39669 PyObject *resultobj = 0;
39670 wxMenu *arg1 = (wxMenu *) 0 ;
39671 int arg2 ;
39672 wxMenuItem *result = 0 ;
39673 void *argp1 = 0 ;
39674 int res1 = 0 ;
39675 int val2 ;
39676 int ecode2 = 0 ;
39677 PyObject * obj0 = 0 ;
39678 PyObject * obj1 = 0 ;
39679 char * kwnames[] = {
39680 (char *) "self",(char *) "id", NULL
39681 };
39682
39683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39685 if (!SWIG_IsOK(res1)) {
39686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39687 }
39688 arg1 = reinterpret_cast< wxMenu * >(argp1);
39689 ecode2 = SWIG_AsVal_int(obj1, &val2);
39690 if (!SWIG_IsOK(ecode2)) {
39691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39692 }
39693 arg2 = static_cast< int >(val2);
39694 {
39695 PyThreadState* __tstate = wxPyBeginAllowThreads();
39696 result = (wxMenuItem *)(arg1)->Remove(arg2);
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 {
39701 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39702 }
39703 return resultobj;
39704 fail:
39705 return NULL;
39706 }
39707
39708
39709 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39710 PyObject *resultobj = 0;
39711 wxMenu *arg1 = (wxMenu *) 0 ;
39712 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39713 wxMenuItem *result = 0 ;
39714 void *argp1 = 0 ;
39715 int res1 = 0 ;
39716 void *argp2 = 0 ;
39717 int res2 = 0 ;
39718 PyObject * obj0 = 0 ;
39719 PyObject * obj1 = 0 ;
39720 char * kwnames[] = {
39721 (char *) "self",(char *) "item", NULL
39722 };
39723
39724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39726 if (!SWIG_IsOK(res1)) {
39727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39728 }
39729 arg1 = reinterpret_cast< wxMenu * >(argp1);
39730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39731 if (!SWIG_IsOK(res2)) {
39732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39733 }
39734 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39735 {
39736 PyThreadState* __tstate = wxPyBeginAllowThreads();
39737 result = (wxMenuItem *)(arg1)->Remove(arg2);
39738 wxPyEndAllowThreads(__tstate);
39739 if (PyErr_Occurred()) SWIG_fail;
39740 }
39741 {
39742 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39743 }
39744 return resultobj;
39745 fail:
39746 return NULL;
39747 }
39748
39749
39750 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39751 PyObject *resultobj = 0;
39752 wxMenu *arg1 = (wxMenu *) 0 ;
39753 int arg2 ;
39754 bool result;
39755 void *argp1 = 0 ;
39756 int res1 = 0 ;
39757 int val2 ;
39758 int ecode2 = 0 ;
39759 PyObject * obj0 = 0 ;
39760 PyObject * obj1 = 0 ;
39761 char * kwnames[] = {
39762 (char *) "self",(char *) "id", NULL
39763 };
39764
39765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39767 if (!SWIG_IsOK(res1)) {
39768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39769 }
39770 arg1 = reinterpret_cast< wxMenu * >(argp1);
39771 ecode2 = SWIG_AsVal_int(obj1, &val2);
39772 if (!SWIG_IsOK(ecode2)) {
39773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39774 }
39775 arg2 = static_cast< int >(val2);
39776 {
39777 PyThreadState* __tstate = wxPyBeginAllowThreads();
39778 result = (bool)(arg1)->Delete(arg2);
39779 wxPyEndAllowThreads(__tstate);
39780 if (PyErr_Occurred()) SWIG_fail;
39781 }
39782 {
39783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39784 }
39785 return resultobj;
39786 fail:
39787 return NULL;
39788 }
39789
39790
39791 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39792 PyObject *resultobj = 0;
39793 wxMenu *arg1 = (wxMenu *) 0 ;
39794 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39795 bool result;
39796 void *argp1 = 0 ;
39797 int res1 = 0 ;
39798 void *argp2 = 0 ;
39799 int res2 = 0 ;
39800 PyObject * obj0 = 0 ;
39801 PyObject * obj1 = 0 ;
39802 char * kwnames[] = {
39803 (char *) "self",(char *) "item", NULL
39804 };
39805
39806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39808 if (!SWIG_IsOK(res1)) {
39809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39810 }
39811 arg1 = reinterpret_cast< wxMenu * >(argp1);
39812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39813 if (!SWIG_IsOK(res2)) {
39814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39815 }
39816 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39817 {
39818 PyThreadState* __tstate = wxPyBeginAllowThreads();
39819 result = (bool)(arg1)->Delete(arg2);
39820 wxPyEndAllowThreads(__tstate);
39821 if (PyErr_Occurred()) SWIG_fail;
39822 }
39823 {
39824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39825 }
39826 return resultobj;
39827 fail:
39828 return NULL;
39829 }
39830
39831
39832 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39833 PyObject *resultobj = 0;
39834 wxMenu *arg1 = (wxMenu *) 0 ;
39835 void *argp1 = 0 ;
39836 int res1 = 0 ;
39837 PyObject *swig_obj[1] ;
39838
39839 if (!args) SWIG_fail;
39840 swig_obj[0] = args;
39841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39842 if (!SWIG_IsOK(res1)) {
39843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39844 }
39845 arg1 = reinterpret_cast< wxMenu * >(argp1);
39846 {
39847 PyThreadState* __tstate = wxPyBeginAllowThreads();
39848 wxMenu_Destroy(arg1);
39849 wxPyEndAllowThreads(__tstate);
39850 if (PyErr_Occurred()) SWIG_fail;
39851 }
39852 resultobj = SWIG_Py_Void();
39853 return resultobj;
39854 fail:
39855 return NULL;
39856 }
39857
39858
39859 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39860 PyObject *resultobj = 0;
39861 wxMenu *arg1 = (wxMenu *) 0 ;
39862 int arg2 ;
39863 bool result;
39864 void *argp1 = 0 ;
39865 int res1 = 0 ;
39866 int val2 ;
39867 int ecode2 = 0 ;
39868 PyObject * obj0 = 0 ;
39869 PyObject * obj1 = 0 ;
39870 char * kwnames[] = {
39871 (char *) "self",(char *) "id", NULL
39872 };
39873
39874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39876 if (!SWIG_IsOK(res1)) {
39877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39878 }
39879 arg1 = reinterpret_cast< wxMenu * >(argp1);
39880 ecode2 = SWIG_AsVal_int(obj1, &val2);
39881 if (!SWIG_IsOK(ecode2)) {
39882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39883 }
39884 arg2 = static_cast< int >(val2);
39885 {
39886 PyThreadState* __tstate = wxPyBeginAllowThreads();
39887 result = (bool)(arg1)->Destroy(arg2);
39888 wxPyEndAllowThreads(__tstate);
39889 if (PyErr_Occurred()) SWIG_fail;
39890 }
39891 {
39892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39893 }
39894 return resultobj;
39895 fail:
39896 return NULL;
39897 }
39898
39899
39900 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39901 PyObject *resultobj = 0;
39902 wxMenu *arg1 = (wxMenu *) 0 ;
39903 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39904 bool result;
39905 void *argp1 = 0 ;
39906 int res1 = 0 ;
39907 void *argp2 = 0 ;
39908 int res2 = 0 ;
39909 PyObject * obj0 = 0 ;
39910 PyObject * obj1 = 0 ;
39911 char * kwnames[] = {
39912 (char *) "self",(char *) "item", NULL
39913 };
39914
39915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39917 if (!SWIG_IsOK(res1)) {
39918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39919 }
39920 arg1 = reinterpret_cast< wxMenu * >(argp1);
39921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39922 if (!SWIG_IsOK(res2)) {
39923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39924 }
39925 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39926 {
39927 PyThreadState* __tstate = wxPyBeginAllowThreads();
39928 result = (bool)(arg1)->Destroy(arg2);
39929 wxPyEndAllowThreads(__tstate);
39930 if (PyErr_Occurred()) SWIG_fail;
39931 }
39932 {
39933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39934 }
39935 return resultobj;
39936 fail:
39937 return NULL;
39938 }
39939
39940
39941 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39942 PyObject *resultobj = 0;
39943 wxMenu *arg1 = (wxMenu *) 0 ;
39944 size_t result;
39945 void *argp1 = 0 ;
39946 int res1 = 0 ;
39947 PyObject *swig_obj[1] ;
39948
39949 if (!args) SWIG_fail;
39950 swig_obj[0] = args;
39951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39952 if (!SWIG_IsOK(res1)) {
39953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39954 }
39955 arg1 = reinterpret_cast< wxMenu * >(argp1);
39956 {
39957 PyThreadState* __tstate = wxPyBeginAllowThreads();
39958 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39959 wxPyEndAllowThreads(__tstate);
39960 if (PyErr_Occurred()) SWIG_fail;
39961 }
39962 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39963 return resultobj;
39964 fail:
39965 return NULL;
39966 }
39967
39968
39969 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39970 PyObject *resultobj = 0;
39971 wxMenu *arg1 = (wxMenu *) 0 ;
39972 PyObject *result = 0 ;
39973 void *argp1 = 0 ;
39974 int res1 = 0 ;
39975 PyObject *swig_obj[1] ;
39976
39977 if (!args) SWIG_fail;
39978 swig_obj[0] = args;
39979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39980 if (!SWIG_IsOK(res1)) {
39981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39982 }
39983 arg1 = reinterpret_cast< wxMenu * >(argp1);
39984 {
39985 PyThreadState* __tstate = wxPyBeginAllowThreads();
39986 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39987 wxPyEndAllowThreads(__tstate);
39988 if (PyErr_Occurred()) SWIG_fail;
39989 }
39990 resultobj = result;
39991 return resultobj;
39992 fail:
39993 return NULL;
39994 }
39995
39996
39997 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39998 PyObject *resultobj = 0;
39999 wxMenu *arg1 = (wxMenu *) 0 ;
40000 wxString *arg2 = 0 ;
40001 int result;
40002 void *argp1 = 0 ;
40003 int res1 = 0 ;
40004 bool temp2 = false ;
40005 PyObject * obj0 = 0 ;
40006 PyObject * obj1 = 0 ;
40007 char * kwnames[] = {
40008 (char *) "self",(char *) "item", NULL
40009 };
40010
40011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40013 if (!SWIG_IsOK(res1)) {
40014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40015 }
40016 arg1 = reinterpret_cast< wxMenu * >(argp1);
40017 {
40018 arg2 = wxString_in_helper(obj1);
40019 if (arg2 == NULL) SWIG_fail;
40020 temp2 = true;
40021 }
40022 {
40023 PyThreadState* __tstate = wxPyBeginAllowThreads();
40024 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40025 wxPyEndAllowThreads(__tstate);
40026 if (PyErr_Occurred()) SWIG_fail;
40027 }
40028 resultobj = SWIG_From_int(static_cast< int >(result));
40029 {
40030 if (temp2)
40031 delete arg2;
40032 }
40033 return resultobj;
40034 fail:
40035 {
40036 if (temp2)
40037 delete arg2;
40038 }
40039 return NULL;
40040 }
40041
40042
40043 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40044 PyObject *resultobj = 0;
40045 wxMenu *arg1 = (wxMenu *) 0 ;
40046 int arg2 ;
40047 wxMenuItem *result = 0 ;
40048 void *argp1 = 0 ;
40049 int res1 = 0 ;
40050 int val2 ;
40051 int ecode2 = 0 ;
40052 PyObject * obj0 = 0 ;
40053 PyObject * obj1 = 0 ;
40054 char * kwnames[] = {
40055 (char *) "self",(char *) "id", NULL
40056 };
40057
40058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40060 if (!SWIG_IsOK(res1)) {
40061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40062 }
40063 arg1 = reinterpret_cast< wxMenu * >(argp1);
40064 ecode2 = SWIG_AsVal_int(obj1, &val2);
40065 if (!SWIG_IsOK(ecode2)) {
40066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40067 }
40068 arg2 = static_cast< int >(val2);
40069 {
40070 PyThreadState* __tstate = wxPyBeginAllowThreads();
40071 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40072 wxPyEndAllowThreads(__tstate);
40073 if (PyErr_Occurred()) SWIG_fail;
40074 }
40075 {
40076 resultobj = wxPyMake_wxObject(result, (bool)0);
40077 }
40078 return resultobj;
40079 fail:
40080 return NULL;
40081 }
40082
40083
40084 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40085 PyObject *resultobj = 0;
40086 wxMenu *arg1 = (wxMenu *) 0 ;
40087 size_t arg2 ;
40088 wxMenuItem *result = 0 ;
40089 void *argp1 = 0 ;
40090 int res1 = 0 ;
40091 size_t val2 ;
40092 int ecode2 = 0 ;
40093 PyObject * obj0 = 0 ;
40094 PyObject * obj1 = 0 ;
40095 char * kwnames[] = {
40096 (char *) "self",(char *) "position", NULL
40097 };
40098
40099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40101 if (!SWIG_IsOK(res1)) {
40102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40103 }
40104 arg1 = reinterpret_cast< wxMenu * >(argp1);
40105 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40106 if (!SWIG_IsOK(ecode2)) {
40107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40108 }
40109 arg2 = static_cast< size_t >(val2);
40110 {
40111 PyThreadState* __tstate = wxPyBeginAllowThreads();
40112 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40113 wxPyEndAllowThreads(__tstate);
40114 if (PyErr_Occurred()) SWIG_fail;
40115 }
40116 {
40117 resultobj = wxPyMake_wxObject(result, (bool)0);
40118 }
40119 return resultobj;
40120 fail:
40121 return NULL;
40122 }
40123
40124
40125 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40126 PyObject *resultobj = 0;
40127 wxMenu *arg1 = (wxMenu *) 0 ;
40128 int arg2 ;
40129 bool arg3 ;
40130 void *argp1 = 0 ;
40131 int res1 = 0 ;
40132 int val2 ;
40133 int ecode2 = 0 ;
40134 bool val3 ;
40135 int ecode3 = 0 ;
40136 PyObject * obj0 = 0 ;
40137 PyObject * obj1 = 0 ;
40138 PyObject * obj2 = 0 ;
40139 char * kwnames[] = {
40140 (char *) "self",(char *) "id",(char *) "enable", NULL
40141 };
40142
40143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40145 if (!SWIG_IsOK(res1)) {
40146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40147 }
40148 arg1 = reinterpret_cast< wxMenu * >(argp1);
40149 ecode2 = SWIG_AsVal_int(obj1, &val2);
40150 if (!SWIG_IsOK(ecode2)) {
40151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40152 }
40153 arg2 = static_cast< int >(val2);
40154 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40155 if (!SWIG_IsOK(ecode3)) {
40156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40157 }
40158 arg3 = static_cast< bool >(val3);
40159 {
40160 PyThreadState* __tstate = wxPyBeginAllowThreads();
40161 (arg1)->Enable(arg2,arg3);
40162 wxPyEndAllowThreads(__tstate);
40163 if (PyErr_Occurred()) SWIG_fail;
40164 }
40165 resultobj = SWIG_Py_Void();
40166 return resultobj;
40167 fail:
40168 return NULL;
40169 }
40170
40171
40172 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40173 PyObject *resultobj = 0;
40174 wxMenu *arg1 = (wxMenu *) 0 ;
40175 int arg2 ;
40176 bool result;
40177 void *argp1 = 0 ;
40178 int res1 = 0 ;
40179 int val2 ;
40180 int ecode2 = 0 ;
40181 PyObject * obj0 = 0 ;
40182 PyObject * obj1 = 0 ;
40183 char * kwnames[] = {
40184 (char *) "self",(char *) "id", NULL
40185 };
40186
40187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40189 if (!SWIG_IsOK(res1)) {
40190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40191 }
40192 arg1 = reinterpret_cast< wxMenu * >(argp1);
40193 ecode2 = SWIG_AsVal_int(obj1, &val2);
40194 if (!SWIG_IsOK(ecode2)) {
40195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40196 }
40197 arg2 = static_cast< int >(val2);
40198 {
40199 PyThreadState* __tstate = wxPyBeginAllowThreads();
40200 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40201 wxPyEndAllowThreads(__tstate);
40202 if (PyErr_Occurred()) SWIG_fail;
40203 }
40204 {
40205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40206 }
40207 return resultobj;
40208 fail:
40209 return NULL;
40210 }
40211
40212
40213 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40214 PyObject *resultobj = 0;
40215 wxMenu *arg1 = (wxMenu *) 0 ;
40216 int arg2 ;
40217 bool arg3 ;
40218 void *argp1 = 0 ;
40219 int res1 = 0 ;
40220 int val2 ;
40221 int ecode2 = 0 ;
40222 bool val3 ;
40223 int ecode3 = 0 ;
40224 PyObject * obj0 = 0 ;
40225 PyObject * obj1 = 0 ;
40226 PyObject * obj2 = 0 ;
40227 char * kwnames[] = {
40228 (char *) "self",(char *) "id",(char *) "check", NULL
40229 };
40230
40231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40233 if (!SWIG_IsOK(res1)) {
40234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40235 }
40236 arg1 = reinterpret_cast< wxMenu * >(argp1);
40237 ecode2 = SWIG_AsVal_int(obj1, &val2);
40238 if (!SWIG_IsOK(ecode2)) {
40239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40240 }
40241 arg2 = static_cast< int >(val2);
40242 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40243 if (!SWIG_IsOK(ecode3)) {
40244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40245 }
40246 arg3 = static_cast< bool >(val3);
40247 {
40248 PyThreadState* __tstate = wxPyBeginAllowThreads();
40249 (arg1)->Check(arg2,arg3);
40250 wxPyEndAllowThreads(__tstate);
40251 if (PyErr_Occurred()) SWIG_fail;
40252 }
40253 resultobj = SWIG_Py_Void();
40254 return resultobj;
40255 fail:
40256 return NULL;
40257 }
40258
40259
40260 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40261 PyObject *resultobj = 0;
40262 wxMenu *arg1 = (wxMenu *) 0 ;
40263 int arg2 ;
40264 bool result;
40265 void *argp1 = 0 ;
40266 int res1 = 0 ;
40267 int val2 ;
40268 int ecode2 = 0 ;
40269 PyObject * obj0 = 0 ;
40270 PyObject * obj1 = 0 ;
40271 char * kwnames[] = {
40272 (char *) "self",(char *) "id", NULL
40273 };
40274
40275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40277 if (!SWIG_IsOK(res1)) {
40278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40279 }
40280 arg1 = reinterpret_cast< wxMenu * >(argp1);
40281 ecode2 = SWIG_AsVal_int(obj1, &val2);
40282 if (!SWIG_IsOK(ecode2)) {
40283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40284 }
40285 arg2 = static_cast< int >(val2);
40286 {
40287 PyThreadState* __tstate = wxPyBeginAllowThreads();
40288 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40289 wxPyEndAllowThreads(__tstate);
40290 if (PyErr_Occurred()) SWIG_fail;
40291 }
40292 {
40293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40294 }
40295 return resultobj;
40296 fail:
40297 return NULL;
40298 }
40299
40300
40301 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40302 PyObject *resultobj = 0;
40303 wxMenu *arg1 = (wxMenu *) 0 ;
40304 int arg2 ;
40305 wxString *arg3 = 0 ;
40306 void *argp1 = 0 ;
40307 int res1 = 0 ;
40308 int val2 ;
40309 int ecode2 = 0 ;
40310 bool temp3 = false ;
40311 PyObject * obj0 = 0 ;
40312 PyObject * obj1 = 0 ;
40313 PyObject * obj2 = 0 ;
40314 char * kwnames[] = {
40315 (char *) "self",(char *) "id",(char *) "label", NULL
40316 };
40317
40318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40320 if (!SWIG_IsOK(res1)) {
40321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40322 }
40323 arg1 = reinterpret_cast< wxMenu * >(argp1);
40324 ecode2 = SWIG_AsVal_int(obj1, &val2);
40325 if (!SWIG_IsOK(ecode2)) {
40326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40327 }
40328 arg2 = static_cast< int >(val2);
40329 {
40330 arg3 = wxString_in_helper(obj2);
40331 if (arg3 == NULL) SWIG_fail;
40332 temp3 = true;
40333 }
40334 {
40335 PyThreadState* __tstate = wxPyBeginAllowThreads();
40336 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40337 wxPyEndAllowThreads(__tstate);
40338 if (PyErr_Occurred()) SWIG_fail;
40339 }
40340 resultobj = SWIG_Py_Void();
40341 {
40342 if (temp3)
40343 delete arg3;
40344 }
40345 return resultobj;
40346 fail:
40347 {
40348 if (temp3)
40349 delete arg3;
40350 }
40351 return NULL;
40352 }
40353
40354
40355 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40356 PyObject *resultobj = 0;
40357 wxMenu *arg1 = (wxMenu *) 0 ;
40358 int arg2 ;
40359 wxString result;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 int val2 ;
40363 int ecode2 = 0 ;
40364 PyObject * obj0 = 0 ;
40365 PyObject * obj1 = 0 ;
40366 char * kwnames[] = {
40367 (char *) "self",(char *) "id", NULL
40368 };
40369
40370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40372 if (!SWIG_IsOK(res1)) {
40373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40374 }
40375 arg1 = reinterpret_cast< wxMenu * >(argp1);
40376 ecode2 = SWIG_AsVal_int(obj1, &val2);
40377 if (!SWIG_IsOK(ecode2)) {
40378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40379 }
40380 arg2 = static_cast< int >(val2);
40381 {
40382 PyThreadState* __tstate = wxPyBeginAllowThreads();
40383 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40384 wxPyEndAllowThreads(__tstate);
40385 if (PyErr_Occurred()) SWIG_fail;
40386 }
40387 {
40388 #if wxUSE_UNICODE
40389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40390 #else
40391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40392 #endif
40393 }
40394 return resultobj;
40395 fail:
40396 return NULL;
40397 }
40398
40399
40400 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40401 PyObject *resultobj = 0;
40402 wxMenu *arg1 = (wxMenu *) 0 ;
40403 int arg2 ;
40404 wxString *arg3 = 0 ;
40405 void *argp1 = 0 ;
40406 int res1 = 0 ;
40407 int val2 ;
40408 int ecode2 = 0 ;
40409 bool temp3 = false ;
40410 PyObject * obj0 = 0 ;
40411 PyObject * obj1 = 0 ;
40412 PyObject * obj2 = 0 ;
40413 char * kwnames[] = {
40414 (char *) "self",(char *) "id",(char *) "helpString", NULL
40415 };
40416
40417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40419 if (!SWIG_IsOK(res1)) {
40420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40421 }
40422 arg1 = reinterpret_cast< wxMenu * >(argp1);
40423 ecode2 = SWIG_AsVal_int(obj1, &val2);
40424 if (!SWIG_IsOK(ecode2)) {
40425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40426 }
40427 arg2 = static_cast< int >(val2);
40428 {
40429 arg3 = wxString_in_helper(obj2);
40430 if (arg3 == NULL) SWIG_fail;
40431 temp3 = true;
40432 }
40433 {
40434 PyThreadState* __tstate = wxPyBeginAllowThreads();
40435 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40436 wxPyEndAllowThreads(__tstate);
40437 if (PyErr_Occurred()) SWIG_fail;
40438 }
40439 resultobj = SWIG_Py_Void();
40440 {
40441 if (temp3)
40442 delete arg3;
40443 }
40444 return resultobj;
40445 fail:
40446 {
40447 if (temp3)
40448 delete arg3;
40449 }
40450 return NULL;
40451 }
40452
40453
40454 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40455 PyObject *resultobj = 0;
40456 wxMenu *arg1 = (wxMenu *) 0 ;
40457 int arg2 ;
40458 wxString result;
40459 void *argp1 = 0 ;
40460 int res1 = 0 ;
40461 int val2 ;
40462 int ecode2 = 0 ;
40463 PyObject * obj0 = 0 ;
40464 PyObject * obj1 = 0 ;
40465 char * kwnames[] = {
40466 (char *) "self",(char *) "id", NULL
40467 };
40468
40469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40471 if (!SWIG_IsOK(res1)) {
40472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40473 }
40474 arg1 = reinterpret_cast< wxMenu * >(argp1);
40475 ecode2 = SWIG_AsVal_int(obj1, &val2);
40476 if (!SWIG_IsOK(ecode2)) {
40477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40478 }
40479 arg2 = static_cast< int >(val2);
40480 {
40481 PyThreadState* __tstate = wxPyBeginAllowThreads();
40482 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40483 wxPyEndAllowThreads(__tstate);
40484 if (PyErr_Occurred()) SWIG_fail;
40485 }
40486 {
40487 #if wxUSE_UNICODE
40488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40489 #else
40490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40491 #endif
40492 }
40493 return resultobj;
40494 fail:
40495 return NULL;
40496 }
40497
40498
40499 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40500 PyObject *resultobj = 0;
40501 wxMenu *arg1 = (wxMenu *) 0 ;
40502 wxString *arg2 = 0 ;
40503 void *argp1 = 0 ;
40504 int res1 = 0 ;
40505 bool temp2 = false ;
40506 PyObject * obj0 = 0 ;
40507 PyObject * obj1 = 0 ;
40508 char * kwnames[] = {
40509 (char *) "self",(char *) "title", NULL
40510 };
40511
40512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40514 if (!SWIG_IsOK(res1)) {
40515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40516 }
40517 arg1 = reinterpret_cast< wxMenu * >(argp1);
40518 {
40519 arg2 = wxString_in_helper(obj1);
40520 if (arg2 == NULL) SWIG_fail;
40521 temp2 = true;
40522 }
40523 {
40524 PyThreadState* __tstate = wxPyBeginAllowThreads();
40525 (arg1)->SetTitle((wxString const &)*arg2);
40526 wxPyEndAllowThreads(__tstate);
40527 if (PyErr_Occurred()) SWIG_fail;
40528 }
40529 resultobj = SWIG_Py_Void();
40530 {
40531 if (temp2)
40532 delete arg2;
40533 }
40534 return resultobj;
40535 fail:
40536 {
40537 if (temp2)
40538 delete arg2;
40539 }
40540 return NULL;
40541 }
40542
40543
40544 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40545 PyObject *resultobj = 0;
40546 wxMenu *arg1 = (wxMenu *) 0 ;
40547 wxString result;
40548 void *argp1 = 0 ;
40549 int res1 = 0 ;
40550 PyObject *swig_obj[1] ;
40551
40552 if (!args) SWIG_fail;
40553 swig_obj[0] = args;
40554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40555 if (!SWIG_IsOK(res1)) {
40556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40557 }
40558 arg1 = reinterpret_cast< wxMenu * >(argp1);
40559 {
40560 PyThreadState* __tstate = wxPyBeginAllowThreads();
40561 result = ((wxMenu const *)arg1)->GetTitle();
40562 wxPyEndAllowThreads(__tstate);
40563 if (PyErr_Occurred()) SWIG_fail;
40564 }
40565 {
40566 #if wxUSE_UNICODE
40567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40568 #else
40569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40570 #endif
40571 }
40572 return resultobj;
40573 fail:
40574 return NULL;
40575 }
40576
40577
40578 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40579 PyObject *resultobj = 0;
40580 wxMenu *arg1 = (wxMenu *) 0 ;
40581 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40582 void *argp1 = 0 ;
40583 int res1 = 0 ;
40584 void *argp2 = 0 ;
40585 int res2 = 0 ;
40586 PyObject * obj0 = 0 ;
40587 PyObject * obj1 = 0 ;
40588 char * kwnames[] = {
40589 (char *) "self",(char *) "handler", NULL
40590 };
40591
40592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40594 if (!SWIG_IsOK(res1)) {
40595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40596 }
40597 arg1 = reinterpret_cast< wxMenu * >(argp1);
40598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40599 if (!SWIG_IsOK(res2)) {
40600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40601 }
40602 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40603 {
40604 PyThreadState* __tstate = wxPyBeginAllowThreads();
40605 (arg1)->SetEventHandler(arg2);
40606 wxPyEndAllowThreads(__tstate);
40607 if (PyErr_Occurred()) SWIG_fail;
40608 }
40609 resultobj = SWIG_Py_Void();
40610 return resultobj;
40611 fail:
40612 return NULL;
40613 }
40614
40615
40616 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40617 PyObject *resultobj = 0;
40618 wxMenu *arg1 = (wxMenu *) 0 ;
40619 wxEvtHandler *result = 0 ;
40620 void *argp1 = 0 ;
40621 int res1 = 0 ;
40622 PyObject *swig_obj[1] ;
40623
40624 if (!args) SWIG_fail;
40625 swig_obj[0] = args;
40626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40627 if (!SWIG_IsOK(res1)) {
40628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40629 }
40630 arg1 = reinterpret_cast< wxMenu * >(argp1);
40631 {
40632 PyThreadState* __tstate = wxPyBeginAllowThreads();
40633 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40634 wxPyEndAllowThreads(__tstate);
40635 if (PyErr_Occurred()) SWIG_fail;
40636 }
40637 {
40638 resultobj = wxPyMake_wxObject(result, 0);
40639 }
40640 return resultobj;
40641 fail:
40642 return NULL;
40643 }
40644
40645
40646 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40647 PyObject *resultobj = 0;
40648 wxMenu *arg1 = (wxMenu *) 0 ;
40649 wxWindow *arg2 = (wxWindow *) 0 ;
40650 void *argp1 = 0 ;
40651 int res1 = 0 ;
40652 void *argp2 = 0 ;
40653 int res2 = 0 ;
40654 PyObject * obj0 = 0 ;
40655 PyObject * obj1 = 0 ;
40656 char * kwnames[] = {
40657 (char *) "self",(char *) "win", NULL
40658 };
40659
40660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40662 if (!SWIG_IsOK(res1)) {
40663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40664 }
40665 arg1 = reinterpret_cast< wxMenu * >(argp1);
40666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40667 if (!SWIG_IsOK(res2)) {
40668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40669 }
40670 arg2 = reinterpret_cast< wxWindow * >(argp2);
40671 {
40672 PyThreadState* __tstate = wxPyBeginAllowThreads();
40673 (arg1)->SetInvokingWindow(arg2);
40674 wxPyEndAllowThreads(__tstate);
40675 if (PyErr_Occurred()) SWIG_fail;
40676 }
40677 resultobj = SWIG_Py_Void();
40678 return resultobj;
40679 fail:
40680 return NULL;
40681 }
40682
40683
40684 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40685 PyObject *resultobj = 0;
40686 wxMenu *arg1 = (wxMenu *) 0 ;
40687 wxWindow *result = 0 ;
40688 void *argp1 = 0 ;
40689 int res1 = 0 ;
40690 PyObject *swig_obj[1] ;
40691
40692 if (!args) SWIG_fail;
40693 swig_obj[0] = args;
40694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40695 if (!SWIG_IsOK(res1)) {
40696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40697 }
40698 arg1 = reinterpret_cast< wxMenu * >(argp1);
40699 {
40700 PyThreadState* __tstate = wxPyBeginAllowThreads();
40701 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40702 wxPyEndAllowThreads(__tstate);
40703 if (PyErr_Occurred()) SWIG_fail;
40704 }
40705 {
40706 resultobj = wxPyMake_wxObject(result, 0);
40707 }
40708 return resultobj;
40709 fail:
40710 return NULL;
40711 }
40712
40713
40714 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40715 PyObject *resultobj = 0;
40716 wxMenu *arg1 = (wxMenu *) 0 ;
40717 long result;
40718 void *argp1 = 0 ;
40719 int res1 = 0 ;
40720 PyObject *swig_obj[1] ;
40721
40722 if (!args) SWIG_fail;
40723 swig_obj[0] = args;
40724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40725 if (!SWIG_IsOK(res1)) {
40726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40727 }
40728 arg1 = reinterpret_cast< wxMenu * >(argp1);
40729 {
40730 PyThreadState* __tstate = wxPyBeginAllowThreads();
40731 result = (long)((wxMenu const *)arg1)->GetStyle();
40732 wxPyEndAllowThreads(__tstate);
40733 if (PyErr_Occurred()) SWIG_fail;
40734 }
40735 resultobj = SWIG_From_long(static_cast< long >(result));
40736 return resultobj;
40737 fail:
40738 return NULL;
40739 }
40740
40741
40742 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40743 PyObject *resultobj = 0;
40744 wxMenu *arg1 = (wxMenu *) 0 ;
40745 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40746 void *argp1 = 0 ;
40747 int res1 = 0 ;
40748 void *argp2 = 0 ;
40749 int res2 = 0 ;
40750 PyObject * obj0 = 0 ;
40751 PyObject * obj1 = 0 ;
40752 char * kwnames[] = {
40753 (char *) "self",(char *) "source", NULL
40754 };
40755
40756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40758 if (!SWIG_IsOK(res1)) {
40759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40760 }
40761 arg1 = reinterpret_cast< wxMenu * >(argp1);
40762 if (obj1) {
40763 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40764 if (!SWIG_IsOK(res2)) {
40765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40766 }
40767 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40768 }
40769 {
40770 PyThreadState* __tstate = wxPyBeginAllowThreads();
40771 (arg1)->UpdateUI(arg2);
40772 wxPyEndAllowThreads(__tstate);
40773 if (PyErr_Occurred()) SWIG_fail;
40774 }
40775 resultobj = SWIG_Py_Void();
40776 return resultobj;
40777 fail:
40778 return NULL;
40779 }
40780
40781
40782 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40783 PyObject *resultobj = 0;
40784 wxMenu *arg1 = (wxMenu *) 0 ;
40785 wxMenuBar *result = 0 ;
40786 void *argp1 = 0 ;
40787 int res1 = 0 ;
40788 PyObject *swig_obj[1] ;
40789
40790 if (!args) SWIG_fail;
40791 swig_obj[0] = args;
40792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40793 if (!SWIG_IsOK(res1)) {
40794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40795 }
40796 arg1 = reinterpret_cast< wxMenu * >(argp1);
40797 {
40798 PyThreadState* __tstate = wxPyBeginAllowThreads();
40799 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40800 wxPyEndAllowThreads(__tstate);
40801 if (PyErr_Occurred()) SWIG_fail;
40802 }
40803 {
40804 resultobj = wxPyMake_wxObject(result, (bool)0);
40805 }
40806 return resultobj;
40807 fail:
40808 return NULL;
40809 }
40810
40811
40812 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40813 PyObject *resultobj = 0;
40814 wxMenu *arg1 = (wxMenu *) 0 ;
40815 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40816 void *argp1 = 0 ;
40817 int res1 = 0 ;
40818 void *argp2 = 0 ;
40819 int res2 = 0 ;
40820 PyObject * obj0 = 0 ;
40821 PyObject * obj1 = 0 ;
40822 char * kwnames[] = {
40823 (char *) "self",(char *) "menubar", NULL
40824 };
40825
40826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40828 if (!SWIG_IsOK(res1)) {
40829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40830 }
40831 arg1 = reinterpret_cast< wxMenu * >(argp1);
40832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40833 if (!SWIG_IsOK(res2)) {
40834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40835 }
40836 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 (arg1)->Attach(arg2);
40840 wxPyEndAllowThreads(__tstate);
40841 if (PyErr_Occurred()) SWIG_fail;
40842 }
40843 resultobj = SWIG_Py_Void();
40844 return resultobj;
40845 fail:
40846 return NULL;
40847 }
40848
40849
40850 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40851 PyObject *resultobj = 0;
40852 wxMenu *arg1 = (wxMenu *) 0 ;
40853 void *argp1 = 0 ;
40854 int res1 = 0 ;
40855 PyObject *swig_obj[1] ;
40856
40857 if (!args) SWIG_fail;
40858 swig_obj[0] = args;
40859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40860 if (!SWIG_IsOK(res1)) {
40861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40862 }
40863 arg1 = reinterpret_cast< wxMenu * >(argp1);
40864 {
40865 PyThreadState* __tstate = wxPyBeginAllowThreads();
40866 (arg1)->Detach();
40867 wxPyEndAllowThreads(__tstate);
40868 if (PyErr_Occurred()) SWIG_fail;
40869 }
40870 resultobj = SWIG_Py_Void();
40871 return resultobj;
40872 fail:
40873 return NULL;
40874 }
40875
40876
40877 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40878 PyObject *resultobj = 0;
40879 wxMenu *arg1 = (wxMenu *) 0 ;
40880 bool result;
40881 void *argp1 = 0 ;
40882 int res1 = 0 ;
40883 PyObject *swig_obj[1] ;
40884
40885 if (!args) SWIG_fail;
40886 swig_obj[0] = args;
40887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40888 if (!SWIG_IsOK(res1)) {
40889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40890 }
40891 arg1 = reinterpret_cast< wxMenu * >(argp1);
40892 {
40893 PyThreadState* __tstate = wxPyBeginAllowThreads();
40894 result = (bool)((wxMenu const *)arg1)->IsAttached();
40895 wxPyEndAllowThreads(__tstate);
40896 if (PyErr_Occurred()) SWIG_fail;
40897 }
40898 {
40899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40900 }
40901 return resultobj;
40902 fail:
40903 return NULL;
40904 }
40905
40906
40907 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40908 PyObject *resultobj = 0;
40909 wxMenu *arg1 = (wxMenu *) 0 ;
40910 wxMenu *arg2 = (wxMenu *) 0 ;
40911 void *argp1 = 0 ;
40912 int res1 = 0 ;
40913 void *argp2 = 0 ;
40914 int res2 = 0 ;
40915 PyObject * obj0 = 0 ;
40916 PyObject * obj1 = 0 ;
40917 char * kwnames[] = {
40918 (char *) "self",(char *) "parent", NULL
40919 };
40920
40921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40923 if (!SWIG_IsOK(res1)) {
40924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40925 }
40926 arg1 = reinterpret_cast< wxMenu * >(argp1);
40927 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40928 if (!SWIG_IsOK(res2)) {
40929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40930 }
40931 arg2 = reinterpret_cast< wxMenu * >(argp2);
40932 {
40933 PyThreadState* __tstate = wxPyBeginAllowThreads();
40934 (arg1)->SetParent(arg2);
40935 wxPyEndAllowThreads(__tstate);
40936 if (PyErr_Occurred()) SWIG_fail;
40937 }
40938 resultobj = SWIG_Py_Void();
40939 return resultobj;
40940 fail:
40941 return NULL;
40942 }
40943
40944
40945 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40946 PyObject *resultobj = 0;
40947 wxMenu *arg1 = (wxMenu *) 0 ;
40948 wxMenu *result = 0 ;
40949 void *argp1 = 0 ;
40950 int res1 = 0 ;
40951 PyObject *swig_obj[1] ;
40952
40953 if (!args) SWIG_fail;
40954 swig_obj[0] = args;
40955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40956 if (!SWIG_IsOK(res1)) {
40957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40958 }
40959 arg1 = reinterpret_cast< wxMenu * >(argp1);
40960 {
40961 PyThreadState* __tstate = wxPyBeginAllowThreads();
40962 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40963 wxPyEndAllowThreads(__tstate);
40964 if (PyErr_Occurred()) SWIG_fail;
40965 }
40966 {
40967 resultobj = wxPyMake_wxObject(result, 0);
40968 }
40969 return resultobj;
40970 fail:
40971 return NULL;
40972 }
40973
40974
40975 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40976 PyObject *obj;
40977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40978 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40979 return SWIG_Py_Void();
40980 }
40981
40982 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40983 return SWIG_Python_InitShadowInstance(args);
40984 }
40985
40986 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40987 PyObject *resultobj = 0;
40988 long arg1 = (long) 0 ;
40989 wxMenuBar *result = 0 ;
40990 long val1 ;
40991 int ecode1 = 0 ;
40992 PyObject * obj0 = 0 ;
40993 char * kwnames[] = {
40994 (char *) "style", NULL
40995 };
40996
40997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40998 if (obj0) {
40999 ecode1 = SWIG_AsVal_long(obj0, &val1);
41000 if (!SWIG_IsOK(ecode1)) {
41001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41002 }
41003 arg1 = static_cast< long >(val1);
41004 }
41005 {
41006 if (!wxPyCheckForApp()) SWIG_fail;
41007 PyThreadState* __tstate = wxPyBeginAllowThreads();
41008 result = (wxMenuBar *)new wxMenuBar(arg1);
41009 wxPyEndAllowThreads(__tstate);
41010 if (PyErr_Occurred()) SWIG_fail;
41011 }
41012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj = 0;
41021 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41022 wxMenu *arg2 = (wxMenu *) 0 ;
41023 wxString *arg3 = 0 ;
41024 bool result;
41025 void *argp1 = 0 ;
41026 int res1 = 0 ;
41027 void *argp2 = 0 ;
41028 int res2 = 0 ;
41029 bool temp3 = false ;
41030 PyObject * obj0 = 0 ;
41031 PyObject * obj1 = 0 ;
41032 PyObject * obj2 = 0 ;
41033 char * kwnames[] = {
41034 (char *) "self",(char *) "menu",(char *) "title", NULL
41035 };
41036
41037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41039 if (!SWIG_IsOK(res1)) {
41040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41041 }
41042 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41043 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41044 if (!SWIG_IsOK(res2)) {
41045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41046 }
41047 arg2 = reinterpret_cast< wxMenu * >(argp2);
41048 {
41049 arg3 = wxString_in_helper(obj2);
41050 if (arg3 == NULL) SWIG_fail;
41051 temp3 = true;
41052 }
41053 {
41054 PyThreadState* __tstate = wxPyBeginAllowThreads();
41055 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41056 wxPyEndAllowThreads(__tstate);
41057 if (PyErr_Occurred()) SWIG_fail;
41058 }
41059 {
41060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41061 }
41062 {
41063 if (temp3)
41064 delete arg3;
41065 }
41066 return resultobj;
41067 fail:
41068 {
41069 if (temp3)
41070 delete arg3;
41071 }
41072 return NULL;
41073 }
41074
41075
41076 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41077 PyObject *resultobj = 0;
41078 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41079 size_t arg2 ;
41080 wxMenu *arg3 = (wxMenu *) 0 ;
41081 wxString *arg4 = 0 ;
41082 bool result;
41083 void *argp1 = 0 ;
41084 int res1 = 0 ;
41085 size_t val2 ;
41086 int ecode2 = 0 ;
41087 void *argp3 = 0 ;
41088 int res3 = 0 ;
41089 bool temp4 = false ;
41090 PyObject * obj0 = 0 ;
41091 PyObject * obj1 = 0 ;
41092 PyObject * obj2 = 0 ;
41093 PyObject * obj3 = 0 ;
41094 char * kwnames[] = {
41095 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41096 };
41097
41098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41100 if (!SWIG_IsOK(res1)) {
41101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41102 }
41103 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41104 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41105 if (!SWIG_IsOK(ecode2)) {
41106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41107 }
41108 arg2 = static_cast< size_t >(val2);
41109 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41110 if (!SWIG_IsOK(res3)) {
41111 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41112 }
41113 arg3 = reinterpret_cast< wxMenu * >(argp3);
41114 {
41115 arg4 = wxString_in_helper(obj3);
41116 if (arg4 == NULL) SWIG_fail;
41117 temp4 = true;
41118 }
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 {
41126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41127 }
41128 {
41129 if (temp4)
41130 delete arg4;
41131 }
41132 return resultobj;
41133 fail:
41134 {
41135 if (temp4)
41136 delete arg4;
41137 }
41138 return NULL;
41139 }
41140
41141
41142 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41143 PyObject *resultobj = 0;
41144 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41145 size_t result;
41146 void *argp1 = 0 ;
41147 int res1 = 0 ;
41148 PyObject *swig_obj[1] ;
41149
41150 if (!args) SWIG_fail;
41151 swig_obj[0] = args;
41152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41153 if (!SWIG_IsOK(res1)) {
41154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41155 }
41156 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41157 {
41158 PyThreadState* __tstate = wxPyBeginAllowThreads();
41159 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41160 wxPyEndAllowThreads(__tstate);
41161 if (PyErr_Occurred()) SWIG_fail;
41162 }
41163 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41164 return resultobj;
41165 fail:
41166 return NULL;
41167 }
41168
41169
41170 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41171 PyObject *resultobj = 0;
41172 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41173 size_t arg2 ;
41174 wxMenu *result = 0 ;
41175 void *argp1 = 0 ;
41176 int res1 = 0 ;
41177 size_t val2 ;
41178 int ecode2 = 0 ;
41179 PyObject * obj0 = 0 ;
41180 PyObject * obj1 = 0 ;
41181 char * kwnames[] = {
41182 (char *) "self",(char *) "pos", NULL
41183 };
41184
41185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41187 if (!SWIG_IsOK(res1)) {
41188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41189 }
41190 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41191 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41192 if (!SWIG_IsOK(ecode2)) {
41193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41194 }
41195 arg2 = static_cast< size_t >(val2);
41196 {
41197 PyThreadState* __tstate = wxPyBeginAllowThreads();
41198 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41199 wxPyEndAllowThreads(__tstate);
41200 if (PyErr_Occurred()) SWIG_fail;
41201 }
41202 {
41203 resultobj = wxPyMake_wxObject(result, 0);
41204 }
41205 return resultobj;
41206 fail:
41207 return NULL;
41208 }
41209
41210
41211 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41212 PyObject *resultobj = 0;
41213 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41214 size_t arg2 ;
41215 wxMenu *arg3 = (wxMenu *) 0 ;
41216 wxString *arg4 = 0 ;
41217 wxMenu *result = 0 ;
41218 void *argp1 = 0 ;
41219 int res1 = 0 ;
41220 size_t val2 ;
41221 int ecode2 = 0 ;
41222 void *argp3 = 0 ;
41223 int res3 = 0 ;
41224 bool temp4 = false ;
41225 PyObject * obj0 = 0 ;
41226 PyObject * obj1 = 0 ;
41227 PyObject * obj2 = 0 ;
41228 PyObject * obj3 = 0 ;
41229 char * kwnames[] = {
41230 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41231 };
41232
41233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41235 if (!SWIG_IsOK(res1)) {
41236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41237 }
41238 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41239 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41240 if (!SWIG_IsOK(ecode2)) {
41241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41242 }
41243 arg2 = static_cast< size_t >(val2);
41244 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41245 if (!SWIG_IsOK(res3)) {
41246 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41247 }
41248 arg3 = reinterpret_cast< wxMenu * >(argp3);
41249 {
41250 arg4 = wxString_in_helper(obj3);
41251 if (arg4 == NULL) SWIG_fail;
41252 temp4 = true;
41253 }
41254 {
41255 PyThreadState* __tstate = wxPyBeginAllowThreads();
41256 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41257 wxPyEndAllowThreads(__tstate);
41258 if (PyErr_Occurred()) SWIG_fail;
41259 }
41260 {
41261 resultobj = wxPyMake_wxObject(result, 0);
41262 }
41263 {
41264 if (temp4)
41265 delete arg4;
41266 }
41267 return resultobj;
41268 fail:
41269 {
41270 if (temp4)
41271 delete arg4;
41272 }
41273 return NULL;
41274 }
41275
41276
41277 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41278 PyObject *resultobj = 0;
41279 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41280 size_t arg2 ;
41281 wxMenu *result = 0 ;
41282 void *argp1 = 0 ;
41283 int res1 = 0 ;
41284 size_t val2 ;
41285 int ecode2 = 0 ;
41286 PyObject * obj0 = 0 ;
41287 PyObject * obj1 = 0 ;
41288 char * kwnames[] = {
41289 (char *) "self",(char *) "pos", NULL
41290 };
41291
41292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41294 if (!SWIG_IsOK(res1)) {
41295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41296 }
41297 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41298 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41299 if (!SWIG_IsOK(ecode2)) {
41300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41301 }
41302 arg2 = static_cast< size_t >(val2);
41303 {
41304 PyThreadState* __tstate = wxPyBeginAllowThreads();
41305 result = (wxMenu *)(arg1)->Remove(arg2);
41306 wxPyEndAllowThreads(__tstate);
41307 if (PyErr_Occurred()) SWIG_fail;
41308 }
41309 {
41310 resultobj = wxPyMake_wxObject(result, 0);
41311 }
41312 return resultobj;
41313 fail:
41314 return NULL;
41315 }
41316
41317
41318 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41319 PyObject *resultobj = 0;
41320 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41321 size_t arg2 ;
41322 bool arg3 ;
41323 void *argp1 = 0 ;
41324 int res1 = 0 ;
41325 size_t val2 ;
41326 int ecode2 = 0 ;
41327 bool val3 ;
41328 int ecode3 = 0 ;
41329 PyObject * obj0 = 0 ;
41330 PyObject * obj1 = 0 ;
41331 PyObject * obj2 = 0 ;
41332 char * kwnames[] = {
41333 (char *) "self",(char *) "pos",(char *) "enable", NULL
41334 };
41335
41336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41338 if (!SWIG_IsOK(res1)) {
41339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41340 }
41341 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41342 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41343 if (!SWIG_IsOK(ecode2)) {
41344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41345 }
41346 arg2 = static_cast< size_t >(val2);
41347 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41348 if (!SWIG_IsOK(ecode3)) {
41349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41350 }
41351 arg3 = static_cast< bool >(val3);
41352 {
41353 PyThreadState* __tstate = wxPyBeginAllowThreads();
41354 (arg1)->EnableTop(arg2,arg3);
41355 wxPyEndAllowThreads(__tstate);
41356 if (PyErr_Occurred()) SWIG_fail;
41357 }
41358 resultobj = SWIG_Py_Void();
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41366 PyObject *resultobj = 0;
41367 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41368 size_t arg2 ;
41369 bool result;
41370 void *argp1 = 0 ;
41371 int res1 = 0 ;
41372 size_t val2 ;
41373 int ecode2 = 0 ;
41374 PyObject * obj0 = 0 ;
41375 PyObject * obj1 = 0 ;
41376 char * kwnames[] = {
41377 (char *) "self",(char *) "pos", NULL
41378 };
41379
41380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41382 if (!SWIG_IsOK(res1)) {
41383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41384 }
41385 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41386 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41387 if (!SWIG_IsOK(ecode2)) {
41388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41389 }
41390 arg2 = static_cast< size_t >(val2);
41391 {
41392 PyThreadState* __tstate = wxPyBeginAllowThreads();
41393 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41394 wxPyEndAllowThreads(__tstate);
41395 if (PyErr_Occurred()) SWIG_fail;
41396 }
41397 {
41398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41399 }
41400 return resultobj;
41401 fail:
41402 return NULL;
41403 }
41404
41405
41406 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41407 PyObject *resultobj = 0;
41408 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41409 size_t arg2 ;
41410 wxString *arg3 = 0 ;
41411 void *argp1 = 0 ;
41412 int res1 = 0 ;
41413 size_t val2 ;
41414 int ecode2 = 0 ;
41415 bool temp3 = false ;
41416 PyObject * obj0 = 0 ;
41417 PyObject * obj1 = 0 ;
41418 PyObject * obj2 = 0 ;
41419 char * kwnames[] = {
41420 (char *) "self",(char *) "pos",(char *) "label", NULL
41421 };
41422
41423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41425 if (!SWIG_IsOK(res1)) {
41426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41427 }
41428 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41429 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41430 if (!SWIG_IsOK(ecode2)) {
41431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41432 }
41433 arg2 = static_cast< size_t >(val2);
41434 {
41435 arg3 = wxString_in_helper(obj2);
41436 if (arg3 == NULL) SWIG_fail;
41437 temp3 = true;
41438 }
41439 {
41440 PyThreadState* __tstate = wxPyBeginAllowThreads();
41441 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41442 wxPyEndAllowThreads(__tstate);
41443 if (PyErr_Occurred()) SWIG_fail;
41444 }
41445 resultobj = SWIG_Py_Void();
41446 {
41447 if (temp3)
41448 delete arg3;
41449 }
41450 return resultobj;
41451 fail:
41452 {
41453 if (temp3)
41454 delete arg3;
41455 }
41456 return NULL;
41457 }
41458
41459
41460 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41461 PyObject *resultobj = 0;
41462 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41463 size_t arg2 ;
41464 wxString result;
41465 void *argp1 = 0 ;
41466 int res1 = 0 ;
41467 size_t val2 ;
41468 int ecode2 = 0 ;
41469 PyObject * obj0 = 0 ;
41470 PyObject * obj1 = 0 ;
41471 char * kwnames[] = {
41472 (char *) "self",(char *) "pos", NULL
41473 };
41474
41475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41477 if (!SWIG_IsOK(res1)) {
41478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41479 }
41480 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41481 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41482 if (!SWIG_IsOK(ecode2)) {
41483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41484 }
41485 arg2 = static_cast< size_t >(val2);
41486 {
41487 PyThreadState* __tstate = wxPyBeginAllowThreads();
41488 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41489 wxPyEndAllowThreads(__tstate);
41490 if (PyErr_Occurred()) SWIG_fail;
41491 }
41492 {
41493 #if wxUSE_UNICODE
41494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41495 #else
41496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41497 #endif
41498 }
41499 return resultobj;
41500 fail:
41501 return NULL;
41502 }
41503
41504
41505 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41506 PyObject *resultobj = 0;
41507 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41508 wxString *arg2 = 0 ;
41509 wxString *arg3 = 0 ;
41510 int result;
41511 void *argp1 = 0 ;
41512 int res1 = 0 ;
41513 bool temp2 = false ;
41514 bool temp3 = false ;
41515 PyObject * obj0 = 0 ;
41516 PyObject * obj1 = 0 ;
41517 PyObject * obj2 = 0 ;
41518 char * kwnames[] = {
41519 (char *) "self",(char *) "menu",(char *) "item", NULL
41520 };
41521
41522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41524 if (!SWIG_IsOK(res1)) {
41525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41526 }
41527 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41528 {
41529 arg2 = wxString_in_helper(obj1);
41530 if (arg2 == NULL) SWIG_fail;
41531 temp2 = true;
41532 }
41533 {
41534 arg3 = wxString_in_helper(obj2);
41535 if (arg3 == NULL) SWIG_fail;
41536 temp3 = true;
41537 }
41538 {
41539 PyThreadState* __tstate = wxPyBeginAllowThreads();
41540 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41541 wxPyEndAllowThreads(__tstate);
41542 if (PyErr_Occurred()) SWIG_fail;
41543 }
41544 resultobj = SWIG_From_int(static_cast< int >(result));
41545 {
41546 if (temp2)
41547 delete arg2;
41548 }
41549 {
41550 if (temp3)
41551 delete arg3;
41552 }
41553 return resultobj;
41554 fail:
41555 {
41556 if (temp2)
41557 delete arg2;
41558 }
41559 {
41560 if (temp3)
41561 delete arg3;
41562 }
41563 return NULL;
41564 }
41565
41566
41567 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41568 PyObject *resultobj = 0;
41569 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41570 int arg2 ;
41571 wxMenuItem *result = 0 ;
41572 void *argp1 = 0 ;
41573 int res1 = 0 ;
41574 int val2 ;
41575 int ecode2 = 0 ;
41576 PyObject * obj0 = 0 ;
41577 PyObject * obj1 = 0 ;
41578 char * kwnames[] = {
41579 (char *) "self",(char *) "id", NULL
41580 };
41581
41582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41584 if (!SWIG_IsOK(res1)) {
41585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41586 }
41587 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41588 ecode2 = SWIG_AsVal_int(obj1, &val2);
41589 if (!SWIG_IsOK(ecode2)) {
41590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41591 }
41592 arg2 = static_cast< int >(val2);
41593 {
41594 PyThreadState* __tstate = wxPyBeginAllowThreads();
41595 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41596 wxPyEndAllowThreads(__tstate);
41597 if (PyErr_Occurred()) SWIG_fail;
41598 }
41599 {
41600 resultobj = wxPyMake_wxObject(result, (bool)0);
41601 }
41602 return resultobj;
41603 fail:
41604 return NULL;
41605 }
41606
41607
41608 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41609 PyObject *resultobj = 0;
41610 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41611 wxString *arg2 = 0 ;
41612 int result;
41613 void *argp1 = 0 ;
41614 int res1 = 0 ;
41615 bool temp2 = false ;
41616 PyObject * obj0 = 0 ;
41617 PyObject * obj1 = 0 ;
41618 char * kwnames[] = {
41619 (char *) "self",(char *) "title", NULL
41620 };
41621
41622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41624 if (!SWIG_IsOK(res1)) {
41625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41626 }
41627 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41628 {
41629 arg2 = wxString_in_helper(obj1);
41630 if (arg2 == NULL) SWIG_fail;
41631 temp2 = true;
41632 }
41633 {
41634 PyThreadState* __tstate = wxPyBeginAllowThreads();
41635 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41636 wxPyEndAllowThreads(__tstate);
41637 if (PyErr_Occurred()) SWIG_fail;
41638 }
41639 resultobj = SWIG_From_int(static_cast< int >(result));
41640 {
41641 if (temp2)
41642 delete arg2;
41643 }
41644 return resultobj;
41645 fail:
41646 {
41647 if (temp2)
41648 delete arg2;
41649 }
41650 return NULL;
41651 }
41652
41653
41654 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41655 PyObject *resultobj = 0;
41656 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41657 int arg2 ;
41658 bool arg3 ;
41659 void *argp1 = 0 ;
41660 int res1 = 0 ;
41661 int val2 ;
41662 int ecode2 = 0 ;
41663 bool val3 ;
41664 int ecode3 = 0 ;
41665 PyObject * obj0 = 0 ;
41666 PyObject * obj1 = 0 ;
41667 PyObject * obj2 = 0 ;
41668 char * kwnames[] = {
41669 (char *) "self",(char *) "id",(char *) "enable", NULL
41670 };
41671
41672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41674 if (!SWIG_IsOK(res1)) {
41675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41676 }
41677 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41678 ecode2 = SWIG_AsVal_int(obj1, &val2);
41679 if (!SWIG_IsOK(ecode2)) {
41680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41681 }
41682 arg2 = static_cast< int >(val2);
41683 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41684 if (!SWIG_IsOK(ecode3)) {
41685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41686 }
41687 arg3 = static_cast< bool >(val3);
41688 {
41689 PyThreadState* __tstate = wxPyBeginAllowThreads();
41690 (arg1)->Enable(arg2,arg3);
41691 wxPyEndAllowThreads(__tstate);
41692 if (PyErr_Occurred()) SWIG_fail;
41693 }
41694 resultobj = SWIG_Py_Void();
41695 return resultobj;
41696 fail:
41697 return NULL;
41698 }
41699
41700
41701 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41702 PyObject *resultobj = 0;
41703 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41704 int arg2 ;
41705 bool arg3 ;
41706 void *argp1 = 0 ;
41707 int res1 = 0 ;
41708 int val2 ;
41709 int ecode2 = 0 ;
41710 bool val3 ;
41711 int ecode3 = 0 ;
41712 PyObject * obj0 = 0 ;
41713 PyObject * obj1 = 0 ;
41714 PyObject * obj2 = 0 ;
41715 char * kwnames[] = {
41716 (char *) "self",(char *) "id",(char *) "check", NULL
41717 };
41718
41719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41721 if (!SWIG_IsOK(res1)) {
41722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41723 }
41724 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41725 ecode2 = SWIG_AsVal_int(obj1, &val2);
41726 if (!SWIG_IsOK(ecode2)) {
41727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41728 }
41729 arg2 = static_cast< int >(val2);
41730 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41731 if (!SWIG_IsOK(ecode3)) {
41732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41733 }
41734 arg3 = static_cast< bool >(val3);
41735 {
41736 PyThreadState* __tstate = wxPyBeginAllowThreads();
41737 (arg1)->Check(arg2,arg3);
41738 wxPyEndAllowThreads(__tstate);
41739 if (PyErr_Occurred()) SWIG_fail;
41740 }
41741 resultobj = SWIG_Py_Void();
41742 return resultobj;
41743 fail:
41744 return NULL;
41745 }
41746
41747
41748 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41749 PyObject *resultobj = 0;
41750 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41751 int arg2 ;
41752 bool result;
41753 void *argp1 = 0 ;
41754 int res1 = 0 ;
41755 int val2 ;
41756 int ecode2 = 0 ;
41757 PyObject * obj0 = 0 ;
41758 PyObject * obj1 = 0 ;
41759 char * kwnames[] = {
41760 (char *) "self",(char *) "id", NULL
41761 };
41762
41763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41765 if (!SWIG_IsOK(res1)) {
41766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41767 }
41768 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41769 ecode2 = SWIG_AsVal_int(obj1, &val2);
41770 if (!SWIG_IsOK(ecode2)) {
41771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41772 }
41773 arg2 = static_cast< int >(val2);
41774 {
41775 PyThreadState* __tstate = wxPyBeginAllowThreads();
41776 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41777 wxPyEndAllowThreads(__tstate);
41778 if (PyErr_Occurred()) SWIG_fail;
41779 }
41780 {
41781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41782 }
41783 return resultobj;
41784 fail:
41785 return NULL;
41786 }
41787
41788
41789 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41790 PyObject *resultobj = 0;
41791 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41792 int arg2 ;
41793 bool result;
41794 void *argp1 = 0 ;
41795 int res1 = 0 ;
41796 int val2 ;
41797 int ecode2 = 0 ;
41798 PyObject * obj0 = 0 ;
41799 PyObject * obj1 = 0 ;
41800 char * kwnames[] = {
41801 (char *) "self",(char *) "id", NULL
41802 };
41803
41804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41806 if (!SWIG_IsOK(res1)) {
41807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41808 }
41809 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41810 ecode2 = SWIG_AsVal_int(obj1, &val2);
41811 if (!SWIG_IsOK(ecode2)) {
41812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41813 }
41814 arg2 = static_cast< int >(val2);
41815 {
41816 PyThreadState* __tstate = wxPyBeginAllowThreads();
41817 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41818 wxPyEndAllowThreads(__tstate);
41819 if (PyErr_Occurred()) SWIG_fail;
41820 }
41821 {
41822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41823 }
41824 return resultobj;
41825 fail:
41826 return NULL;
41827 }
41828
41829
41830 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41831 PyObject *resultobj = 0;
41832 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41833 int arg2 ;
41834 wxString *arg3 = 0 ;
41835 void *argp1 = 0 ;
41836 int res1 = 0 ;
41837 int val2 ;
41838 int ecode2 = 0 ;
41839 bool temp3 = false ;
41840 PyObject * obj0 = 0 ;
41841 PyObject * obj1 = 0 ;
41842 PyObject * obj2 = 0 ;
41843 char * kwnames[] = {
41844 (char *) "self",(char *) "id",(char *) "label", NULL
41845 };
41846
41847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41849 if (!SWIG_IsOK(res1)) {
41850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41851 }
41852 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41853 ecode2 = SWIG_AsVal_int(obj1, &val2);
41854 if (!SWIG_IsOK(ecode2)) {
41855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41856 }
41857 arg2 = static_cast< int >(val2);
41858 {
41859 arg3 = wxString_in_helper(obj2);
41860 if (arg3 == NULL) SWIG_fail;
41861 temp3 = true;
41862 }
41863 {
41864 PyThreadState* __tstate = wxPyBeginAllowThreads();
41865 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41866 wxPyEndAllowThreads(__tstate);
41867 if (PyErr_Occurred()) SWIG_fail;
41868 }
41869 resultobj = SWIG_Py_Void();
41870 {
41871 if (temp3)
41872 delete arg3;
41873 }
41874 return resultobj;
41875 fail:
41876 {
41877 if (temp3)
41878 delete arg3;
41879 }
41880 return NULL;
41881 }
41882
41883
41884 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41885 PyObject *resultobj = 0;
41886 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41887 int arg2 ;
41888 wxString result;
41889 void *argp1 = 0 ;
41890 int res1 = 0 ;
41891 int val2 ;
41892 int ecode2 = 0 ;
41893 PyObject * obj0 = 0 ;
41894 PyObject * obj1 = 0 ;
41895 char * kwnames[] = {
41896 (char *) "self",(char *) "id", NULL
41897 };
41898
41899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41901 if (!SWIG_IsOK(res1)) {
41902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41903 }
41904 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41905 ecode2 = SWIG_AsVal_int(obj1, &val2);
41906 if (!SWIG_IsOK(ecode2)) {
41907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41908 }
41909 arg2 = static_cast< int >(val2);
41910 {
41911 PyThreadState* __tstate = wxPyBeginAllowThreads();
41912 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41913 wxPyEndAllowThreads(__tstate);
41914 if (PyErr_Occurred()) SWIG_fail;
41915 }
41916 {
41917 #if wxUSE_UNICODE
41918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41919 #else
41920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41921 #endif
41922 }
41923 return resultobj;
41924 fail:
41925 return NULL;
41926 }
41927
41928
41929 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41930 PyObject *resultobj = 0;
41931 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41932 int arg2 ;
41933 wxString *arg3 = 0 ;
41934 void *argp1 = 0 ;
41935 int res1 = 0 ;
41936 int val2 ;
41937 int ecode2 = 0 ;
41938 bool temp3 = false ;
41939 PyObject * obj0 = 0 ;
41940 PyObject * obj1 = 0 ;
41941 PyObject * obj2 = 0 ;
41942 char * kwnames[] = {
41943 (char *) "self",(char *) "id",(char *) "helpString", NULL
41944 };
41945
41946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41948 if (!SWIG_IsOK(res1)) {
41949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41950 }
41951 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41952 ecode2 = SWIG_AsVal_int(obj1, &val2);
41953 if (!SWIG_IsOK(ecode2)) {
41954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41955 }
41956 arg2 = static_cast< int >(val2);
41957 {
41958 arg3 = wxString_in_helper(obj2);
41959 if (arg3 == NULL) SWIG_fail;
41960 temp3 = true;
41961 }
41962 {
41963 PyThreadState* __tstate = wxPyBeginAllowThreads();
41964 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41965 wxPyEndAllowThreads(__tstate);
41966 if (PyErr_Occurred()) SWIG_fail;
41967 }
41968 resultobj = SWIG_Py_Void();
41969 {
41970 if (temp3)
41971 delete arg3;
41972 }
41973 return resultobj;
41974 fail:
41975 {
41976 if (temp3)
41977 delete arg3;
41978 }
41979 return NULL;
41980 }
41981
41982
41983 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41984 PyObject *resultobj = 0;
41985 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41986 int arg2 ;
41987 wxString result;
41988 void *argp1 = 0 ;
41989 int res1 = 0 ;
41990 int val2 ;
41991 int ecode2 = 0 ;
41992 PyObject * obj0 = 0 ;
41993 PyObject * obj1 = 0 ;
41994 char * kwnames[] = {
41995 (char *) "self",(char *) "id", NULL
41996 };
41997
41998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42000 if (!SWIG_IsOK(res1)) {
42001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42002 }
42003 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42004 ecode2 = SWIG_AsVal_int(obj1, &val2);
42005 if (!SWIG_IsOK(ecode2)) {
42006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42007 }
42008 arg2 = static_cast< int >(val2);
42009 {
42010 PyThreadState* __tstate = wxPyBeginAllowThreads();
42011 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42012 wxPyEndAllowThreads(__tstate);
42013 if (PyErr_Occurred()) SWIG_fail;
42014 }
42015 {
42016 #if wxUSE_UNICODE
42017 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42018 #else
42019 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42020 #endif
42021 }
42022 return resultobj;
42023 fail:
42024 return NULL;
42025 }
42026
42027
42028 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42029 PyObject *resultobj = 0;
42030 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42031 wxFrame *result = 0 ;
42032 void *argp1 = 0 ;
42033 int res1 = 0 ;
42034 PyObject *swig_obj[1] ;
42035
42036 if (!args) SWIG_fail;
42037 swig_obj[0] = args;
42038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42039 if (!SWIG_IsOK(res1)) {
42040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42041 }
42042 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42043 {
42044 PyThreadState* __tstate = wxPyBeginAllowThreads();
42045 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42046 wxPyEndAllowThreads(__tstate);
42047 if (PyErr_Occurred()) SWIG_fail;
42048 }
42049 {
42050 resultobj = wxPyMake_wxObject(result, (bool)0);
42051 }
42052 return resultobj;
42053 fail:
42054 return NULL;
42055 }
42056
42057
42058 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42059 PyObject *resultobj = 0;
42060 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42061 bool result;
42062 void *argp1 = 0 ;
42063 int res1 = 0 ;
42064 PyObject *swig_obj[1] ;
42065
42066 if (!args) SWIG_fail;
42067 swig_obj[0] = args;
42068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42069 if (!SWIG_IsOK(res1)) {
42070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42071 }
42072 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42073 {
42074 PyThreadState* __tstate = wxPyBeginAllowThreads();
42075 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42076 wxPyEndAllowThreads(__tstate);
42077 if (PyErr_Occurred()) SWIG_fail;
42078 }
42079 {
42080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42081 }
42082 return resultobj;
42083 fail:
42084 return NULL;
42085 }
42086
42087
42088 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42089 PyObject *resultobj = 0;
42090 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42091 wxFrame *arg2 = (wxFrame *) 0 ;
42092 void *argp1 = 0 ;
42093 int res1 = 0 ;
42094 void *argp2 = 0 ;
42095 int res2 = 0 ;
42096 PyObject * obj0 = 0 ;
42097 PyObject * obj1 = 0 ;
42098 char * kwnames[] = {
42099 (char *) "self",(char *) "frame", NULL
42100 };
42101
42102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42104 if (!SWIG_IsOK(res1)) {
42105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42106 }
42107 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42109 if (!SWIG_IsOK(res2)) {
42110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42111 }
42112 arg2 = reinterpret_cast< wxFrame * >(argp2);
42113 {
42114 PyThreadState* __tstate = wxPyBeginAllowThreads();
42115 (arg1)->Attach(arg2);
42116 wxPyEndAllowThreads(__tstate);
42117 if (PyErr_Occurred()) SWIG_fail;
42118 }
42119 resultobj = SWIG_Py_Void();
42120 return resultobj;
42121 fail:
42122 return NULL;
42123 }
42124
42125
42126 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42127 PyObject *resultobj = 0;
42128 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42129 void *argp1 = 0 ;
42130 int res1 = 0 ;
42131 PyObject *swig_obj[1] ;
42132
42133 if (!args) SWIG_fail;
42134 swig_obj[0] = args;
42135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42136 if (!SWIG_IsOK(res1)) {
42137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42138 }
42139 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42140 {
42141 PyThreadState* __tstate = wxPyBeginAllowThreads();
42142 (arg1)->Detach();
42143 wxPyEndAllowThreads(__tstate);
42144 if (PyErr_Occurred()) SWIG_fail;
42145 }
42146 resultobj = SWIG_Py_Void();
42147 return resultobj;
42148 fail:
42149 return NULL;
42150 }
42151
42152
42153 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42154 PyObject *resultobj = 0;
42155 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42156 void *argp1 = 0 ;
42157 int res1 = 0 ;
42158 PyObject *swig_obj[1] ;
42159
42160 if (!args) SWIG_fail;
42161 swig_obj[0] = args;
42162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42163 if (!SWIG_IsOK(res1)) {
42164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42165 }
42166 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42167 {
42168 PyThreadState* __tstate = wxPyBeginAllowThreads();
42169 (arg1)->UpdateMenus();
42170 wxPyEndAllowThreads(__tstate);
42171 if (PyErr_Occurred()) SWIG_fail;
42172 }
42173 resultobj = SWIG_Py_Void();
42174 return resultobj;
42175 fail:
42176 return NULL;
42177 }
42178
42179
42180 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42181 PyObject *resultobj = 0;
42182 bool arg1 ;
42183 bool val1 ;
42184 int ecode1 = 0 ;
42185 PyObject * obj0 = 0 ;
42186 char * kwnames[] = {
42187 (char *) "enable", NULL
42188 };
42189
42190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42191 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42192 if (!SWIG_IsOK(ecode1)) {
42193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42194 }
42195 arg1 = static_cast< bool >(val1);
42196 {
42197 PyThreadState* __tstate = wxPyBeginAllowThreads();
42198 wxMenuBar_SetAutoWindowMenu(arg1);
42199 wxPyEndAllowThreads(__tstate);
42200 if (PyErr_Occurred()) SWIG_fail;
42201 }
42202 resultobj = SWIG_Py_Void();
42203 return resultobj;
42204 fail:
42205 return NULL;
42206 }
42207
42208
42209 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42210 PyObject *resultobj = 0;
42211 bool result;
42212
42213 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42214 {
42215 PyThreadState* __tstate = wxPyBeginAllowThreads();
42216 result = (bool)wxMenuBar_GetAutoWindowMenu();
42217 wxPyEndAllowThreads(__tstate);
42218 if (PyErr_Occurred()) SWIG_fail;
42219 }
42220 {
42221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42222 }
42223 return resultobj;
42224 fail:
42225 return NULL;
42226 }
42227
42228
42229 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42230 PyObject *obj;
42231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42232 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42233 return SWIG_Py_Void();
42234 }
42235
42236 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42237 return SWIG_Python_InitShadowInstance(args);
42238 }
42239
42240 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42241 PyObject *resultobj = 0;
42242 wxMenu *arg1 = (wxMenu *) NULL ;
42243 int arg2 = (int) wxID_ANY ;
42244 wxString const &arg3_defvalue = wxPyEmptyString ;
42245 wxString *arg3 = (wxString *) &arg3_defvalue ;
42246 wxString const &arg4_defvalue = wxPyEmptyString ;
42247 wxString *arg4 = (wxString *) &arg4_defvalue ;
42248 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42249 wxMenu *arg6 = (wxMenu *) NULL ;
42250 wxMenuItem *result = 0 ;
42251 void *argp1 = 0 ;
42252 int res1 = 0 ;
42253 int val2 ;
42254 int ecode2 = 0 ;
42255 bool temp3 = false ;
42256 bool temp4 = false ;
42257 int val5 ;
42258 int ecode5 = 0 ;
42259 void *argp6 = 0 ;
42260 int res6 = 0 ;
42261 PyObject * obj0 = 0 ;
42262 PyObject * obj1 = 0 ;
42263 PyObject * obj2 = 0 ;
42264 PyObject * obj3 = 0 ;
42265 PyObject * obj4 = 0 ;
42266 PyObject * obj5 = 0 ;
42267 char * kwnames[] = {
42268 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42269 };
42270
42271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42272 if (obj0) {
42273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42274 if (!SWIG_IsOK(res1)) {
42275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42276 }
42277 arg1 = reinterpret_cast< wxMenu * >(argp1);
42278 }
42279 if (obj1) {
42280 ecode2 = SWIG_AsVal_int(obj1, &val2);
42281 if (!SWIG_IsOK(ecode2)) {
42282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42283 }
42284 arg2 = static_cast< int >(val2);
42285 }
42286 if (obj2) {
42287 {
42288 arg3 = wxString_in_helper(obj2);
42289 if (arg3 == NULL) SWIG_fail;
42290 temp3 = true;
42291 }
42292 }
42293 if (obj3) {
42294 {
42295 arg4 = wxString_in_helper(obj3);
42296 if (arg4 == NULL) SWIG_fail;
42297 temp4 = true;
42298 }
42299 }
42300 if (obj4) {
42301 ecode5 = SWIG_AsVal_int(obj4, &val5);
42302 if (!SWIG_IsOK(ecode5)) {
42303 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42304 }
42305 arg5 = static_cast< wxItemKind >(val5);
42306 }
42307 if (obj5) {
42308 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42309 if (!SWIG_IsOK(res6)) {
42310 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42311 }
42312 arg6 = reinterpret_cast< wxMenu * >(argp6);
42313 }
42314 {
42315 PyThreadState* __tstate = wxPyBeginAllowThreads();
42316 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42317 wxPyEndAllowThreads(__tstate);
42318 if (PyErr_Occurred()) SWIG_fail;
42319 }
42320 {
42321 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42322 }
42323 {
42324 if (temp3)
42325 delete arg3;
42326 }
42327 {
42328 if (temp4)
42329 delete arg4;
42330 }
42331 return resultobj;
42332 fail:
42333 {
42334 if (temp3)
42335 delete arg3;
42336 }
42337 {
42338 if (temp4)
42339 delete arg4;
42340 }
42341 return NULL;
42342 }
42343
42344
42345 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42346 PyObject *resultobj = 0;
42347 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42348 void *argp1 = 0 ;
42349 int res1 = 0 ;
42350 PyObject *swig_obj[1] ;
42351
42352 if (!args) SWIG_fail;
42353 swig_obj[0] = args;
42354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42355 if (!SWIG_IsOK(res1)) {
42356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42357 }
42358 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42359 {
42360 PyThreadState* __tstate = wxPyBeginAllowThreads();
42361 delete arg1;
42362
42363 wxPyEndAllowThreads(__tstate);
42364 if (PyErr_Occurred()) SWIG_fail;
42365 }
42366 resultobj = SWIG_Py_Void();
42367 return resultobj;
42368 fail:
42369 return NULL;
42370 }
42371
42372
42373 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42374 PyObject *resultobj = 0;
42375 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42376 wxMenu *result = 0 ;
42377 void *argp1 = 0 ;
42378 int res1 = 0 ;
42379 PyObject *swig_obj[1] ;
42380
42381 if (!args) SWIG_fail;
42382 swig_obj[0] = args;
42383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42384 if (!SWIG_IsOK(res1)) {
42385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42386 }
42387 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42388 {
42389 PyThreadState* __tstate = wxPyBeginAllowThreads();
42390 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42391 wxPyEndAllowThreads(__tstate);
42392 if (PyErr_Occurred()) SWIG_fail;
42393 }
42394 {
42395 resultobj = wxPyMake_wxObject(result, 0);
42396 }
42397 return resultobj;
42398 fail:
42399 return NULL;
42400 }
42401
42402
42403 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42404 PyObject *resultobj = 0;
42405 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42406 wxMenu *arg2 = (wxMenu *) 0 ;
42407 void *argp1 = 0 ;
42408 int res1 = 0 ;
42409 void *argp2 = 0 ;
42410 int res2 = 0 ;
42411 PyObject * obj0 = 0 ;
42412 PyObject * obj1 = 0 ;
42413 char * kwnames[] = {
42414 (char *) "self",(char *) "menu", NULL
42415 };
42416
42417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42419 if (!SWIG_IsOK(res1)) {
42420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42421 }
42422 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42424 if (!SWIG_IsOK(res2)) {
42425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42426 }
42427 arg2 = reinterpret_cast< wxMenu * >(argp2);
42428 {
42429 PyThreadState* __tstate = wxPyBeginAllowThreads();
42430 (arg1)->SetMenu(arg2);
42431 wxPyEndAllowThreads(__tstate);
42432 if (PyErr_Occurred()) SWIG_fail;
42433 }
42434 resultobj = SWIG_Py_Void();
42435 return resultobj;
42436 fail:
42437 return NULL;
42438 }
42439
42440
42441 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42442 PyObject *resultobj = 0;
42443 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42444 int arg2 ;
42445 void *argp1 = 0 ;
42446 int res1 = 0 ;
42447 int val2 ;
42448 int ecode2 = 0 ;
42449 PyObject * obj0 = 0 ;
42450 PyObject * obj1 = 0 ;
42451 char * kwnames[] = {
42452 (char *) "self",(char *) "id", NULL
42453 };
42454
42455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42457 if (!SWIG_IsOK(res1)) {
42458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42459 }
42460 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42461 ecode2 = SWIG_AsVal_int(obj1, &val2);
42462 if (!SWIG_IsOK(ecode2)) {
42463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42464 }
42465 arg2 = static_cast< int >(val2);
42466 {
42467 PyThreadState* __tstate = wxPyBeginAllowThreads();
42468 (arg1)->SetId(arg2);
42469 wxPyEndAllowThreads(__tstate);
42470 if (PyErr_Occurred()) SWIG_fail;
42471 }
42472 resultobj = SWIG_Py_Void();
42473 return resultobj;
42474 fail:
42475 return NULL;
42476 }
42477
42478
42479 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42480 PyObject *resultobj = 0;
42481 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42482 int result;
42483 void *argp1 = 0 ;
42484 int res1 = 0 ;
42485 PyObject *swig_obj[1] ;
42486
42487 if (!args) SWIG_fail;
42488 swig_obj[0] = args;
42489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42490 if (!SWIG_IsOK(res1)) {
42491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42492 }
42493 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42494 {
42495 PyThreadState* __tstate = wxPyBeginAllowThreads();
42496 result = (int)((wxMenuItem const *)arg1)->GetId();
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 resultobj = SWIG_From_int(static_cast< int >(result));
42501 return resultobj;
42502 fail:
42503 return NULL;
42504 }
42505
42506
42507 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42508 PyObject *resultobj = 0;
42509 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42510 bool result;
42511 void *argp1 = 0 ;
42512 int res1 = 0 ;
42513 PyObject *swig_obj[1] ;
42514
42515 if (!args) SWIG_fail;
42516 swig_obj[0] = args;
42517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42518 if (!SWIG_IsOK(res1)) {
42519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42520 }
42521 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42522 {
42523 PyThreadState* __tstate = wxPyBeginAllowThreads();
42524 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42525 wxPyEndAllowThreads(__tstate);
42526 if (PyErr_Occurred()) SWIG_fail;
42527 }
42528 {
42529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42530 }
42531 return resultobj;
42532 fail:
42533 return NULL;
42534 }
42535
42536
42537 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42538 PyObject *resultobj = 0;
42539 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42540 wxString *arg2 = 0 ;
42541 void *argp1 = 0 ;
42542 int res1 = 0 ;
42543 bool temp2 = false ;
42544 PyObject * obj0 = 0 ;
42545 PyObject * obj1 = 0 ;
42546 char * kwnames[] = {
42547 (char *) "self",(char *) "str", NULL
42548 };
42549
42550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42552 if (!SWIG_IsOK(res1)) {
42553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42554 }
42555 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42556 {
42557 arg2 = wxString_in_helper(obj1);
42558 if (arg2 == NULL) SWIG_fail;
42559 temp2 = true;
42560 }
42561 {
42562 PyThreadState* __tstate = wxPyBeginAllowThreads();
42563 (arg1)->SetText((wxString const &)*arg2);
42564 wxPyEndAllowThreads(__tstate);
42565 if (PyErr_Occurred()) SWIG_fail;
42566 }
42567 resultobj = SWIG_Py_Void();
42568 {
42569 if (temp2)
42570 delete arg2;
42571 }
42572 return resultobj;
42573 fail:
42574 {
42575 if (temp2)
42576 delete arg2;
42577 }
42578 return NULL;
42579 }
42580
42581
42582 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42583 PyObject *resultobj = 0;
42584 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42585 wxString result;
42586 void *argp1 = 0 ;
42587 int res1 = 0 ;
42588 PyObject *swig_obj[1] ;
42589
42590 if (!args) SWIG_fail;
42591 swig_obj[0] = args;
42592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42593 if (!SWIG_IsOK(res1)) {
42594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42595 }
42596 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42597 {
42598 PyThreadState* __tstate = wxPyBeginAllowThreads();
42599 result = ((wxMenuItem const *)arg1)->GetLabel();
42600 wxPyEndAllowThreads(__tstate);
42601 if (PyErr_Occurred()) SWIG_fail;
42602 }
42603 {
42604 #if wxUSE_UNICODE
42605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42606 #else
42607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42608 #endif
42609 }
42610 return resultobj;
42611 fail:
42612 return NULL;
42613 }
42614
42615
42616 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42617 PyObject *resultobj = 0;
42618 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42619 wxString *result = 0 ;
42620 void *argp1 = 0 ;
42621 int res1 = 0 ;
42622 PyObject *swig_obj[1] ;
42623
42624 if (!args) SWIG_fail;
42625 swig_obj[0] = args;
42626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42627 if (!SWIG_IsOK(res1)) {
42628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42629 }
42630 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42631 {
42632 PyThreadState* __tstate = wxPyBeginAllowThreads();
42633 {
42634 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42635 result = (wxString *) &_result_ref;
42636 }
42637 wxPyEndAllowThreads(__tstate);
42638 if (PyErr_Occurred()) SWIG_fail;
42639 }
42640 {
42641 #if wxUSE_UNICODE
42642 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42643 #else
42644 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42645 #endif
42646 }
42647 return resultobj;
42648 fail:
42649 return NULL;
42650 }
42651
42652
42653 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42654 PyObject *resultobj = 0;
42655 wxString *arg1 = 0 ;
42656 wxString result;
42657 bool temp1 = false ;
42658 PyObject * obj0 = 0 ;
42659 char * kwnames[] = {
42660 (char *) "text", NULL
42661 };
42662
42663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42664 {
42665 arg1 = wxString_in_helper(obj0);
42666 if (arg1 == NULL) SWIG_fail;
42667 temp1 = true;
42668 }
42669 {
42670 PyThreadState* __tstate = wxPyBeginAllowThreads();
42671 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42672 wxPyEndAllowThreads(__tstate);
42673 if (PyErr_Occurred()) SWIG_fail;
42674 }
42675 {
42676 #if wxUSE_UNICODE
42677 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42678 #else
42679 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42680 #endif
42681 }
42682 {
42683 if (temp1)
42684 delete arg1;
42685 }
42686 return resultobj;
42687 fail:
42688 {
42689 if (temp1)
42690 delete arg1;
42691 }
42692 return NULL;
42693 }
42694
42695
42696 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42697 PyObject *resultobj = 0;
42698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42699 wxItemKind result;
42700 void *argp1 = 0 ;
42701 int res1 = 0 ;
42702 PyObject *swig_obj[1] ;
42703
42704 if (!args) SWIG_fail;
42705 swig_obj[0] = args;
42706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42707 if (!SWIG_IsOK(res1)) {
42708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42709 }
42710 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42711 {
42712 PyThreadState* __tstate = wxPyBeginAllowThreads();
42713 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42714 wxPyEndAllowThreads(__tstate);
42715 if (PyErr_Occurred()) SWIG_fail;
42716 }
42717 resultobj = SWIG_From_int(static_cast< int >(result));
42718 return resultobj;
42719 fail:
42720 return NULL;
42721 }
42722
42723
42724 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42725 PyObject *resultobj = 0;
42726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42727 wxItemKind arg2 ;
42728 void *argp1 = 0 ;
42729 int res1 = 0 ;
42730 int val2 ;
42731 int ecode2 = 0 ;
42732 PyObject * obj0 = 0 ;
42733 PyObject * obj1 = 0 ;
42734 char * kwnames[] = {
42735 (char *) "self",(char *) "kind", NULL
42736 };
42737
42738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42740 if (!SWIG_IsOK(res1)) {
42741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42742 }
42743 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42744 ecode2 = SWIG_AsVal_int(obj1, &val2);
42745 if (!SWIG_IsOK(ecode2)) {
42746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42747 }
42748 arg2 = static_cast< wxItemKind >(val2);
42749 {
42750 PyThreadState* __tstate = wxPyBeginAllowThreads();
42751 (arg1)->SetKind(arg2);
42752 wxPyEndAllowThreads(__tstate);
42753 if (PyErr_Occurred()) SWIG_fail;
42754 }
42755 resultobj = SWIG_Py_Void();
42756 return resultobj;
42757 fail:
42758 return NULL;
42759 }
42760
42761
42762 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42763 PyObject *resultobj = 0;
42764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42765 bool arg2 ;
42766 void *argp1 = 0 ;
42767 int res1 = 0 ;
42768 bool val2 ;
42769 int ecode2 = 0 ;
42770 PyObject * obj0 = 0 ;
42771 PyObject * obj1 = 0 ;
42772 char * kwnames[] = {
42773 (char *) "self",(char *) "checkable", NULL
42774 };
42775
42776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42778 if (!SWIG_IsOK(res1)) {
42779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42780 }
42781 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42782 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42783 if (!SWIG_IsOK(ecode2)) {
42784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42785 }
42786 arg2 = static_cast< bool >(val2);
42787 {
42788 PyThreadState* __tstate = wxPyBeginAllowThreads();
42789 (arg1)->SetCheckable(arg2);
42790 wxPyEndAllowThreads(__tstate);
42791 if (PyErr_Occurred()) SWIG_fail;
42792 }
42793 resultobj = SWIG_Py_Void();
42794 return resultobj;
42795 fail:
42796 return NULL;
42797 }
42798
42799
42800 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42801 PyObject *resultobj = 0;
42802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42803 bool result;
42804 void *argp1 = 0 ;
42805 int res1 = 0 ;
42806 PyObject *swig_obj[1] ;
42807
42808 if (!args) SWIG_fail;
42809 swig_obj[0] = args;
42810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42811 if (!SWIG_IsOK(res1)) {
42812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42813 }
42814 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42815 {
42816 PyThreadState* __tstate = wxPyBeginAllowThreads();
42817 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42818 wxPyEndAllowThreads(__tstate);
42819 if (PyErr_Occurred()) SWIG_fail;
42820 }
42821 {
42822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42823 }
42824 return resultobj;
42825 fail:
42826 return NULL;
42827 }
42828
42829
42830 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42831 PyObject *resultobj = 0;
42832 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42833 bool result;
42834 void *argp1 = 0 ;
42835 int res1 = 0 ;
42836 PyObject *swig_obj[1] ;
42837
42838 if (!args) SWIG_fail;
42839 swig_obj[0] = args;
42840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42841 if (!SWIG_IsOK(res1)) {
42842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42843 }
42844 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42845 {
42846 PyThreadState* __tstate = wxPyBeginAllowThreads();
42847 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42848 wxPyEndAllowThreads(__tstate);
42849 if (PyErr_Occurred()) SWIG_fail;
42850 }
42851 {
42852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42853 }
42854 return resultobj;
42855 fail:
42856 return NULL;
42857 }
42858
42859
42860 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42861 PyObject *resultobj = 0;
42862 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42863 wxMenu *arg2 = (wxMenu *) 0 ;
42864 void *argp1 = 0 ;
42865 int res1 = 0 ;
42866 void *argp2 = 0 ;
42867 int res2 = 0 ;
42868 PyObject * obj0 = 0 ;
42869 PyObject * obj1 = 0 ;
42870 char * kwnames[] = {
42871 (char *) "self",(char *) "menu", NULL
42872 };
42873
42874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42876 if (!SWIG_IsOK(res1)) {
42877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42878 }
42879 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42881 if (!SWIG_IsOK(res2)) {
42882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42883 }
42884 arg2 = reinterpret_cast< wxMenu * >(argp2);
42885 {
42886 PyThreadState* __tstate = wxPyBeginAllowThreads();
42887 (arg1)->SetSubMenu(arg2);
42888 wxPyEndAllowThreads(__tstate);
42889 if (PyErr_Occurred()) SWIG_fail;
42890 }
42891 resultobj = SWIG_Py_Void();
42892 return resultobj;
42893 fail:
42894 return NULL;
42895 }
42896
42897
42898 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42899 PyObject *resultobj = 0;
42900 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42901 wxMenu *result = 0 ;
42902 void *argp1 = 0 ;
42903 int res1 = 0 ;
42904 PyObject *swig_obj[1] ;
42905
42906 if (!args) SWIG_fail;
42907 swig_obj[0] = args;
42908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42909 if (!SWIG_IsOK(res1)) {
42910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42911 }
42912 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42913 {
42914 PyThreadState* __tstate = wxPyBeginAllowThreads();
42915 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42916 wxPyEndAllowThreads(__tstate);
42917 if (PyErr_Occurred()) SWIG_fail;
42918 }
42919 {
42920 resultobj = wxPyMake_wxObject(result, 0);
42921 }
42922 return resultobj;
42923 fail:
42924 return NULL;
42925 }
42926
42927
42928 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42929 PyObject *resultobj = 0;
42930 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42931 bool arg2 = (bool) true ;
42932 void *argp1 = 0 ;
42933 int res1 = 0 ;
42934 bool val2 ;
42935 int ecode2 = 0 ;
42936 PyObject * obj0 = 0 ;
42937 PyObject * obj1 = 0 ;
42938 char * kwnames[] = {
42939 (char *) "self",(char *) "enable", NULL
42940 };
42941
42942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42944 if (!SWIG_IsOK(res1)) {
42945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42946 }
42947 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42948 if (obj1) {
42949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42950 if (!SWIG_IsOK(ecode2)) {
42951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42952 }
42953 arg2 = static_cast< bool >(val2);
42954 }
42955 {
42956 PyThreadState* __tstate = wxPyBeginAllowThreads();
42957 (arg1)->Enable(arg2);
42958 wxPyEndAllowThreads(__tstate);
42959 if (PyErr_Occurred()) SWIG_fail;
42960 }
42961 resultobj = SWIG_Py_Void();
42962 return resultobj;
42963 fail:
42964 return NULL;
42965 }
42966
42967
42968 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42969 PyObject *resultobj = 0;
42970 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42971 bool result;
42972 void *argp1 = 0 ;
42973 int res1 = 0 ;
42974 PyObject *swig_obj[1] ;
42975
42976 if (!args) SWIG_fail;
42977 swig_obj[0] = args;
42978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42979 if (!SWIG_IsOK(res1)) {
42980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42981 }
42982 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42983 {
42984 PyThreadState* __tstate = wxPyBeginAllowThreads();
42985 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42986 wxPyEndAllowThreads(__tstate);
42987 if (PyErr_Occurred()) SWIG_fail;
42988 }
42989 {
42990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42991 }
42992 return resultobj;
42993 fail:
42994 return NULL;
42995 }
42996
42997
42998 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42999 PyObject *resultobj = 0;
43000 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43001 bool arg2 = (bool) true ;
43002 void *argp1 = 0 ;
43003 int res1 = 0 ;
43004 bool val2 ;
43005 int ecode2 = 0 ;
43006 PyObject * obj0 = 0 ;
43007 PyObject * obj1 = 0 ;
43008 char * kwnames[] = {
43009 (char *) "self",(char *) "check", NULL
43010 };
43011
43012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43014 if (!SWIG_IsOK(res1)) {
43015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43016 }
43017 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43018 if (obj1) {
43019 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43020 if (!SWIG_IsOK(ecode2)) {
43021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43022 }
43023 arg2 = static_cast< bool >(val2);
43024 }
43025 {
43026 PyThreadState* __tstate = wxPyBeginAllowThreads();
43027 (arg1)->Check(arg2);
43028 wxPyEndAllowThreads(__tstate);
43029 if (PyErr_Occurred()) SWIG_fail;
43030 }
43031 resultobj = SWIG_Py_Void();
43032 return resultobj;
43033 fail:
43034 return NULL;
43035 }
43036
43037
43038 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43039 PyObject *resultobj = 0;
43040 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43041 bool result;
43042 void *argp1 = 0 ;
43043 int res1 = 0 ;
43044 PyObject *swig_obj[1] ;
43045
43046 if (!args) SWIG_fail;
43047 swig_obj[0] = args;
43048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43049 if (!SWIG_IsOK(res1)) {
43050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43051 }
43052 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43053 {
43054 PyThreadState* __tstate = wxPyBeginAllowThreads();
43055 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43056 wxPyEndAllowThreads(__tstate);
43057 if (PyErr_Occurred()) SWIG_fail;
43058 }
43059 {
43060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43061 }
43062 return resultobj;
43063 fail:
43064 return NULL;
43065 }
43066
43067
43068 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43069 PyObject *resultobj = 0;
43070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43071 void *argp1 = 0 ;
43072 int res1 = 0 ;
43073 PyObject *swig_obj[1] ;
43074
43075 if (!args) SWIG_fail;
43076 swig_obj[0] = args;
43077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43078 if (!SWIG_IsOK(res1)) {
43079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43080 }
43081 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43082 {
43083 PyThreadState* __tstate = wxPyBeginAllowThreads();
43084 (arg1)->Toggle();
43085 wxPyEndAllowThreads(__tstate);
43086 if (PyErr_Occurred()) SWIG_fail;
43087 }
43088 resultobj = SWIG_Py_Void();
43089 return resultobj;
43090 fail:
43091 return NULL;
43092 }
43093
43094
43095 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43096 PyObject *resultobj = 0;
43097 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43098 wxString *arg2 = 0 ;
43099 void *argp1 = 0 ;
43100 int res1 = 0 ;
43101 bool temp2 = false ;
43102 PyObject * obj0 = 0 ;
43103 PyObject * obj1 = 0 ;
43104 char * kwnames[] = {
43105 (char *) "self",(char *) "str", NULL
43106 };
43107
43108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43110 if (!SWIG_IsOK(res1)) {
43111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43112 }
43113 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43114 {
43115 arg2 = wxString_in_helper(obj1);
43116 if (arg2 == NULL) SWIG_fail;
43117 temp2 = true;
43118 }
43119 {
43120 PyThreadState* __tstate = wxPyBeginAllowThreads();
43121 (arg1)->SetHelp((wxString const &)*arg2);
43122 wxPyEndAllowThreads(__tstate);
43123 if (PyErr_Occurred()) SWIG_fail;
43124 }
43125 resultobj = SWIG_Py_Void();
43126 {
43127 if (temp2)
43128 delete arg2;
43129 }
43130 return resultobj;
43131 fail:
43132 {
43133 if (temp2)
43134 delete arg2;
43135 }
43136 return NULL;
43137 }
43138
43139
43140 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43141 PyObject *resultobj = 0;
43142 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43143 wxString *result = 0 ;
43144 void *argp1 = 0 ;
43145 int res1 = 0 ;
43146 PyObject *swig_obj[1] ;
43147
43148 if (!args) SWIG_fail;
43149 swig_obj[0] = args;
43150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43151 if (!SWIG_IsOK(res1)) {
43152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43153 }
43154 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43155 {
43156 PyThreadState* __tstate = wxPyBeginAllowThreads();
43157 {
43158 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43159 result = (wxString *) &_result_ref;
43160 }
43161 wxPyEndAllowThreads(__tstate);
43162 if (PyErr_Occurred()) SWIG_fail;
43163 }
43164 {
43165 #if wxUSE_UNICODE
43166 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43167 #else
43168 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43169 #endif
43170 }
43171 return resultobj;
43172 fail:
43173 return NULL;
43174 }
43175
43176
43177 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43178 PyObject *resultobj = 0;
43179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43180 wxAcceleratorEntry *result = 0 ;
43181 void *argp1 = 0 ;
43182 int res1 = 0 ;
43183 PyObject *swig_obj[1] ;
43184
43185 if (!args) SWIG_fail;
43186 swig_obj[0] = args;
43187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43188 if (!SWIG_IsOK(res1)) {
43189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43190 }
43191 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43192 {
43193 PyThreadState* __tstate = wxPyBeginAllowThreads();
43194 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43195 wxPyEndAllowThreads(__tstate);
43196 if (PyErr_Occurred()) SWIG_fail;
43197 }
43198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43199 return resultobj;
43200 fail:
43201 return NULL;
43202 }
43203
43204
43205 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43206 PyObject *resultobj = 0;
43207 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43208 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43209 void *argp1 = 0 ;
43210 int res1 = 0 ;
43211 void *argp2 = 0 ;
43212 int res2 = 0 ;
43213 PyObject * obj0 = 0 ;
43214 PyObject * obj1 = 0 ;
43215 char * kwnames[] = {
43216 (char *) "self",(char *) "accel", NULL
43217 };
43218
43219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43221 if (!SWIG_IsOK(res1)) {
43222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43223 }
43224 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43226 if (!SWIG_IsOK(res2)) {
43227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43228 }
43229 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43230 {
43231 PyThreadState* __tstate = wxPyBeginAllowThreads();
43232 (arg1)->SetAccel(arg2);
43233 wxPyEndAllowThreads(__tstate);
43234 if (PyErr_Occurred()) SWIG_fail;
43235 }
43236 resultobj = SWIG_Py_Void();
43237 return resultobj;
43238 fail:
43239 return NULL;
43240 }
43241
43242
43243 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43244 PyObject *resultobj = 0;
43245 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43246 wxBitmap *arg2 = 0 ;
43247 void *argp1 = 0 ;
43248 int res1 = 0 ;
43249 void *argp2 = 0 ;
43250 int res2 = 0 ;
43251 PyObject * obj0 = 0 ;
43252 PyObject * obj1 = 0 ;
43253 char * kwnames[] = {
43254 (char *) "self",(char *) "bitmap", NULL
43255 };
43256
43257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43259 if (!SWIG_IsOK(res1)) {
43260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43261 }
43262 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43263 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43264 if (!SWIG_IsOK(res2)) {
43265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43266 }
43267 if (!argp2) {
43268 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43269 }
43270 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43271 {
43272 PyThreadState* __tstate = wxPyBeginAllowThreads();
43273 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43274 wxPyEndAllowThreads(__tstate);
43275 if (PyErr_Occurred()) SWIG_fail;
43276 }
43277 resultobj = SWIG_Py_Void();
43278 return resultobj;
43279 fail:
43280 return NULL;
43281 }
43282
43283
43284 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43285 PyObject *resultobj = 0;
43286 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43287 wxBitmap *result = 0 ;
43288 void *argp1 = 0 ;
43289 int res1 = 0 ;
43290 PyObject *swig_obj[1] ;
43291
43292 if (!args) SWIG_fail;
43293 swig_obj[0] = args;
43294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43295 if (!SWIG_IsOK(res1)) {
43296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43297 }
43298 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43299 {
43300 PyThreadState* __tstate = wxPyBeginAllowThreads();
43301 {
43302 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43303 result = (wxBitmap *) &_result_ref;
43304 }
43305 wxPyEndAllowThreads(__tstate);
43306 if (PyErr_Occurred()) SWIG_fail;
43307 }
43308 {
43309 wxBitmap* resultptr = new wxBitmap(*result);
43310 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43311 }
43312 return resultobj;
43313 fail:
43314 return NULL;
43315 }
43316
43317
43318 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43319 PyObject *resultobj = 0;
43320 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43321 wxFont *arg2 = 0 ;
43322 void *argp1 = 0 ;
43323 int res1 = 0 ;
43324 void *argp2 = 0 ;
43325 int res2 = 0 ;
43326 PyObject * obj0 = 0 ;
43327 PyObject * obj1 = 0 ;
43328 char * kwnames[] = {
43329 (char *) "self",(char *) "font", NULL
43330 };
43331
43332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43334 if (!SWIG_IsOK(res1)) {
43335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43336 }
43337 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43339 if (!SWIG_IsOK(res2)) {
43340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43341 }
43342 if (!argp2) {
43343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43344 }
43345 arg2 = reinterpret_cast< wxFont * >(argp2);
43346 {
43347 PyThreadState* __tstate = wxPyBeginAllowThreads();
43348 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43349 wxPyEndAllowThreads(__tstate);
43350 if (PyErr_Occurred()) SWIG_fail;
43351 }
43352 resultobj = SWIG_Py_Void();
43353 return resultobj;
43354 fail:
43355 return NULL;
43356 }
43357
43358
43359 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43360 PyObject *resultobj = 0;
43361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43362 wxFont result;
43363 void *argp1 = 0 ;
43364 int res1 = 0 ;
43365 PyObject *swig_obj[1] ;
43366
43367 if (!args) SWIG_fail;
43368 swig_obj[0] = args;
43369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43370 if (!SWIG_IsOK(res1)) {
43371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43372 }
43373 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43374 {
43375 PyThreadState* __tstate = wxPyBeginAllowThreads();
43376 result = wxMenuItem_GetFont(arg1);
43377 wxPyEndAllowThreads(__tstate);
43378 if (PyErr_Occurred()) SWIG_fail;
43379 }
43380 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43381 return resultobj;
43382 fail:
43383 return NULL;
43384 }
43385
43386
43387 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43388 PyObject *resultobj = 0;
43389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43390 wxColour *arg2 = 0 ;
43391 void *argp1 = 0 ;
43392 int res1 = 0 ;
43393 wxColour temp2 ;
43394 PyObject * obj0 = 0 ;
43395 PyObject * obj1 = 0 ;
43396 char * kwnames[] = {
43397 (char *) "self",(char *) "colText", NULL
43398 };
43399
43400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43402 if (!SWIG_IsOK(res1)) {
43403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43404 }
43405 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43406 {
43407 arg2 = &temp2;
43408 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43409 }
43410 {
43411 PyThreadState* __tstate = wxPyBeginAllowThreads();
43412 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43413 wxPyEndAllowThreads(__tstate);
43414 if (PyErr_Occurred()) SWIG_fail;
43415 }
43416 resultobj = SWIG_Py_Void();
43417 return resultobj;
43418 fail:
43419 return NULL;
43420 }
43421
43422
43423 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43424 PyObject *resultobj = 0;
43425 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43426 wxColour result;
43427 void *argp1 = 0 ;
43428 int res1 = 0 ;
43429 PyObject *swig_obj[1] ;
43430
43431 if (!args) SWIG_fail;
43432 swig_obj[0] = args;
43433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43434 if (!SWIG_IsOK(res1)) {
43435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43436 }
43437 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43438 {
43439 PyThreadState* __tstate = wxPyBeginAllowThreads();
43440 result = wxMenuItem_GetTextColour(arg1);
43441 wxPyEndAllowThreads(__tstate);
43442 if (PyErr_Occurred()) SWIG_fail;
43443 }
43444 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43445 return resultobj;
43446 fail:
43447 return NULL;
43448 }
43449
43450
43451 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43452 PyObject *resultobj = 0;
43453 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43454 wxColour *arg2 = 0 ;
43455 void *argp1 = 0 ;
43456 int res1 = 0 ;
43457 wxColour temp2 ;
43458 PyObject * obj0 = 0 ;
43459 PyObject * obj1 = 0 ;
43460 char * kwnames[] = {
43461 (char *) "self",(char *) "colBack", NULL
43462 };
43463
43464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43466 if (!SWIG_IsOK(res1)) {
43467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43468 }
43469 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43470 {
43471 arg2 = &temp2;
43472 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43473 }
43474 {
43475 PyThreadState* __tstate = wxPyBeginAllowThreads();
43476 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43477 wxPyEndAllowThreads(__tstate);
43478 if (PyErr_Occurred()) SWIG_fail;
43479 }
43480 resultobj = SWIG_Py_Void();
43481 return resultobj;
43482 fail:
43483 return NULL;
43484 }
43485
43486
43487 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43488 PyObject *resultobj = 0;
43489 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43490 wxColour result;
43491 void *argp1 = 0 ;
43492 int res1 = 0 ;
43493 PyObject *swig_obj[1] ;
43494
43495 if (!args) SWIG_fail;
43496 swig_obj[0] = args;
43497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43498 if (!SWIG_IsOK(res1)) {
43499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43500 }
43501 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43502 {
43503 PyThreadState* __tstate = wxPyBeginAllowThreads();
43504 result = wxMenuItem_GetBackgroundColour(arg1);
43505 wxPyEndAllowThreads(__tstate);
43506 if (PyErr_Occurred()) SWIG_fail;
43507 }
43508 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43509 return resultobj;
43510 fail:
43511 return NULL;
43512 }
43513
43514
43515 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43516 PyObject *resultobj = 0;
43517 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43518 wxBitmap *arg2 = 0 ;
43519 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43520 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43521 void *argp1 = 0 ;
43522 int res1 = 0 ;
43523 void *argp2 = 0 ;
43524 int res2 = 0 ;
43525 void *argp3 = 0 ;
43526 int res3 = 0 ;
43527 PyObject * obj0 = 0 ;
43528 PyObject * obj1 = 0 ;
43529 PyObject * obj2 = 0 ;
43530 char * kwnames[] = {
43531 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43532 };
43533
43534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43536 if (!SWIG_IsOK(res1)) {
43537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43538 }
43539 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43540 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43541 if (!SWIG_IsOK(res2)) {
43542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43543 }
43544 if (!argp2) {
43545 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43546 }
43547 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43548 if (obj2) {
43549 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43550 if (!SWIG_IsOK(res3)) {
43551 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43552 }
43553 if (!argp3) {
43554 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43555 }
43556 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43557 }
43558 {
43559 PyThreadState* __tstate = wxPyBeginAllowThreads();
43560 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43561 wxPyEndAllowThreads(__tstate);
43562 if (PyErr_Occurred()) SWIG_fail;
43563 }
43564 resultobj = SWIG_Py_Void();
43565 return resultobj;
43566 fail:
43567 return NULL;
43568 }
43569
43570
43571 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43572 PyObject *resultobj = 0;
43573 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43574 wxBitmap *arg2 = 0 ;
43575 void *argp1 = 0 ;
43576 int res1 = 0 ;
43577 void *argp2 = 0 ;
43578 int res2 = 0 ;
43579 PyObject * obj0 = 0 ;
43580 PyObject * obj1 = 0 ;
43581 char * kwnames[] = {
43582 (char *) "self",(char *) "bmpDisabled", NULL
43583 };
43584
43585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43587 if (!SWIG_IsOK(res1)) {
43588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43589 }
43590 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43591 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43592 if (!SWIG_IsOK(res2)) {
43593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43594 }
43595 if (!argp2) {
43596 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43597 }
43598 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43599 {
43600 PyThreadState* __tstate = wxPyBeginAllowThreads();
43601 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43602 wxPyEndAllowThreads(__tstate);
43603 if (PyErr_Occurred()) SWIG_fail;
43604 }
43605 resultobj = SWIG_Py_Void();
43606 return resultobj;
43607 fail:
43608 return NULL;
43609 }
43610
43611
43612 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43613 PyObject *resultobj = 0;
43614 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43615 wxBitmap *result = 0 ;
43616 void *argp1 = 0 ;
43617 int res1 = 0 ;
43618 PyObject *swig_obj[1] ;
43619
43620 if (!args) SWIG_fail;
43621 swig_obj[0] = args;
43622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43623 if (!SWIG_IsOK(res1)) {
43624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43625 }
43626 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43627 {
43628 PyThreadState* __tstate = wxPyBeginAllowThreads();
43629 {
43630 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43631 result = (wxBitmap *) &_result_ref;
43632 }
43633 wxPyEndAllowThreads(__tstate);
43634 if (PyErr_Occurred()) SWIG_fail;
43635 }
43636 {
43637 wxBitmap* resultptr = new wxBitmap(*result);
43638 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43639 }
43640 return resultobj;
43641 fail:
43642 return NULL;
43643 }
43644
43645
43646 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43647 PyObject *resultobj = 0;
43648 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43649 int arg2 ;
43650 void *argp1 = 0 ;
43651 int res1 = 0 ;
43652 int val2 ;
43653 int ecode2 = 0 ;
43654 PyObject * obj0 = 0 ;
43655 PyObject * obj1 = 0 ;
43656 char * kwnames[] = {
43657 (char *) "self",(char *) "nWidth", NULL
43658 };
43659
43660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43662 if (!SWIG_IsOK(res1)) {
43663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43664 }
43665 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43666 ecode2 = SWIG_AsVal_int(obj1, &val2);
43667 if (!SWIG_IsOK(ecode2)) {
43668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43669 }
43670 arg2 = static_cast< int >(val2);
43671 {
43672 PyThreadState* __tstate = wxPyBeginAllowThreads();
43673 wxMenuItem_SetMarginWidth(arg1,arg2);
43674 wxPyEndAllowThreads(__tstate);
43675 if (PyErr_Occurred()) SWIG_fail;
43676 }
43677 resultobj = SWIG_Py_Void();
43678 return resultobj;
43679 fail:
43680 return NULL;
43681 }
43682
43683
43684 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43685 PyObject *resultobj = 0;
43686 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43687 int result;
43688 void *argp1 = 0 ;
43689 int res1 = 0 ;
43690 PyObject *swig_obj[1] ;
43691
43692 if (!args) SWIG_fail;
43693 swig_obj[0] = args;
43694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43695 if (!SWIG_IsOK(res1)) {
43696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43697 }
43698 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43699 {
43700 PyThreadState* __tstate = wxPyBeginAllowThreads();
43701 result = (int)wxMenuItem_GetMarginWidth(arg1);
43702 wxPyEndAllowThreads(__tstate);
43703 if (PyErr_Occurred()) SWIG_fail;
43704 }
43705 resultobj = SWIG_From_int(static_cast< int >(result));
43706 return resultobj;
43707 fail:
43708 return NULL;
43709 }
43710
43711
43712 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43713 PyObject *resultobj = 0;
43714 int result;
43715
43716 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43717 {
43718 PyThreadState* __tstate = wxPyBeginAllowThreads();
43719 result = (int)wxMenuItem_GetDefaultMarginWidth();
43720 wxPyEndAllowThreads(__tstate);
43721 if (PyErr_Occurred()) SWIG_fail;
43722 }
43723 resultobj = SWIG_From_int(static_cast< int >(result));
43724 return resultobj;
43725 fail:
43726 return NULL;
43727 }
43728
43729
43730 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43731 PyObject *resultobj = 0;
43732 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43733 bool result;
43734 void *argp1 = 0 ;
43735 int res1 = 0 ;
43736 PyObject *swig_obj[1] ;
43737
43738 if (!args) SWIG_fail;
43739 swig_obj[0] = args;
43740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43741 if (!SWIG_IsOK(res1)) {
43742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43743 }
43744 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43745 {
43746 PyThreadState* __tstate = wxPyBeginAllowThreads();
43747 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43748 wxPyEndAllowThreads(__tstate);
43749 if (PyErr_Occurred()) SWIG_fail;
43750 }
43751 {
43752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43753 }
43754 return resultobj;
43755 fail:
43756 return NULL;
43757 }
43758
43759
43760 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43761 PyObject *resultobj = 0;
43762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43763 bool arg2 = (bool) true ;
43764 void *argp1 = 0 ;
43765 int res1 = 0 ;
43766 bool val2 ;
43767 int ecode2 = 0 ;
43768 PyObject * obj0 = 0 ;
43769 PyObject * obj1 = 0 ;
43770 char * kwnames[] = {
43771 (char *) "self",(char *) "ownerDrawn", NULL
43772 };
43773
43774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43776 if (!SWIG_IsOK(res1)) {
43777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43778 }
43779 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43780 if (obj1) {
43781 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43782 if (!SWIG_IsOK(ecode2)) {
43783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43784 }
43785 arg2 = static_cast< bool >(val2);
43786 }
43787 {
43788 PyThreadState* __tstate = wxPyBeginAllowThreads();
43789 wxMenuItem_SetOwnerDrawn(arg1,arg2);
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_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43801 PyObject *resultobj = 0;
43802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43803 void *argp1 = 0 ;
43804 int res1 = 0 ;
43805 PyObject *swig_obj[1] ;
43806
43807 if (!args) SWIG_fail;
43808 swig_obj[0] = args;
43809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43810 if (!SWIG_IsOK(res1)) {
43811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43812 }
43813 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43814 {
43815 PyThreadState* __tstate = wxPyBeginAllowThreads();
43816 wxMenuItem_ResetOwnerDrawn(arg1);
43817 wxPyEndAllowThreads(__tstate);
43818 if (PyErr_Occurred()) SWIG_fail;
43819 }
43820 resultobj = SWIG_Py_Void();
43821 return resultobj;
43822 fail:
43823 return NULL;
43824 }
43825
43826
43827 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43828 PyObject *obj;
43829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43830 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43831 return SWIG_Py_Void();
43832 }
43833
43834 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43835 return SWIG_Python_InitShadowInstance(args);
43836 }
43837
43838 SWIGINTERN int ControlNameStr_set(PyObject *) {
43839 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43840 return 1;
43841 }
43842
43843
43844 SWIGINTERN PyObject *ControlNameStr_get(void) {
43845 PyObject *pyobj = 0;
43846
43847 {
43848 #if wxUSE_UNICODE
43849 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43850 #else
43851 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43852 #endif
43853 }
43854 return pyobj;
43855 }
43856
43857
43858 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43859 PyObject *resultobj = 0;
43860 wxWindow *arg1 = (wxWindow *) 0 ;
43861 int arg2 = (int) -1 ;
43862 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43863 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43864 wxSize const &arg4_defvalue = wxDefaultSize ;
43865 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43866 long arg5 = (long) 0 ;
43867 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43868 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43869 wxString const &arg7_defvalue = wxPyControlNameStr ;
43870 wxString *arg7 = (wxString *) &arg7_defvalue ;
43871 wxControl *result = 0 ;
43872 void *argp1 = 0 ;
43873 int res1 = 0 ;
43874 int val2 ;
43875 int ecode2 = 0 ;
43876 wxPoint temp3 ;
43877 wxSize temp4 ;
43878 long val5 ;
43879 int ecode5 = 0 ;
43880 void *argp6 = 0 ;
43881 int res6 = 0 ;
43882 bool temp7 = false ;
43883 PyObject * obj0 = 0 ;
43884 PyObject * obj1 = 0 ;
43885 PyObject * obj2 = 0 ;
43886 PyObject * obj3 = 0 ;
43887 PyObject * obj4 = 0 ;
43888 PyObject * obj5 = 0 ;
43889 PyObject * obj6 = 0 ;
43890 char * kwnames[] = {
43891 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43892 };
43893
43894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43896 if (!SWIG_IsOK(res1)) {
43897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43898 }
43899 arg1 = reinterpret_cast< wxWindow * >(argp1);
43900 if (obj1) {
43901 ecode2 = SWIG_AsVal_int(obj1, &val2);
43902 if (!SWIG_IsOK(ecode2)) {
43903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43904 }
43905 arg2 = static_cast< int >(val2);
43906 }
43907 if (obj2) {
43908 {
43909 arg3 = &temp3;
43910 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43911 }
43912 }
43913 if (obj3) {
43914 {
43915 arg4 = &temp4;
43916 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43917 }
43918 }
43919 if (obj4) {
43920 ecode5 = SWIG_AsVal_long(obj4, &val5);
43921 if (!SWIG_IsOK(ecode5)) {
43922 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43923 }
43924 arg5 = static_cast< long >(val5);
43925 }
43926 if (obj5) {
43927 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43928 if (!SWIG_IsOK(res6)) {
43929 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43930 }
43931 if (!argp6) {
43932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43933 }
43934 arg6 = reinterpret_cast< wxValidator * >(argp6);
43935 }
43936 if (obj6) {
43937 {
43938 arg7 = wxString_in_helper(obj6);
43939 if (arg7 == NULL) SWIG_fail;
43940 temp7 = true;
43941 }
43942 }
43943 {
43944 if (!wxPyCheckForApp()) SWIG_fail;
43945 PyThreadState* __tstate = wxPyBeginAllowThreads();
43946 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43947 wxPyEndAllowThreads(__tstate);
43948 if (PyErr_Occurred()) SWIG_fail;
43949 }
43950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43951 {
43952 if (temp7)
43953 delete arg7;
43954 }
43955 return resultobj;
43956 fail:
43957 {
43958 if (temp7)
43959 delete arg7;
43960 }
43961 return NULL;
43962 }
43963
43964
43965 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43966 PyObject *resultobj = 0;
43967 wxControl *result = 0 ;
43968
43969 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43970 {
43971 if (!wxPyCheckForApp()) SWIG_fail;
43972 PyThreadState* __tstate = wxPyBeginAllowThreads();
43973 result = (wxControl *)new wxControl();
43974 wxPyEndAllowThreads(__tstate);
43975 if (PyErr_Occurred()) SWIG_fail;
43976 }
43977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43978 return resultobj;
43979 fail:
43980 return NULL;
43981 }
43982
43983
43984 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43985 PyObject *resultobj = 0;
43986 wxControl *arg1 = (wxControl *) 0 ;
43987 wxWindow *arg2 = (wxWindow *) 0 ;
43988 int arg3 = (int) -1 ;
43989 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43990 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43991 wxSize const &arg5_defvalue = wxDefaultSize ;
43992 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43993 long arg6 = (long) 0 ;
43994 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43995 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43996 wxString const &arg8_defvalue = wxPyControlNameStr ;
43997 wxString *arg8 = (wxString *) &arg8_defvalue ;
43998 bool result;
43999 void *argp1 = 0 ;
44000 int res1 = 0 ;
44001 void *argp2 = 0 ;
44002 int res2 = 0 ;
44003 int val3 ;
44004 int ecode3 = 0 ;
44005 wxPoint temp4 ;
44006 wxSize temp5 ;
44007 long val6 ;
44008 int ecode6 = 0 ;
44009 void *argp7 = 0 ;
44010 int res7 = 0 ;
44011 bool temp8 = false ;
44012 PyObject * obj0 = 0 ;
44013 PyObject * obj1 = 0 ;
44014 PyObject * obj2 = 0 ;
44015 PyObject * obj3 = 0 ;
44016 PyObject * obj4 = 0 ;
44017 PyObject * obj5 = 0 ;
44018 PyObject * obj6 = 0 ;
44019 PyObject * obj7 = 0 ;
44020 char * kwnames[] = {
44021 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44022 };
44023
44024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44026 if (!SWIG_IsOK(res1)) {
44027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44028 }
44029 arg1 = reinterpret_cast< wxControl * >(argp1);
44030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44031 if (!SWIG_IsOK(res2)) {
44032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44033 }
44034 arg2 = reinterpret_cast< wxWindow * >(argp2);
44035 if (obj2) {
44036 ecode3 = SWIG_AsVal_int(obj2, &val3);
44037 if (!SWIG_IsOK(ecode3)) {
44038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44039 }
44040 arg3 = static_cast< int >(val3);
44041 }
44042 if (obj3) {
44043 {
44044 arg4 = &temp4;
44045 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44046 }
44047 }
44048 if (obj4) {
44049 {
44050 arg5 = &temp5;
44051 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44052 }
44053 }
44054 if (obj5) {
44055 ecode6 = SWIG_AsVal_long(obj5, &val6);
44056 if (!SWIG_IsOK(ecode6)) {
44057 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44058 }
44059 arg6 = static_cast< long >(val6);
44060 }
44061 if (obj6) {
44062 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44063 if (!SWIG_IsOK(res7)) {
44064 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44065 }
44066 if (!argp7) {
44067 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44068 }
44069 arg7 = reinterpret_cast< wxValidator * >(argp7);
44070 }
44071 if (obj7) {
44072 {
44073 arg8 = wxString_in_helper(obj7);
44074 if (arg8 == NULL) SWIG_fail;
44075 temp8 = true;
44076 }
44077 }
44078 {
44079 PyThreadState* __tstate = wxPyBeginAllowThreads();
44080 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44081 wxPyEndAllowThreads(__tstate);
44082 if (PyErr_Occurred()) SWIG_fail;
44083 }
44084 {
44085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44086 }
44087 {
44088 if (temp8)
44089 delete arg8;
44090 }
44091 return resultobj;
44092 fail:
44093 {
44094 if (temp8)
44095 delete arg8;
44096 }
44097 return NULL;
44098 }
44099
44100
44101 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44102 PyObject *resultobj = 0;
44103 wxControl *arg1 = (wxControl *) 0 ;
44104 int result;
44105 void *argp1 = 0 ;
44106 int res1 = 0 ;
44107 PyObject *swig_obj[1] ;
44108
44109 if (!args) SWIG_fail;
44110 swig_obj[0] = args;
44111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44112 if (!SWIG_IsOK(res1)) {
44113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44114 }
44115 arg1 = reinterpret_cast< wxControl * >(argp1);
44116 {
44117 PyThreadState* __tstate = wxPyBeginAllowThreads();
44118 result = (int)((wxControl const *)arg1)->GetAlignment();
44119 wxPyEndAllowThreads(__tstate);
44120 if (PyErr_Occurred()) SWIG_fail;
44121 }
44122 resultobj = SWIG_From_int(static_cast< int >(result));
44123 return resultobj;
44124 fail:
44125 return NULL;
44126 }
44127
44128
44129 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44130 PyObject *resultobj = 0;
44131 wxControl *arg1 = (wxControl *) 0 ;
44132 wxString result;
44133 void *argp1 = 0 ;
44134 int res1 = 0 ;
44135 PyObject *swig_obj[1] ;
44136
44137 if (!args) SWIG_fail;
44138 swig_obj[0] = args;
44139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44140 if (!SWIG_IsOK(res1)) {
44141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44142 }
44143 arg1 = reinterpret_cast< wxControl * >(argp1);
44144 {
44145 PyThreadState* __tstate = wxPyBeginAllowThreads();
44146 result = ((wxControl const *)arg1)->GetLabelText();
44147 wxPyEndAllowThreads(__tstate);
44148 if (PyErr_Occurred()) SWIG_fail;
44149 }
44150 {
44151 #if wxUSE_UNICODE
44152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44153 #else
44154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44155 #endif
44156 }
44157 return resultobj;
44158 fail:
44159 return NULL;
44160 }
44161
44162
44163 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44164 PyObject *resultobj = 0;
44165 wxControl *arg1 = (wxControl *) 0 ;
44166 wxCommandEvent *arg2 = 0 ;
44167 void *argp1 = 0 ;
44168 int res1 = 0 ;
44169 void *argp2 = 0 ;
44170 int res2 = 0 ;
44171 PyObject * obj0 = 0 ;
44172 PyObject * obj1 = 0 ;
44173 char * kwnames[] = {
44174 (char *) "self",(char *) "event", NULL
44175 };
44176
44177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44179 if (!SWIG_IsOK(res1)) {
44180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44181 }
44182 arg1 = reinterpret_cast< wxControl * >(argp1);
44183 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44184 if (!SWIG_IsOK(res2)) {
44185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44186 }
44187 if (!argp2) {
44188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44189 }
44190 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44191 {
44192 PyThreadState* __tstate = wxPyBeginAllowThreads();
44193 (arg1)->Command(*arg2);
44194 wxPyEndAllowThreads(__tstate);
44195 if (PyErr_Occurred()) SWIG_fail;
44196 }
44197 resultobj = SWIG_Py_Void();
44198 return resultobj;
44199 fail:
44200 return NULL;
44201 }
44202
44203
44204 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44205 PyObject *resultobj = 0;
44206 wxControl *arg1 = (wxControl *) 0 ;
44207 wxString result;
44208 void *argp1 = 0 ;
44209 int res1 = 0 ;
44210 PyObject *swig_obj[1] ;
44211
44212 if (!args) SWIG_fail;
44213 swig_obj[0] = args;
44214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44215 if (!SWIG_IsOK(res1)) {
44216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44217 }
44218 arg1 = reinterpret_cast< wxControl * >(argp1);
44219 {
44220 PyThreadState* __tstate = wxPyBeginAllowThreads();
44221 result = (arg1)->GetLabel();
44222 wxPyEndAllowThreads(__tstate);
44223 if (PyErr_Occurred()) SWIG_fail;
44224 }
44225 {
44226 #if wxUSE_UNICODE
44227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44228 #else
44229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44230 #endif
44231 }
44232 return resultobj;
44233 fail:
44234 return NULL;
44235 }
44236
44237
44238 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44239 PyObject *resultobj = 0;
44240 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44241 SwigValueWrapper<wxVisualAttributes > result;
44242 int val1 ;
44243 int ecode1 = 0 ;
44244 PyObject * obj0 = 0 ;
44245 char * kwnames[] = {
44246 (char *) "variant", NULL
44247 };
44248
44249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44250 if (obj0) {
44251 ecode1 = SWIG_AsVal_int(obj0, &val1);
44252 if (!SWIG_IsOK(ecode1)) {
44253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44254 }
44255 arg1 = static_cast< wxWindowVariant >(val1);
44256 }
44257 {
44258 if (!wxPyCheckForApp()) SWIG_fail;
44259 PyThreadState* __tstate = wxPyBeginAllowThreads();
44260 result = wxControl::GetClassDefaultAttributes(arg1);
44261 wxPyEndAllowThreads(__tstate);
44262 if (PyErr_Occurred()) SWIG_fail;
44263 }
44264 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44265 return resultobj;
44266 fail:
44267 return NULL;
44268 }
44269
44270
44271 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44272 PyObject *obj;
44273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44274 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44275 return SWIG_Py_Void();
44276 }
44277
44278 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44279 return SWIG_Python_InitShadowInstance(args);
44280 }
44281
44282 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44283 PyObject *resultobj = 0;
44284 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44285 wxString *arg2 = 0 ;
44286 PyObject *arg3 = (PyObject *) NULL ;
44287 int result;
44288 void *argp1 = 0 ;
44289 int res1 = 0 ;
44290 bool temp2 = false ;
44291 PyObject * obj0 = 0 ;
44292 PyObject * obj1 = 0 ;
44293 PyObject * obj2 = 0 ;
44294 char * kwnames[] = {
44295 (char *) "self",(char *) "item",(char *) "clientData", NULL
44296 };
44297
44298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44300 if (!SWIG_IsOK(res1)) {
44301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44302 }
44303 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44304 {
44305 arg2 = wxString_in_helper(obj1);
44306 if (arg2 == NULL) SWIG_fail;
44307 temp2 = true;
44308 }
44309 if (obj2) {
44310 arg3 = obj2;
44311 }
44312 {
44313 PyThreadState* __tstate = wxPyBeginAllowThreads();
44314 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44315 wxPyEndAllowThreads(__tstate);
44316 if (PyErr_Occurred()) SWIG_fail;
44317 }
44318 resultobj = SWIG_From_int(static_cast< int >(result));
44319 {
44320 if (temp2)
44321 delete arg2;
44322 }
44323 return resultobj;
44324 fail:
44325 {
44326 if (temp2)
44327 delete arg2;
44328 }
44329 return NULL;
44330 }
44331
44332
44333 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44334 PyObject *resultobj = 0;
44335 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44336 wxArrayString *arg2 = 0 ;
44337 void *argp1 = 0 ;
44338 int res1 = 0 ;
44339 bool temp2 = false ;
44340 PyObject * obj0 = 0 ;
44341 PyObject * obj1 = 0 ;
44342 char * kwnames[] = {
44343 (char *) "self",(char *) "strings", NULL
44344 };
44345
44346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44348 if (!SWIG_IsOK(res1)) {
44349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44350 }
44351 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44352 {
44353 if (! PySequence_Check(obj1)) {
44354 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44355 SWIG_fail;
44356 }
44357 arg2 = new wxArrayString;
44358 temp2 = true;
44359 int i, len=PySequence_Length(obj1);
44360 for (i=0; i<len; i++) {
44361 PyObject* item = PySequence_GetItem(obj1, i);
44362 wxString* s = wxString_in_helper(item);
44363 if (PyErr_Occurred()) SWIG_fail;
44364 arg2->Add(*s);
44365 delete s;
44366 Py_DECREF(item);
44367 }
44368 }
44369 {
44370 PyThreadState* __tstate = wxPyBeginAllowThreads();
44371 (arg1)->Append((wxArrayString const &)*arg2);
44372 wxPyEndAllowThreads(__tstate);
44373 if (PyErr_Occurred()) SWIG_fail;
44374 }
44375 resultobj = SWIG_Py_Void();
44376 {
44377 if (temp2) delete arg2;
44378 }
44379 return resultobj;
44380 fail:
44381 {
44382 if (temp2) delete arg2;
44383 }
44384 return NULL;
44385 }
44386
44387
44388 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44389 PyObject *resultobj = 0;
44390 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44391 wxString *arg2 = 0 ;
44392 unsigned int arg3 ;
44393 PyObject *arg4 = (PyObject *) NULL ;
44394 int result;
44395 void *argp1 = 0 ;
44396 int res1 = 0 ;
44397 bool temp2 = false ;
44398 unsigned int val3 ;
44399 int ecode3 = 0 ;
44400 PyObject * obj0 = 0 ;
44401 PyObject * obj1 = 0 ;
44402 PyObject * obj2 = 0 ;
44403 PyObject * obj3 = 0 ;
44404 char * kwnames[] = {
44405 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44406 };
44407
44408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44410 if (!SWIG_IsOK(res1)) {
44411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44412 }
44413 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44414 {
44415 arg2 = wxString_in_helper(obj1);
44416 if (arg2 == NULL) SWIG_fail;
44417 temp2 = true;
44418 }
44419 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44420 if (!SWIG_IsOK(ecode3)) {
44421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44422 }
44423 arg3 = static_cast< unsigned int >(val3);
44424 if (obj3) {
44425 arg4 = obj3;
44426 }
44427 {
44428 PyThreadState* __tstate = wxPyBeginAllowThreads();
44429 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44430 wxPyEndAllowThreads(__tstate);
44431 if (PyErr_Occurred()) SWIG_fail;
44432 }
44433 resultobj = SWIG_From_int(static_cast< int >(result));
44434 {
44435 if (temp2)
44436 delete arg2;
44437 }
44438 return resultobj;
44439 fail:
44440 {
44441 if (temp2)
44442 delete arg2;
44443 }
44444 return NULL;
44445 }
44446
44447
44448 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44449 PyObject *resultobj = 0;
44450 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44451 void *argp1 = 0 ;
44452 int res1 = 0 ;
44453 PyObject *swig_obj[1] ;
44454
44455 if (!args) SWIG_fail;
44456 swig_obj[0] = args;
44457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44458 if (!SWIG_IsOK(res1)) {
44459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44460 }
44461 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44462 {
44463 PyThreadState* __tstate = wxPyBeginAllowThreads();
44464 (arg1)->Clear();
44465 wxPyEndAllowThreads(__tstate);
44466 if (PyErr_Occurred()) SWIG_fail;
44467 }
44468 resultobj = SWIG_Py_Void();
44469 return resultobj;
44470 fail:
44471 return NULL;
44472 }
44473
44474
44475 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44476 PyObject *resultobj = 0;
44477 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44478 unsigned int arg2 ;
44479 void *argp1 = 0 ;
44480 int res1 = 0 ;
44481 unsigned int val2 ;
44482 int ecode2 = 0 ;
44483 PyObject * obj0 = 0 ;
44484 PyObject * obj1 = 0 ;
44485 char * kwnames[] = {
44486 (char *) "self",(char *) "n", NULL
44487 };
44488
44489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44491 if (!SWIG_IsOK(res1)) {
44492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44493 }
44494 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44495 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44496 if (!SWIG_IsOK(ecode2)) {
44497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44498 }
44499 arg2 = static_cast< unsigned int >(val2);
44500 {
44501 PyThreadState* __tstate = wxPyBeginAllowThreads();
44502 (arg1)->Delete(arg2);
44503 wxPyEndAllowThreads(__tstate);
44504 if (PyErr_Occurred()) SWIG_fail;
44505 }
44506 resultobj = SWIG_Py_Void();
44507 return resultobj;
44508 fail:
44509 return NULL;
44510 }
44511
44512
44513 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44514 PyObject *resultobj = 0;
44515 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44516 unsigned int arg2 ;
44517 PyObject *result = 0 ;
44518 void *argp1 = 0 ;
44519 int res1 = 0 ;
44520 unsigned int val2 ;
44521 int ecode2 = 0 ;
44522 PyObject * obj0 = 0 ;
44523 PyObject * obj1 = 0 ;
44524 char * kwnames[] = {
44525 (char *) "self",(char *) "n", NULL
44526 };
44527
44528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44530 if (!SWIG_IsOK(res1)) {
44531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44532 }
44533 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44534 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44535 if (!SWIG_IsOK(ecode2)) {
44536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44537 }
44538 arg2 = static_cast< unsigned int >(val2);
44539 {
44540 PyThreadState* __tstate = wxPyBeginAllowThreads();
44541 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44542 wxPyEndAllowThreads(__tstate);
44543 if (PyErr_Occurred()) SWIG_fail;
44544 }
44545 resultobj = result;
44546 return resultobj;
44547 fail:
44548 return NULL;
44549 }
44550
44551
44552 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44553 PyObject *resultobj = 0;
44554 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44555 unsigned int arg2 ;
44556 PyObject *arg3 = (PyObject *) 0 ;
44557 void *argp1 = 0 ;
44558 int res1 = 0 ;
44559 unsigned int val2 ;
44560 int ecode2 = 0 ;
44561 PyObject * obj0 = 0 ;
44562 PyObject * obj1 = 0 ;
44563 PyObject * obj2 = 0 ;
44564 char * kwnames[] = {
44565 (char *) "self",(char *) "n",(char *) "clientData", NULL
44566 };
44567
44568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44570 if (!SWIG_IsOK(res1)) {
44571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44572 }
44573 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44574 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44575 if (!SWIG_IsOK(ecode2)) {
44576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44577 }
44578 arg2 = static_cast< unsigned int >(val2);
44579 arg3 = obj2;
44580 {
44581 PyThreadState* __tstate = wxPyBeginAllowThreads();
44582 wxItemContainer_SetClientData(arg1,arg2,arg3);
44583 wxPyEndAllowThreads(__tstate);
44584 if (PyErr_Occurred()) SWIG_fail;
44585 }
44586 resultobj = SWIG_Py_Void();
44587 return resultobj;
44588 fail:
44589 return NULL;
44590 }
44591
44592
44593 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44594 PyObject *resultobj = 0;
44595 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44596 unsigned int result;
44597 void *argp1 = 0 ;
44598 int res1 = 0 ;
44599 PyObject *swig_obj[1] ;
44600
44601 if (!args) SWIG_fail;
44602 swig_obj[0] = args;
44603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44604 if (!SWIG_IsOK(res1)) {
44605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44606 }
44607 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44608 {
44609 PyThreadState* __tstate = wxPyBeginAllowThreads();
44610 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44611 wxPyEndAllowThreads(__tstate);
44612 if (PyErr_Occurred()) SWIG_fail;
44613 }
44614 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44615 return resultobj;
44616 fail:
44617 return NULL;
44618 }
44619
44620
44621 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44622 PyObject *resultobj = 0;
44623 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44624 bool result;
44625 void *argp1 = 0 ;
44626 int res1 = 0 ;
44627 PyObject *swig_obj[1] ;
44628
44629 if (!args) SWIG_fail;
44630 swig_obj[0] = args;
44631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44632 if (!SWIG_IsOK(res1)) {
44633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44634 }
44635 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44636 {
44637 PyThreadState* __tstate = wxPyBeginAllowThreads();
44638 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44639 wxPyEndAllowThreads(__tstate);
44640 if (PyErr_Occurred()) SWIG_fail;
44641 }
44642 {
44643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44644 }
44645 return resultobj;
44646 fail:
44647 return NULL;
44648 }
44649
44650
44651 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44652 PyObject *resultobj = 0;
44653 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44654 unsigned int arg2 ;
44655 wxString result;
44656 void *argp1 = 0 ;
44657 int res1 = 0 ;
44658 unsigned int val2 ;
44659 int ecode2 = 0 ;
44660 PyObject * obj0 = 0 ;
44661 PyObject * obj1 = 0 ;
44662 char * kwnames[] = {
44663 (char *) "self",(char *) "n", NULL
44664 };
44665
44666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44668 if (!SWIG_IsOK(res1)) {
44669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44670 }
44671 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44672 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44673 if (!SWIG_IsOK(ecode2)) {
44674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44675 }
44676 arg2 = static_cast< unsigned int >(val2);
44677 {
44678 PyThreadState* __tstate = wxPyBeginAllowThreads();
44679 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44680 wxPyEndAllowThreads(__tstate);
44681 if (PyErr_Occurred()) SWIG_fail;
44682 }
44683 {
44684 #if wxUSE_UNICODE
44685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44686 #else
44687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44688 #endif
44689 }
44690 return resultobj;
44691 fail:
44692 return NULL;
44693 }
44694
44695
44696 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44697 PyObject *resultobj = 0;
44698 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44699 wxArrayString result;
44700 void *argp1 = 0 ;
44701 int res1 = 0 ;
44702 PyObject *swig_obj[1] ;
44703
44704 if (!args) SWIG_fail;
44705 swig_obj[0] = args;
44706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44707 if (!SWIG_IsOK(res1)) {
44708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44709 }
44710 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44711 {
44712 PyThreadState* __tstate = wxPyBeginAllowThreads();
44713 result = ((wxItemContainer const *)arg1)->GetStrings();
44714 wxPyEndAllowThreads(__tstate);
44715 if (PyErr_Occurred()) SWIG_fail;
44716 }
44717 {
44718 resultobj = wxArrayString2PyList_helper(result);
44719 }
44720 return resultobj;
44721 fail:
44722 return NULL;
44723 }
44724
44725
44726 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44727 PyObject *resultobj = 0;
44728 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44729 unsigned int arg2 ;
44730 wxString *arg3 = 0 ;
44731 void *argp1 = 0 ;
44732 int res1 = 0 ;
44733 unsigned int val2 ;
44734 int ecode2 = 0 ;
44735 bool temp3 = false ;
44736 PyObject * obj0 = 0 ;
44737 PyObject * obj1 = 0 ;
44738 PyObject * obj2 = 0 ;
44739 char * kwnames[] = {
44740 (char *) "self",(char *) "n",(char *) "s", NULL
44741 };
44742
44743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44745 if (!SWIG_IsOK(res1)) {
44746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44747 }
44748 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44749 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44750 if (!SWIG_IsOK(ecode2)) {
44751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44752 }
44753 arg2 = static_cast< unsigned int >(val2);
44754 {
44755 arg3 = wxString_in_helper(obj2);
44756 if (arg3 == NULL) SWIG_fail;
44757 temp3 = true;
44758 }
44759 {
44760 PyThreadState* __tstate = wxPyBeginAllowThreads();
44761 (arg1)->SetString(arg2,(wxString const &)*arg3);
44762 wxPyEndAllowThreads(__tstate);
44763 if (PyErr_Occurred()) SWIG_fail;
44764 }
44765 resultobj = SWIG_Py_Void();
44766 {
44767 if (temp3)
44768 delete arg3;
44769 }
44770 return resultobj;
44771 fail:
44772 {
44773 if (temp3)
44774 delete arg3;
44775 }
44776 return NULL;
44777 }
44778
44779
44780 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44781 PyObject *resultobj = 0;
44782 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44783 wxString *arg2 = 0 ;
44784 int result;
44785 void *argp1 = 0 ;
44786 int res1 = 0 ;
44787 bool temp2 = false ;
44788 PyObject * obj0 = 0 ;
44789 PyObject * obj1 = 0 ;
44790 char * kwnames[] = {
44791 (char *) "self",(char *) "s", NULL
44792 };
44793
44794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44796 if (!SWIG_IsOK(res1)) {
44797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44798 }
44799 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44800 {
44801 arg2 = wxString_in_helper(obj1);
44802 if (arg2 == NULL) SWIG_fail;
44803 temp2 = true;
44804 }
44805 {
44806 PyThreadState* __tstate = wxPyBeginAllowThreads();
44807 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 resultobj = SWIG_From_int(static_cast< int >(result));
44812 {
44813 if (temp2)
44814 delete arg2;
44815 }
44816 return resultobj;
44817 fail:
44818 {
44819 if (temp2)
44820 delete arg2;
44821 }
44822 return NULL;
44823 }
44824
44825
44826 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44827 PyObject *resultobj = 0;
44828 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44829 int arg2 ;
44830 void *argp1 = 0 ;
44831 int res1 = 0 ;
44832 int val2 ;
44833 int ecode2 = 0 ;
44834 PyObject * obj0 = 0 ;
44835 PyObject * obj1 = 0 ;
44836 char * kwnames[] = {
44837 (char *) "self",(char *) "n", NULL
44838 };
44839
44840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44842 if (!SWIG_IsOK(res1)) {
44843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44844 }
44845 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44846 ecode2 = SWIG_AsVal_int(obj1, &val2);
44847 if (!SWIG_IsOK(ecode2)) {
44848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44849 }
44850 arg2 = static_cast< int >(val2);
44851 {
44852 PyThreadState* __tstate = wxPyBeginAllowThreads();
44853 (arg1)->SetSelection(arg2);
44854 wxPyEndAllowThreads(__tstate);
44855 if (PyErr_Occurred()) SWIG_fail;
44856 }
44857 resultobj = SWIG_Py_Void();
44858 return resultobj;
44859 fail:
44860 return NULL;
44861 }
44862
44863
44864 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44865 PyObject *resultobj = 0;
44866 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44867 int result;
44868 void *argp1 = 0 ;
44869 int res1 = 0 ;
44870 PyObject *swig_obj[1] ;
44871
44872 if (!args) SWIG_fail;
44873 swig_obj[0] = args;
44874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44875 if (!SWIG_IsOK(res1)) {
44876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44877 }
44878 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44879 {
44880 PyThreadState* __tstate = wxPyBeginAllowThreads();
44881 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44882 wxPyEndAllowThreads(__tstate);
44883 if (PyErr_Occurred()) SWIG_fail;
44884 }
44885 resultobj = SWIG_From_int(static_cast< int >(result));
44886 return resultobj;
44887 fail:
44888 return NULL;
44889 }
44890
44891
44892 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44893 PyObject *resultobj = 0;
44894 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44895 wxString *arg2 = 0 ;
44896 bool result;
44897 void *argp1 = 0 ;
44898 int res1 = 0 ;
44899 bool temp2 = false ;
44900 PyObject * obj0 = 0 ;
44901 PyObject * obj1 = 0 ;
44902 char * kwnames[] = {
44903 (char *) "self",(char *) "s", NULL
44904 };
44905
44906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44908 if (!SWIG_IsOK(res1)) {
44909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44910 }
44911 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44912 {
44913 arg2 = wxString_in_helper(obj1);
44914 if (arg2 == NULL) SWIG_fail;
44915 temp2 = true;
44916 }
44917 {
44918 PyThreadState* __tstate = wxPyBeginAllowThreads();
44919 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44920 wxPyEndAllowThreads(__tstate);
44921 if (PyErr_Occurred()) SWIG_fail;
44922 }
44923 {
44924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44925 }
44926 {
44927 if (temp2)
44928 delete arg2;
44929 }
44930 return resultobj;
44931 fail:
44932 {
44933 if (temp2)
44934 delete arg2;
44935 }
44936 return NULL;
44937 }
44938
44939
44940 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44941 PyObject *resultobj = 0;
44942 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44943 wxString result;
44944 void *argp1 = 0 ;
44945 int res1 = 0 ;
44946 PyObject *swig_obj[1] ;
44947
44948 if (!args) SWIG_fail;
44949 swig_obj[0] = args;
44950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44951 if (!SWIG_IsOK(res1)) {
44952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44953 }
44954 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44955 {
44956 PyThreadState* __tstate = wxPyBeginAllowThreads();
44957 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44958 wxPyEndAllowThreads(__tstate);
44959 if (PyErr_Occurred()) SWIG_fail;
44960 }
44961 {
44962 #if wxUSE_UNICODE
44963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44964 #else
44965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44966 #endif
44967 }
44968 return resultobj;
44969 fail:
44970 return NULL;
44971 }
44972
44973
44974 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44975 PyObject *resultobj = 0;
44976 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44977 int arg2 ;
44978 void *argp1 = 0 ;
44979 int res1 = 0 ;
44980 int val2 ;
44981 int ecode2 = 0 ;
44982 PyObject * obj0 = 0 ;
44983 PyObject * obj1 = 0 ;
44984 char * kwnames[] = {
44985 (char *) "self",(char *) "n", NULL
44986 };
44987
44988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44990 if (!SWIG_IsOK(res1)) {
44991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44992 }
44993 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44994 ecode2 = SWIG_AsVal_int(obj1, &val2);
44995 if (!SWIG_IsOK(ecode2)) {
44996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44997 }
44998 arg2 = static_cast< int >(val2);
44999 {
45000 PyThreadState* __tstate = wxPyBeginAllowThreads();
45001 (arg1)->Select(arg2);
45002 wxPyEndAllowThreads(__tstate);
45003 if (PyErr_Occurred()) SWIG_fail;
45004 }
45005 resultobj = SWIG_Py_Void();
45006 return resultobj;
45007 fail:
45008 return NULL;
45009 }
45010
45011
45012 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45013 PyObject *obj;
45014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45015 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45016 return SWIG_Py_Void();
45017 }
45018
45019 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45020 PyObject *obj;
45021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45022 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45023 return SWIG_Py_Void();
45024 }
45025
45026 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45027 PyObject *resultobj = 0;
45028 wxSizerItem *result = 0 ;
45029
45030 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45031 {
45032 PyThreadState* __tstate = wxPyBeginAllowThreads();
45033 result = (wxSizerItem *)new wxSizerItem();
45034 wxPyEndAllowThreads(__tstate);
45035 if (PyErr_Occurred()) SWIG_fail;
45036 }
45037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45038 return resultobj;
45039 fail:
45040 return NULL;
45041 }
45042
45043
45044 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45045 PyObject *resultobj = 0;
45046 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45047 void *argp1 = 0 ;
45048 int res1 = 0 ;
45049 PyObject *swig_obj[1] ;
45050
45051 if (!args) SWIG_fail;
45052 swig_obj[0] = args;
45053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45054 if (!SWIG_IsOK(res1)) {
45055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45056 }
45057 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45058 {
45059 PyThreadState* __tstate = wxPyBeginAllowThreads();
45060 delete arg1;
45061
45062 wxPyEndAllowThreads(__tstate);
45063 if (PyErr_Occurred()) SWIG_fail;
45064 }
45065 resultobj = SWIG_Py_Void();
45066 return resultobj;
45067 fail:
45068 return NULL;
45069 }
45070
45071
45072 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45073 PyObject *resultobj = 0;
45074 wxWindow *arg1 = (wxWindow *) 0 ;
45075 int arg2 ;
45076 int arg3 ;
45077 int arg4 ;
45078 PyObject *arg5 = (PyObject *) NULL ;
45079 wxSizerItem *result = 0 ;
45080 void *argp1 = 0 ;
45081 int res1 = 0 ;
45082 int val2 ;
45083 int ecode2 = 0 ;
45084 int val3 ;
45085 int ecode3 = 0 ;
45086 int val4 ;
45087 int ecode4 = 0 ;
45088 PyObject * obj0 = 0 ;
45089 PyObject * obj1 = 0 ;
45090 PyObject * obj2 = 0 ;
45091 PyObject * obj3 = 0 ;
45092 PyObject * obj4 = 0 ;
45093 char * kwnames[] = {
45094 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45095 };
45096
45097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45099 if (!SWIG_IsOK(res1)) {
45100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45101 }
45102 arg1 = reinterpret_cast< wxWindow * >(argp1);
45103 ecode2 = SWIG_AsVal_int(obj1, &val2);
45104 if (!SWIG_IsOK(ecode2)) {
45105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45106 }
45107 arg2 = static_cast< int >(val2);
45108 ecode3 = SWIG_AsVal_int(obj2, &val3);
45109 if (!SWIG_IsOK(ecode3)) {
45110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45111 }
45112 arg3 = static_cast< int >(val3);
45113 ecode4 = SWIG_AsVal_int(obj3, &val4);
45114 if (!SWIG_IsOK(ecode4)) {
45115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45116 }
45117 arg4 = static_cast< int >(val4);
45118 if (obj4) {
45119 arg5 = obj4;
45120 }
45121 {
45122 PyThreadState* __tstate = wxPyBeginAllowThreads();
45123 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45124 wxPyEndAllowThreads(__tstate);
45125 if (PyErr_Occurred()) SWIG_fail;
45126 }
45127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45128 return resultobj;
45129 fail:
45130 return NULL;
45131 }
45132
45133
45134 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45135 PyObject *resultobj = 0;
45136 int arg1 ;
45137 int arg2 ;
45138 int arg3 ;
45139 int arg4 ;
45140 int arg5 ;
45141 PyObject *arg6 = (PyObject *) NULL ;
45142 wxSizerItem *result = 0 ;
45143 int val1 ;
45144 int ecode1 = 0 ;
45145 int val2 ;
45146 int ecode2 = 0 ;
45147 int val3 ;
45148 int ecode3 = 0 ;
45149 int val4 ;
45150 int ecode4 = 0 ;
45151 int val5 ;
45152 int ecode5 = 0 ;
45153 PyObject * obj0 = 0 ;
45154 PyObject * obj1 = 0 ;
45155 PyObject * obj2 = 0 ;
45156 PyObject * obj3 = 0 ;
45157 PyObject * obj4 = 0 ;
45158 PyObject * obj5 = 0 ;
45159 char * kwnames[] = {
45160 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45161 };
45162
45163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45164 ecode1 = SWIG_AsVal_int(obj0, &val1);
45165 if (!SWIG_IsOK(ecode1)) {
45166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45167 }
45168 arg1 = static_cast< int >(val1);
45169 ecode2 = SWIG_AsVal_int(obj1, &val2);
45170 if (!SWIG_IsOK(ecode2)) {
45171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45172 }
45173 arg2 = static_cast< int >(val2);
45174 ecode3 = SWIG_AsVal_int(obj2, &val3);
45175 if (!SWIG_IsOK(ecode3)) {
45176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45177 }
45178 arg3 = static_cast< int >(val3);
45179 ecode4 = SWIG_AsVal_int(obj3, &val4);
45180 if (!SWIG_IsOK(ecode4)) {
45181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45182 }
45183 arg4 = static_cast< int >(val4);
45184 ecode5 = SWIG_AsVal_int(obj4, &val5);
45185 if (!SWIG_IsOK(ecode5)) {
45186 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45187 }
45188 arg5 = static_cast< int >(val5);
45189 if (obj5) {
45190 arg6 = obj5;
45191 }
45192 {
45193 PyThreadState* __tstate = wxPyBeginAllowThreads();
45194 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45195 wxPyEndAllowThreads(__tstate);
45196 if (PyErr_Occurred()) SWIG_fail;
45197 }
45198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45199 return resultobj;
45200 fail:
45201 return NULL;
45202 }
45203
45204
45205 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45206 PyObject *resultobj = 0;
45207 wxSizer *arg1 = (wxSizer *) 0 ;
45208 int arg2 ;
45209 int arg3 ;
45210 int arg4 ;
45211 PyObject *arg5 = (PyObject *) NULL ;
45212 wxSizerItem *result = 0 ;
45213 int res1 = 0 ;
45214 int val2 ;
45215 int ecode2 = 0 ;
45216 int val3 ;
45217 int ecode3 = 0 ;
45218 int val4 ;
45219 int ecode4 = 0 ;
45220 PyObject * obj0 = 0 ;
45221 PyObject * obj1 = 0 ;
45222 PyObject * obj2 = 0 ;
45223 PyObject * obj3 = 0 ;
45224 PyObject * obj4 = 0 ;
45225 char * kwnames[] = {
45226 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45227 };
45228
45229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45230 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45231 if (!SWIG_IsOK(res1)) {
45232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45233 }
45234 ecode2 = SWIG_AsVal_int(obj1, &val2);
45235 if (!SWIG_IsOK(ecode2)) {
45236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45237 }
45238 arg2 = static_cast< int >(val2);
45239 ecode3 = SWIG_AsVal_int(obj2, &val3);
45240 if (!SWIG_IsOK(ecode3)) {
45241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45242 }
45243 arg3 = static_cast< int >(val3);
45244 ecode4 = SWIG_AsVal_int(obj3, &val4);
45245 if (!SWIG_IsOK(ecode4)) {
45246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45247 }
45248 arg4 = static_cast< int >(val4);
45249 if (obj4) {
45250 arg5 = obj4;
45251 }
45252 {
45253 PyThreadState* __tstate = wxPyBeginAllowThreads();
45254 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45255 wxPyEndAllowThreads(__tstate);
45256 if (PyErr_Occurred()) SWIG_fail;
45257 }
45258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45259 return resultobj;
45260 fail:
45261 return NULL;
45262 }
45263
45264
45265 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45266 PyObject *resultobj = 0;
45267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45268 void *argp1 = 0 ;
45269 int res1 = 0 ;
45270 PyObject *swig_obj[1] ;
45271
45272 if (!args) SWIG_fail;
45273 swig_obj[0] = args;
45274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45275 if (!SWIG_IsOK(res1)) {
45276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45277 }
45278 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45279 {
45280 PyThreadState* __tstate = wxPyBeginAllowThreads();
45281 (arg1)->DeleteWindows();
45282 wxPyEndAllowThreads(__tstate);
45283 if (PyErr_Occurred()) SWIG_fail;
45284 }
45285 resultobj = SWIG_Py_Void();
45286 return resultobj;
45287 fail:
45288 return NULL;
45289 }
45290
45291
45292 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45293 PyObject *resultobj = 0;
45294 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45295 void *argp1 = 0 ;
45296 int res1 = 0 ;
45297 PyObject *swig_obj[1] ;
45298
45299 if (!args) SWIG_fail;
45300 swig_obj[0] = args;
45301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45302 if (!SWIG_IsOK(res1)) {
45303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45304 }
45305 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45306 {
45307 PyThreadState* __tstate = wxPyBeginAllowThreads();
45308 (arg1)->DetachSizer();
45309 wxPyEndAllowThreads(__tstate);
45310 if (PyErr_Occurred()) SWIG_fail;
45311 }
45312 resultobj = SWIG_Py_Void();
45313 return resultobj;
45314 fail:
45315 return NULL;
45316 }
45317
45318
45319 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45320 PyObject *resultobj = 0;
45321 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45322 wxSize result;
45323 void *argp1 = 0 ;
45324 int res1 = 0 ;
45325 PyObject *swig_obj[1] ;
45326
45327 if (!args) SWIG_fail;
45328 swig_obj[0] = args;
45329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45330 if (!SWIG_IsOK(res1)) {
45331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45332 }
45333 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45334 {
45335 PyThreadState* __tstate = wxPyBeginAllowThreads();
45336 result = (arg1)->GetSize();
45337 wxPyEndAllowThreads(__tstate);
45338 if (PyErr_Occurred()) SWIG_fail;
45339 }
45340 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45341 return resultobj;
45342 fail:
45343 return NULL;
45344 }
45345
45346
45347 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45348 PyObject *resultobj = 0;
45349 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45350 wxSize result;
45351 void *argp1 = 0 ;
45352 int res1 = 0 ;
45353 PyObject *swig_obj[1] ;
45354
45355 if (!args) SWIG_fail;
45356 swig_obj[0] = args;
45357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45358 if (!SWIG_IsOK(res1)) {
45359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45360 }
45361 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45362 {
45363 PyThreadState* __tstate = wxPyBeginAllowThreads();
45364 result = (arg1)->CalcMin();
45365 wxPyEndAllowThreads(__tstate);
45366 if (PyErr_Occurred()) SWIG_fail;
45367 }
45368 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45369 return resultobj;
45370 fail:
45371 return NULL;
45372 }
45373
45374
45375 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45376 PyObject *resultobj = 0;
45377 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45378 wxPoint *arg2 = 0 ;
45379 wxSize *arg3 = 0 ;
45380 void *argp1 = 0 ;
45381 int res1 = 0 ;
45382 wxPoint temp2 ;
45383 wxSize temp3 ;
45384 PyObject * obj0 = 0 ;
45385 PyObject * obj1 = 0 ;
45386 PyObject * obj2 = 0 ;
45387 char * kwnames[] = {
45388 (char *) "self",(char *) "pos",(char *) "size", NULL
45389 };
45390
45391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45393 if (!SWIG_IsOK(res1)) {
45394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45395 }
45396 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45397 {
45398 arg2 = &temp2;
45399 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45400 }
45401 {
45402 arg3 = &temp3;
45403 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45404 }
45405 {
45406 PyThreadState* __tstate = wxPyBeginAllowThreads();
45407 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45408 wxPyEndAllowThreads(__tstate);
45409 if (PyErr_Occurred()) SWIG_fail;
45410 }
45411 resultobj = SWIG_Py_Void();
45412 return resultobj;
45413 fail:
45414 return NULL;
45415 }
45416
45417
45418 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45419 PyObject *resultobj = 0;
45420 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45421 wxSize result;
45422 void *argp1 = 0 ;
45423 int res1 = 0 ;
45424 PyObject *swig_obj[1] ;
45425
45426 if (!args) SWIG_fail;
45427 swig_obj[0] = args;
45428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45429 if (!SWIG_IsOK(res1)) {
45430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45431 }
45432 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45433 {
45434 PyThreadState* __tstate = wxPyBeginAllowThreads();
45435 result = (arg1)->GetMinSize();
45436 wxPyEndAllowThreads(__tstate);
45437 if (PyErr_Occurred()) SWIG_fail;
45438 }
45439 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45440 return resultobj;
45441 fail:
45442 return NULL;
45443 }
45444
45445
45446 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45447 PyObject *resultobj = 0;
45448 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45449 wxSize result;
45450 void *argp1 = 0 ;
45451 int res1 = 0 ;
45452 PyObject *swig_obj[1] ;
45453
45454 if (!args) SWIG_fail;
45455 swig_obj[0] = args;
45456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45457 if (!SWIG_IsOK(res1)) {
45458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45459 }
45460 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45461 {
45462 PyThreadState* __tstate = wxPyBeginAllowThreads();
45463 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45464 wxPyEndAllowThreads(__tstate);
45465 if (PyErr_Occurred()) SWIG_fail;
45466 }
45467 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45468 return resultobj;
45469 fail:
45470 return NULL;
45471 }
45472
45473
45474 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45475 PyObject *resultobj = 0;
45476 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45477 int arg2 ;
45478 int arg3 ;
45479 void *argp1 = 0 ;
45480 int res1 = 0 ;
45481 int val2 ;
45482 int ecode2 = 0 ;
45483 int val3 ;
45484 int ecode3 = 0 ;
45485 PyObject * obj0 = 0 ;
45486 PyObject * obj1 = 0 ;
45487 PyObject * obj2 = 0 ;
45488 char * kwnames[] = {
45489 (char *) "self",(char *) "x",(char *) "y", NULL
45490 };
45491
45492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45494 if (!SWIG_IsOK(res1)) {
45495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45496 }
45497 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45498 ecode2 = SWIG_AsVal_int(obj1, &val2);
45499 if (!SWIG_IsOK(ecode2)) {
45500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45501 }
45502 arg2 = static_cast< int >(val2);
45503 ecode3 = SWIG_AsVal_int(obj2, &val3);
45504 if (!SWIG_IsOK(ecode3)) {
45505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45506 }
45507 arg3 = static_cast< int >(val3);
45508 {
45509 PyThreadState* __tstate = wxPyBeginAllowThreads();
45510 (arg1)->SetInitSize(arg2,arg3);
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_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45522 PyObject *resultobj = 0;
45523 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45524 int arg2 ;
45525 int arg3 ;
45526 void *argp1 = 0 ;
45527 int res1 = 0 ;
45528 int val2 ;
45529 int ecode2 = 0 ;
45530 int val3 ;
45531 int ecode3 = 0 ;
45532 PyObject * obj0 = 0 ;
45533 PyObject * obj1 = 0 ;
45534 PyObject * obj2 = 0 ;
45535 char * kwnames[] = {
45536 (char *) "self",(char *) "width",(char *) "height", NULL
45537 };
45538
45539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45541 if (!SWIG_IsOK(res1)) {
45542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45543 }
45544 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45545 ecode2 = SWIG_AsVal_int(obj1, &val2);
45546 if (!SWIG_IsOK(ecode2)) {
45547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45548 }
45549 arg2 = static_cast< int >(val2);
45550 ecode3 = SWIG_AsVal_int(obj2, &val3);
45551 if (!SWIG_IsOK(ecode3)) {
45552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45553 }
45554 arg3 = static_cast< int >(val3);
45555 {
45556 PyThreadState* __tstate = wxPyBeginAllowThreads();
45557 (arg1)->SetRatio(arg2,arg3);
45558 wxPyEndAllowThreads(__tstate);
45559 if (PyErr_Occurred()) SWIG_fail;
45560 }
45561 resultobj = SWIG_Py_Void();
45562 return resultobj;
45563 fail:
45564 return NULL;
45565 }
45566
45567
45568 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45569 PyObject *resultobj = 0;
45570 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45571 wxSize *arg2 = 0 ;
45572 void *argp1 = 0 ;
45573 int res1 = 0 ;
45574 wxSize temp2 ;
45575 PyObject * obj0 = 0 ;
45576 PyObject * obj1 = 0 ;
45577 char * kwnames[] = {
45578 (char *) "self",(char *) "size", NULL
45579 };
45580
45581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45583 if (!SWIG_IsOK(res1)) {
45584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45585 }
45586 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45587 {
45588 arg2 = &temp2;
45589 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45590 }
45591 {
45592 PyThreadState* __tstate = wxPyBeginAllowThreads();
45593 (arg1)->SetRatio((wxSize const &)*arg2);
45594 wxPyEndAllowThreads(__tstate);
45595 if (PyErr_Occurred()) SWIG_fail;
45596 }
45597 resultobj = SWIG_Py_Void();
45598 return resultobj;
45599 fail:
45600 return NULL;
45601 }
45602
45603
45604 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45605 PyObject *resultobj = 0;
45606 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45607 float arg2 ;
45608 void *argp1 = 0 ;
45609 int res1 = 0 ;
45610 float val2 ;
45611 int ecode2 = 0 ;
45612 PyObject * obj0 = 0 ;
45613 PyObject * obj1 = 0 ;
45614 char * kwnames[] = {
45615 (char *) "self",(char *) "ratio", NULL
45616 };
45617
45618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45620 if (!SWIG_IsOK(res1)) {
45621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45622 }
45623 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45624 ecode2 = SWIG_AsVal_float(obj1, &val2);
45625 if (!SWIG_IsOK(ecode2)) {
45626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45627 }
45628 arg2 = static_cast< float >(val2);
45629 {
45630 PyThreadState* __tstate = wxPyBeginAllowThreads();
45631 (arg1)->SetRatio(arg2);
45632 wxPyEndAllowThreads(__tstate);
45633 if (PyErr_Occurred()) SWIG_fail;
45634 }
45635 resultobj = SWIG_Py_Void();
45636 return resultobj;
45637 fail:
45638 return NULL;
45639 }
45640
45641
45642 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45643 PyObject *resultobj = 0;
45644 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45645 float result;
45646 void *argp1 = 0 ;
45647 int res1 = 0 ;
45648 PyObject *swig_obj[1] ;
45649
45650 if (!args) SWIG_fail;
45651 swig_obj[0] = args;
45652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45653 if (!SWIG_IsOK(res1)) {
45654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45655 }
45656 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45657 {
45658 PyThreadState* __tstate = wxPyBeginAllowThreads();
45659 result = (float)(arg1)->GetRatio();
45660 wxPyEndAllowThreads(__tstate);
45661 if (PyErr_Occurred()) SWIG_fail;
45662 }
45663 resultobj = SWIG_From_float(static_cast< float >(result));
45664 return resultobj;
45665 fail:
45666 return NULL;
45667 }
45668
45669
45670 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45671 PyObject *resultobj = 0;
45672 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45673 wxRect result;
45674 void *argp1 = 0 ;
45675 int res1 = 0 ;
45676 PyObject *swig_obj[1] ;
45677
45678 if (!args) SWIG_fail;
45679 swig_obj[0] = args;
45680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45681 if (!SWIG_IsOK(res1)) {
45682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45683 }
45684 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45685 {
45686 PyThreadState* __tstate = wxPyBeginAllowThreads();
45687 result = (arg1)->GetRect();
45688 wxPyEndAllowThreads(__tstate);
45689 if (PyErr_Occurred()) SWIG_fail;
45690 }
45691 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45692 return resultobj;
45693 fail:
45694 return NULL;
45695 }
45696
45697
45698 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45699 PyObject *resultobj = 0;
45700 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45701 bool result;
45702 void *argp1 = 0 ;
45703 int res1 = 0 ;
45704 PyObject *swig_obj[1] ;
45705
45706 if (!args) SWIG_fail;
45707 swig_obj[0] = args;
45708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45709 if (!SWIG_IsOK(res1)) {
45710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45711 }
45712 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45713 {
45714 PyThreadState* __tstate = wxPyBeginAllowThreads();
45715 result = (bool)(arg1)->IsWindow();
45716 wxPyEndAllowThreads(__tstate);
45717 if (PyErr_Occurred()) SWIG_fail;
45718 }
45719 {
45720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45721 }
45722 return resultobj;
45723 fail:
45724 return NULL;
45725 }
45726
45727
45728 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45729 PyObject *resultobj = 0;
45730 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45731 bool result;
45732 void *argp1 = 0 ;
45733 int res1 = 0 ;
45734 PyObject *swig_obj[1] ;
45735
45736 if (!args) SWIG_fail;
45737 swig_obj[0] = args;
45738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45739 if (!SWIG_IsOK(res1)) {
45740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45741 }
45742 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45743 {
45744 PyThreadState* __tstate = wxPyBeginAllowThreads();
45745 result = (bool)(arg1)->IsSizer();
45746 wxPyEndAllowThreads(__tstate);
45747 if (PyErr_Occurred()) SWIG_fail;
45748 }
45749 {
45750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45751 }
45752 return resultobj;
45753 fail:
45754 return NULL;
45755 }
45756
45757
45758 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45759 PyObject *resultobj = 0;
45760 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45761 bool result;
45762 void *argp1 = 0 ;
45763 int res1 = 0 ;
45764 PyObject *swig_obj[1] ;
45765
45766 if (!args) SWIG_fail;
45767 swig_obj[0] = args;
45768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45769 if (!SWIG_IsOK(res1)) {
45770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45771 }
45772 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45773 {
45774 PyThreadState* __tstate = wxPyBeginAllowThreads();
45775 result = (bool)(arg1)->IsSpacer();
45776 wxPyEndAllowThreads(__tstate);
45777 if (PyErr_Occurred()) SWIG_fail;
45778 }
45779 {
45780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45781 }
45782 return resultobj;
45783 fail:
45784 return NULL;
45785 }
45786
45787
45788 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45789 PyObject *resultobj = 0;
45790 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45791 int arg2 ;
45792 void *argp1 = 0 ;
45793 int res1 = 0 ;
45794 int val2 ;
45795 int ecode2 = 0 ;
45796 PyObject * obj0 = 0 ;
45797 PyObject * obj1 = 0 ;
45798 char * kwnames[] = {
45799 (char *) "self",(char *) "proportion", NULL
45800 };
45801
45802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45804 if (!SWIG_IsOK(res1)) {
45805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45806 }
45807 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45808 ecode2 = SWIG_AsVal_int(obj1, &val2);
45809 if (!SWIG_IsOK(ecode2)) {
45810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45811 }
45812 arg2 = static_cast< int >(val2);
45813 {
45814 PyThreadState* __tstate = wxPyBeginAllowThreads();
45815 (arg1)->SetProportion(arg2);
45816 wxPyEndAllowThreads(__tstate);
45817 if (PyErr_Occurred()) SWIG_fail;
45818 }
45819 resultobj = SWIG_Py_Void();
45820 return resultobj;
45821 fail:
45822 return NULL;
45823 }
45824
45825
45826 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45827 PyObject *resultobj = 0;
45828 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45829 int result;
45830 void *argp1 = 0 ;
45831 int res1 = 0 ;
45832 PyObject *swig_obj[1] ;
45833
45834 if (!args) SWIG_fail;
45835 swig_obj[0] = args;
45836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45837 if (!SWIG_IsOK(res1)) {
45838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45839 }
45840 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45841 {
45842 PyThreadState* __tstate = wxPyBeginAllowThreads();
45843 result = (int)(arg1)->GetProportion();
45844 wxPyEndAllowThreads(__tstate);
45845 if (PyErr_Occurred()) SWIG_fail;
45846 }
45847 resultobj = SWIG_From_int(static_cast< int >(result));
45848 return resultobj;
45849 fail:
45850 return NULL;
45851 }
45852
45853
45854 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45855 PyObject *resultobj = 0;
45856 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45857 int arg2 ;
45858 void *argp1 = 0 ;
45859 int res1 = 0 ;
45860 int val2 ;
45861 int ecode2 = 0 ;
45862 PyObject * obj0 = 0 ;
45863 PyObject * obj1 = 0 ;
45864 char * kwnames[] = {
45865 (char *) "self",(char *) "flag", NULL
45866 };
45867
45868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45870 if (!SWIG_IsOK(res1)) {
45871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45872 }
45873 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45874 ecode2 = SWIG_AsVal_int(obj1, &val2);
45875 if (!SWIG_IsOK(ecode2)) {
45876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45877 }
45878 arg2 = static_cast< int >(val2);
45879 {
45880 PyThreadState* __tstate = wxPyBeginAllowThreads();
45881 (arg1)->SetFlag(arg2);
45882 wxPyEndAllowThreads(__tstate);
45883 if (PyErr_Occurred()) SWIG_fail;
45884 }
45885 resultobj = SWIG_Py_Void();
45886 return resultobj;
45887 fail:
45888 return NULL;
45889 }
45890
45891
45892 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45893 PyObject *resultobj = 0;
45894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45895 int result;
45896 void *argp1 = 0 ;
45897 int res1 = 0 ;
45898 PyObject *swig_obj[1] ;
45899
45900 if (!args) SWIG_fail;
45901 swig_obj[0] = args;
45902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45903 if (!SWIG_IsOK(res1)) {
45904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45905 }
45906 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45907 {
45908 PyThreadState* __tstate = wxPyBeginAllowThreads();
45909 result = (int)(arg1)->GetFlag();
45910 wxPyEndAllowThreads(__tstate);
45911 if (PyErr_Occurred()) SWIG_fail;
45912 }
45913 resultobj = SWIG_From_int(static_cast< int >(result));
45914 return resultobj;
45915 fail:
45916 return NULL;
45917 }
45918
45919
45920 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45921 PyObject *resultobj = 0;
45922 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45923 int arg2 ;
45924 void *argp1 = 0 ;
45925 int res1 = 0 ;
45926 int val2 ;
45927 int ecode2 = 0 ;
45928 PyObject * obj0 = 0 ;
45929 PyObject * obj1 = 0 ;
45930 char * kwnames[] = {
45931 (char *) "self",(char *) "border", NULL
45932 };
45933
45934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45936 if (!SWIG_IsOK(res1)) {
45937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45938 }
45939 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45940 ecode2 = SWIG_AsVal_int(obj1, &val2);
45941 if (!SWIG_IsOK(ecode2)) {
45942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45943 }
45944 arg2 = static_cast< int >(val2);
45945 {
45946 PyThreadState* __tstate = wxPyBeginAllowThreads();
45947 (arg1)->SetBorder(arg2);
45948 wxPyEndAllowThreads(__tstate);
45949 if (PyErr_Occurred()) SWIG_fail;
45950 }
45951 resultobj = SWIG_Py_Void();
45952 return resultobj;
45953 fail:
45954 return NULL;
45955 }
45956
45957
45958 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45959 PyObject *resultobj = 0;
45960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45961 int result;
45962 void *argp1 = 0 ;
45963 int res1 = 0 ;
45964 PyObject *swig_obj[1] ;
45965
45966 if (!args) SWIG_fail;
45967 swig_obj[0] = args;
45968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45969 if (!SWIG_IsOK(res1)) {
45970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45971 }
45972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45973 {
45974 PyThreadState* __tstate = wxPyBeginAllowThreads();
45975 result = (int)(arg1)->GetBorder();
45976 wxPyEndAllowThreads(__tstate);
45977 if (PyErr_Occurred()) SWIG_fail;
45978 }
45979 resultobj = SWIG_From_int(static_cast< int >(result));
45980 return resultobj;
45981 fail:
45982 return NULL;
45983 }
45984
45985
45986 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45987 PyObject *resultobj = 0;
45988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45989 wxWindow *result = 0 ;
45990 void *argp1 = 0 ;
45991 int res1 = 0 ;
45992 PyObject *swig_obj[1] ;
45993
45994 if (!args) SWIG_fail;
45995 swig_obj[0] = args;
45996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45997 if (!SWIG_IsOK(res1)) {
45998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45999 }
46000 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46001 {
46002 PyThreadState* __tstate = wxPyBeginAllowThreads();
46003 result = (wxWindow *)(arg1)->GetWindow();
46004 wxPyEndAllowThreads(__tstate);
46005 if (PyErr_Occurred()) SWIG_fail;
46006 }
46007 {
46008 resultobj = wxPyMake_wxObject(result, 0);
46009 }
46010 return resultobj;
46011 fail:
46012 return NULL;
46013 }
46014
46015
46016 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46017 PyObject *resultobj = 0;
46018 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46019 wxWindow *arg2 = (wxWindow *) 0 ;
46020 void *argp1 = 0 ;
46021 int res1 = 0 ;
46022 void *argp2 = 0 ;
46023 int res2 = 0 ;
46024 PyObject * obj0 = 0 ;
46025 PyObject * obj1 = 0 ;
46026 char * kwnames[] = {
46027 (char *) "self",(char *) "window", NULL
46028 };
46029
46030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46032 if (!SWIG_IsOK(res1)) {
46033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46034 }
46035 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46037 if (!SWIG_IsOK(res2)) {
46038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46039 }
46040 arg2 = reinterpret_cast< wxWindow * >(argp2);
46041 {
46042 PyThreadState* __tstate = wxPyBeginAllowThreads();
46043 (arg1)->SetWindow(arg2);
46044 wxPyEndAllowThreads(__tstate);
46045 if (PyErr_Occurred()) SWIG_fail;
46046 }
46047 resultobj = SWIG_Py_Void();
46048 return resultobj;
46049 fail:
46050 return NULL;
46051 }
46052
46053
46054 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46055 PyObject *resultobj = 0;
46056 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46057 wxSizer *result = 0 ;
46058 void *argp1 = 0 ;
46059 int res1 = 0 ;
46060 PyObject *swig_obj[1] ;
46061
46062 if (!args) SWIG_fail;
46063 swig_obj[0] = args;
46064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46065 if (!SWIG_IsOK(res1)) {
46066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46067 }
46068 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46069 {
46070 PyThreadState* __tstate = wxPyBeginAllowThreads();
46071 result = (wxSizer *)(arg1)->GetSizer();
46072 wxPyEndAllowThreads(__tstate);
46073 if (PyErr_Occurred()) SWIG_fail;
46074 }
46075 {
46076 resultobj = wxPyMake_wxObject(result, (bool)0);
46077 }
46078 return resultobj;
46079 fail:
46080 return NULL;
46081 }
46082
46083
46084 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46085 PyObject *resultobj = 0;
46086 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46087 wxSizer *arg2 = (wxSizer *) 0 ;
46088 void *argp1 = 0 ;
46089 int res1 = 0 ;
46090 int res2 = 0 ;
46091 PyObject * obj0 = 0 ;
46092 PyObject * obj1 = 0 ;
46093 char * kwnames[] = {
46094 (char *) "self",(char *) "sizer", NULL
46095 };
46096
46097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",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_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46101 }
46102 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46103 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46104 if (!SWIG_IsOK(res2)) {
46105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46106 }
46107 {
46108 PyThreadState* __tstate = wxPyBeginAllowThreads();
46109 (arg1)->SetSizer(arg2);
46110 wxPyEndAllowThreads(__tstate);
46111 if (PyErr_Occurred()) SWIG_fail;
46112 }
46113 resultobj = SWIG_Py_Void();
46114 return resultobj;
46115 fail:
46116 return NULL;
46117 }
46118
46119
46120 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46121 PyObject *resultobj = 0;
46122 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46123 wxSize *result = 0 ;
46124 void *argp1 = 0 ;
46125 int res1 = 0 ;
46126 PyObject *swig_obj[1] ;
46127
46128 if (!args) SWIG_fail;
46129 swig_obj[0] = args;
46130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46131 if (!SWIG_IsOK(res1)) {
46132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46133 }
46134 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46135 {
46136 PyThreadState* __tstate = wxPyBeginAllowThreads();
46137 {
46138 wxSize const &_result_ref = (arg1)->GetSpacer();
46139 result = (wxSize *) &_result_ref;
46140 }
46141 wxPyEndAllowThreads(__tstate);
46142 if (PyErr_Occurred()) SWIG_fail;
46143 }
46144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46145 return resultobj;
46146 fail:
46147 return NULL;
46148 }
46149
46150
46151 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46152 PyObject *resultobj = 0;
46153 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46154 wxSize *arg2 = 0 ;
46155 void *argp1 = 0 ;
46156 int res1 = 0 ;
46157 wxSize temp2 ;
46158 PyObject * obj0 = 0 ;
46159 PyObject * obj1 = 0 ;
46160 char * kwnames[] = {
46161 (char *) "self",(char *) "size", NULL
46162 };
46163
46164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46166 if (!SWIG_IsOK(res1)) {
46167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46168 }
46169 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46170 {
46171 arg2 = &temp2;
46172 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46173 }
46174 {
46175 PyThreadState* __tstate = wxPyBeginAllowThreads();
46176 (arg1)->SetSpacer((wxSize const &)*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_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46188 PyObject *resultobj = 0;
46189 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46190 bool arg2 ;
46191 void *argp1 = 0 ;
46192 int res1 = 0 ;
46193 bool val2 ;
46194 int ecode2 = 0 ;
46195 PyObject * obj0 = 0 ;
46196 PyObject * obj1 = 0 ;
46197 char * kwnames[] = {
46198 (char *) "self",(char *) "show", NULL
46199 };
46200
46201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46203 if (!SWIG_IsOK(res1)) {
46204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46205 }
46206 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46208 if (!SWIG_IsOK(ecode2)) {
46209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46210 }
46211 arg2 = static_cast< bool >(val2);
46212 {
46213 PyThreadState* __tstate = wxPyBeginAllowThreads();
46214 (arg1)->Show(arg2);
46215 wxPyEndAllowThreads(__tstate);
46216 if (PyErr_Occurred()) SWIG_fail;
46217 }
46218 resultobj = SWIG_Py_Void();
46219 return resultobj;
46220 fail:
46221 return NULL;
46222 }
46223
46224
46225 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46226 PyObject *resultobj = 0;
46227 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46228 bool result;
46229 void *argp1 = 0 ;
46230 int res1 = 0 ;
46231 PyObject *swig_obj[1] ;
46232
46233 if (!args) SWIG_fail;
46234 swig_obj[0] = args;
46235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46236 if (!SWIG_IsOK(res1)) {
46237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46238 }
46239 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46240 {
46241 PyThreadState* __tstate = wxPyBeginAllowThreads();
46242 result = (bool)(arg1)->IsShown();
46243 wxPyEndAllowThreads(__tstate);
46244 if (PyErr_Occurred()) SWIG_fail;
46245 }
46246 {
46247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46248 }
46249 return resultobj;
46250 fail:
46251 return NULL;
46252 }
46253
46254
46255 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46256 PyObject *resultobj = 0;
46257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46258 wxPoint result;
46259 void *argp1 = 0 ;
46260 int res1 = 0 ;
46261 PyObject *swig_obj[1] ;
46262
46263 if (!args) SWIG_fail;
46264 swig_obj[0] = args;
46265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46266 if (!SWIG_IsOK(res1)) {
46267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46268 }
46269 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46270 {
46271 PyThreadState* __tstate = wxPyBeginAllowThreads();
46272 result = (arg1)->GetPosition();
46273 wxPyEndAllowThreads(__tstate);
46274 if (PyErr_Occurred()) SWIG_fail;
46275 }
46276 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46277 return resultobj;
46278 fail:
46279 return NULL;
46280 }
46281
46282
46283 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46284 PyObject *resultobj = 0;
46285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46286 PyObject *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_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46296 }
46297 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46298 {
46299 PyThreadState* __tstate = wxPyBeginAllowThreads();
46300 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46301 wxPyEndAllowThreads(__tstate);
46302 if (PyErr_Occurred()) SWIG_fail;
46303 }
46304 resultobj = result;
46305 return resultobj;
46306 fail:
46307 return NULL;
46308 }
46309
46310
46311 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46312 PyObject *resultobj = 0;
46313 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46314 PyObject *arg2 = (PyObject *) 0 ;
46315 void *argp1 = 0 ;
46316 int res1 = 0 ;
46317 PyObject * obj0 = 0 ;
46318 PyObject * obj1 = 0 ;
46319 char * kwnames[] = {
46320 (char *) "self",(char *) "userData", NULL
46321 };
46322
46323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46325 if (!SWIG_IsOK(res1)) {
46326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46327 }
46328 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46329 arg2 = obj1;
46330 {
46331 PyThreadState* __tstate = wxPyBeginAllowThreads();
46332 wxSizerItem_SetUserData(arg1,arg2);
46333 wxPyEndAllowThreads(__tstate);
46334 if (PyErr_Occurred()) SWIG_fail;
46335 }
46336 resultobj = SWIG_Py_Void();
46337 return resultobj;
46338 fail:
46339 return NULL;
46340 }
46341
46342
46343 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46344 PyObject *obj;
46345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46346 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46347 return SWIG_Py_Void();
46348 }
46349
46350 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46351 return SWIG_Python_InitShadowInstance(args);
46352 }
46353
46354 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46355 PyObject *resultobj = 0;
46356 wxSizer *arg1 = (wxSizer *) 0 ;
46357 void *argp1 = 0 ;
46358 int res1 = 0 ;
46359 PyObject *swig_obj[1] ;
46360
46361 if (!args) SWIG_fail;
46362 swig_obj[0] = args;
46363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46364 if (!SWIG_IsOK(res1)) {
46365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46366 }
46367 arg1 = reinterpret_cast< wxSizer * >(argp1);
46368 {
46369 PyThreadState* __tstate = wxPyBeginAllowThreads();
46370 delete arg1;
46371
46372 wxPyEndAllowThreads(__tstate);
46373 if (PyErr_Occurred()) SWIG_fail;
46374 }
46375 resultobj = SWIG_Py_Void();
46376 return resultobj;
46377 fail:
46378 return NULL;
46379 }
46380
46381
46382 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46383 PyObject *resultobj = 0;
46384 wxSizer *arg1 = (wxSizer *) 0 ;
46385 PyObject *arg2 = (PyObject *) 0 ;
46386 void *argp1 = 0 ;
46387 int res1 = 0 ;
46388 PyObject * obj0 = 0 ;
46389 PyObject * obj1 = 0 ;
46390 char * kwnames[] = {
46391 (char *) "self",(char *) "_self", NULL
46392 };
46393
46394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46396 if (!SWIG_IsOK(res1)) {
46397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46398 }
46399 arg1 = reinterpret_cast< wxSizer * >(argp1);
46400 arg2 = obj1;
46401 {
46402 PyThreadState* __tstate = wxPyBeginAllowThreads();
46403 wxSizer__setOORInfo(arg1,arg2);
46404 wxPyEndAllowThreads(__tstate);
46405 if (PyErr_Occurred()) SWIG_fail;
46406 }
46407 resultobj = SWIG_Py_Void();
46408 return resultobj;
46409 fail:
46410 return NULL;
46411 }
46412
46413
46414 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46415 PyObject *resultobj = 0;
46416 wxSizer *arg1 = (wxSizer *) 0 ;
46417 PyObject *arg2 = (PyObject *) 0 ;
46418 int arg3 = (int) 0 ;
46419 int arg4 = (int) 0 ;
46420 int arg5 = (int) 0 ;
46421 PyObject *arg6 = (PyObject *) NULL ;
46422 wxSizerItem *result = 0 ;
46423 void *argp1 = 0 ;
46424 int res1 = 0 ;
46425 int val3 ;
46426 int ecode3 = 0 ;
46427 int val4 ;
46428 int ecode4 = 0 ;
46429 int val5 ;
46430 int ecode5 = 0 ;
46431 PyObject * obj0 = 0 ;
46432 PyObject * obj1 = 0 ;
46433 PyObject * obj2 = 0 ;
46434 PyObject * obj3 = 0 ;
46435 PyObject * obj4 = 0 ;
46436 PyObject * obj5 = 0 ;
46437 char * kwnames[] = {
46438 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46439 };
46440
46441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46443 if (!SWIG_IsOK(res1)) {
46444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46445 }
46446 arg1 = reinterpret_cast< wxSizer * >(argp1);
46447 arg2 = obj1;
46448 if (obj2) {
46449 ecode3 = SWIG_AsVal_int(obj2, &val3);
46450 if (!SWIG_IsOK(ecode3)) {
46451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46452 }
46453 arg3 = static_cast< int >(val3);
46454 }
46455 if (obj3) {
46456 ecode4 = SWIG_AsVal_int(obj3, &val4);
46457 if (!SWIG_IsOK(ecode4)) {
46458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46459 }
46460 arg4 = static_cast< int >(val4);
46461 }
46462 if (obj4) {
46463 ecode5 = SWIG_AsVal_int(obj4, &val5);
46464 if (!SWIG_IsOK(ecode5)) {
46465 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46466 }
46467 arg5 = static_cast< int >(val5);
46468 }
46469 if (obj5) {
46470 arg6 = obj5;
46471 }
46472 {
46473 PyThreadState* __tstate = wxPyBeginAllowThreads();
46474 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46475 wxPyEndAllowThreads(__tstate);
46476 if (PyErr_Occurred()) SWIG_fail;
46477 }
46478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46479 return resultobj;
46480 fail:
46481 return NULL;
46482 }
46483
46484
46485 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46486 PyObject *resultobj = 0;
46487 wxSizer *arg1 = (wxSizer *) 0 ;
46488 int arg2 ;
46489 PyObject *arg3 = (PyObject *) 0 ;
46490 int arg4 = (int) 0 ;
46491 int arg5 = (int) 0 ;
46492 int arg6 = (int) 0 ;
46493 PyObject *arg7 = (PyObject *) NULL ;
46494 wxSizerItem *result = 0 ;
46495 void *argp1 = 0 ;
46496 int res1 = 0 ;
46497 int val2 ;
46498 int ecode2 = 0 ;
46499 int val4 ;
46500 int ecode4 = 0 ;
46501 int val5 ;
46502 int ecode5 = 0 ;
46503 int val6 ;
46504 int ecode6 = 0 ;
46505 PyObject * obj0 = 0 ;
46506 PyObject * obj1 = 0 ;
46507 PyObject * obj2 = 0 ;
46508 PyObject * obj3 = 0 ;
46509 PyObject * obj4 = 0 ;
46510 PyObject * obj5 = 0 ;
46511 PyObject * obj6 = 0 ;
46512 char * kwnames[] = {
46513 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46514 };
46515
46516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46518 if (!SWIG_IsOK(res1)) {
46519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46520 }
46521 arg1 = reinterpret_cast< wxSizer * >(argp1);
46522 ecode2 = SWIG_AsVal_int(obj1, &val2);
46523 if (!SWIG_IsOK(ecode2)) {
46524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46525 }
46526 arg2 = static_cast< int >(val2);
46527 arg3 = obj2;
46528 if (obj3) {
46529 ecode4 = SWIG_AsVal_int(obj3, &val4);
46530 if (!SWIG_IsOK(ecode4)) {
46531 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46532 }
46533 arg4 = static_cast< int >(val4);
46534 }
46535 if (obj4) {
46536 ecode5 = SWIG_AsVal_int(obj4, &val5);
46537 if (!SWIG_IsOK(ecode5)) {
46538 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46539 }
46540 arg5 = static_cast< int >(val5);
46541 }
46542 if (obj5) {
46543 ecode6 = SWIG_AsVal_int(obj5, &val6);
46544 if (!SWIG_IsOK(ecode6)) {
46545 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46546 }
46547 arg6 = static_cast< int >(val6);
46548 }
46549 if (obj6) {
46550 arg7 = obj6;
46551 }
46552 {
46553 PyThreadState* __tstate = wxPyBeginAllowThreads();
46554 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46555 wxPyEndAllowThreads(__tstate);
46556 if (PyErr_Occurred()) SWIG_fail;
46557 }
46558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46559 return resultobj;
46560 fail:
46561 return NULL;
46562 }
46563
46564
46565 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46566 PyObject *resultobj = 0;
46567 wxSizer *arg1 = (wxSizer *) 0 ;
46568 PyObject *arg2 = (PyObject *) 0 ;
46569 int arg3 = (int) 0 ;
46570 int arg4 = (int) 0 ;
46571 int arg5 = (int) 0 ;
46572 PyObject *arg6 = (PyObject *) NULL ;
46573 wxSizerItem *result = 0 ;
46574 void *argp1 = 0 ;
46575 int res1 = 0 ;
46576 int val3 ;
46577 int ecode3 = 0 ;
46578 int val4 ;
46579 int ecode4 = 0 ;
46580 int val5 ;
46581 int ecode5 = 0 ;
46582 PyObject * obj0 = 0 ;
46583 PyObject * obj1 = 0 ;
46584 PyObject * obj2 = 0 ;
46585 PyObject * obj3 = 0 ;
46586 PyObject * obj4 = 0 ;
46587 PyObject * obj5 = 0 ;
46588 char * kwnames[] = {
46589 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46590 };
46591
46592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46596 }
46597 arg1 = reinterpret_cast< wxSizer * >(argp1);
46598 arg2 = obj1;
46599 if (obj2) {
46600 ecode3 = SWIG_AsVal_int(obj2, &val3);
46601 if (!SWIG_IsOK(ecode3)) {
46602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46603 }
46604 arg3 = static_cast< int >(val3);
46605 }
46606 if (obj3) {
46607 ecode4 = SWIG_AsVal_int(obj3, &val4);
46608 if (!SWIG_IsOK(ecode4)) {
46609 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46610 }
46611 arg4 = static_cast< int >(val4);
46612 }
46613 if (obj4) {
46614 ecode5 = SWIG_AsVal_int(obj4, &val5);
46615 if (!SWIG_IsOK(ecode5)) {
46616 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46617 }
46618 arg5 = static_cast< int >(val5);
46619 }
46620 if (obj5) {
46621 arg6 = obj5;
46622 }
46623 {
46624 PyThreadState* __tstate = wxPyBeginAllowThreads();
46625 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46626 wxPyEndAllowThreads(__tstate);
46627 if (PyErr_Occurred()) SWIG_fail;
46628 }
46629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46630 return resultobj;
46631 fail:
46632 return NULL;
46633 }
46634
46635
46636 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46637 PyObject *resultobj = 0;
46638 wxSizer *arg1 = (wxSizer *) 0 ;
46639 PyObject *arg2 = (PyObject *) 0 ;
46640 bool result;
46641 void *argp1 = 0 ;
46642 int res1 = 0 ;
46643 PyObject * obj0 = 0 ;
46644 PyObject * obj1 = 0 ;
46645 char * kwnames[] = {
46646 (char *) "self",(char *) "item", NULL
46647 };
46648
46649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46651 if (!SWIG_IsOK(res1)) {
46652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46653 }
46654 arg1 = reinterpret_cast< wxSizer * >(argp1);
46655 arg2 = obj1;
46656 {
46657 PyThreadState* __tstate = wxPyBeginAllowThreads();
46658 result = (bool)wxSizer_Remove(arg1,arg2);
46659 wxPyEndAllowThreads(__tstate);
46660 if (PyErr_Occurred()) SWIG_fail;
46661 }
46662 {
46663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46664 }
46665 return resultobj;
46666 fail:
46667 return NULL;
46668 }
46669
46670
46671 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46672 PyObject *resultobj = 0;
46673 wxSizer *arg1 = (wxSizer *) 0 ;
46674 PyObject *arg2 = (PyObject *) 0 ;
46675 bool result;
46676 void *argp1 = 0 ;
46677 int res1 = 0 ;
46678 PyObject * obj0 = 0 ;
46679 PyObject * obj1 = 0 ;
46680 char * kwnames[] = {
46681 (char *) "self",(char *) "item", NULL
46682 };
46683
46684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46686 if (!SWIG_IsOK(res1)) {
46687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46688 }
46689 arg1 = reinterpret_cast< wxSizer * >(argp1);
46690 arg2 = obj1;
46691 {
46692 PyThreadState* __tstate = wxPyBeginAllowThreads();
46693 result = (bool)wxSizer_Detach(arg1,arg2);
46694 wxPyEndAllowThreads(__tstate);
46695 if (PyErr_Occurred()) SWIG_fail;
46696 }
46697 {
46698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46699 }
46700 return resultobj;
46701 fail:
46702 return NULL;
46703 }
46704
46705
46706 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46707 PyObject *resultobj = 0;
46708 wxSizer *arg1 = (wxSizer *) 0 ;
46709 PyObject *arg2 = (PyObject *) 0 ;
46710 wxSizerItem *result = 0 ;
46711 void *argp1 = 0 ;
46712 int res1 = 0 ;
46713 PyObject * obj0 = 0 ;
46714 PyObject * obj1 = 0 ;
46715 char * kwnames[] = {
46716 (char *) "self",(char *) "item", NULL
46717 };
46718
46719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46721 if (!SWIG_IsOK(res1)) {
46722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46723 }
46724 arg1 = reinterpret_cast< wxSizer * >(argp1);
46725 arg2 = obj1;
46726 {
46727 PyThreadState* __tstate = wxPyBeginAllowThreads();
46728 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46729 wxPyEndAllowThreads(__tstate);
46730 if (PyErr_Occurred()) SWIG_fail;
46731 }
46732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46733 return resultobj;
46734 fail:
46735 return NULL;
46736 }
46737
46738
46739 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46740 PyObject *resultobj = 0;
46741 wxSizer *arg1 = (wxSizer *) 0 ;
46742 PyObject *arg2 = (PyObject *) 0 ;
46743 wxSize *arg3 = 0 ;
46744 void *argp1 = 0 ;
46745 int res1 = 0 ;
46746 wxSize temp3 ;
46747 PyObject * obj0 = 0 ;
46748 PyObject * obj1 = 0 ;
46749 PyObject * obj2 = 0 ;
46750 char * kwnames[] = {
46751 (char *) "self",(char *) "item",(char *) "size", NULL
46752 };
46753
46754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46756 if (!SWIG_IsOK(res1)) {
46757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46758 }
46759 arg1 = reinterpret_cast< wxSizer * >(argp1);
46760 arg2 = obj1;
46761 {
46762 arg3 = &temp3;
46763 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46764 }
46765 {
46766 PyThreadState* __tstate = wxPyBeginAllowThreads();
46767 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46768 wxPyEndAllowThreads(__tstate);
46769 if (PyErr_Occurred()) SWIG_fail;
46770 }
46771 resultobj = SWIG_Py_Void();
46772 return resultobj;
46773 fail:
46774 return NULL;
46775 }
46776
46777
46778 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46779 PyObject *resultobj = 0;
46780 wxSizer *arg1 = (wxSizer *) 0 ;
46781 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46782 wxSizerItem *result = 0 ;
46783 void *argp1 = 0 ;
46784 int res1 = 0 ;
46785 int res2 = 0 ;
46786 PyObject * obj0 = 0 ;
46787 PyObject * obj1 = 0 ;
46788 char * kwnames[] = {
46789 (char *) "self",(char *) "item", NULL
46790 };
46791
46792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46794 if (!SWIG_IsOK(res1)) {
46795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46796 }
46797 arg1 = reinterpret_cast< wxSizer * >(argp1);
46798 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46799 if (!SWIG_IsOK(res2)) {
46800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46801 }
46802 {
46803 PyThreadState* __tstate = wxPyBeginAllowThreads();
46804 result = (wxSizerItem *)(arg1)->Add(arg2);
46805 wxPyEndAllowThreads(__tstate);
46806 if (PyErr_Occurred()) SWIG_fail;
46807 }
46808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46809 return resultobj;
46810 fail:
46811 return NULL;
46812 }
46813
46814
46815 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46816 PyObject *resultobj = 0;
46817 wxSizer *arg1 = (wxSizer *) 0 ;
46818 size_t arg2 ;
46819 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46820 wxSizerItem *result = 0 ;
46821 void *argp1 = 0 ;
46822 int res1 = 0 ;
46823 size_t val2 ;
46824 int ecode2 = 0 ;
46825 int res3 = 0 ;
46826 PyObject * obj0 = 0 ;
46827 PyObject * obj1 = 0 ;
46828 PyObject * obj2 = 0 ;
46829 char * kwnames[] = {
46830 (char *) "self",(char *) "index",(char *) "item", NULL
46831 };
46832
46833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46835 if (!SWIG_IsOK(res1)) {
46836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46837 }
46838 arg1 = reinterpret_cast< wxSizer * >(argp1);
46839 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46840 if (!SWIG_IsOK(ecode2)) {
46841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46842 }
46843 arg2 = static_cast< size_t >(val2);
46844 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46845 if (!SWIG_IsOK(res3)) {
46846 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46847 }
46848 {
46849 PyThreadState* __tstate = wxPyBeginAllowThreads();
46850 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46851 wxPyEndAllowThreads(__tstate);
46852 if (PyErr_Occurred()) SWIG_fail;
46853 }
46854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46855 return resultobj;
46856 fail:
46857 return NULL;
46858 }
46859
46860
46861 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46862 PyObject *resultobj = 0;
46863 wxSizer *arg1 = (wxSizer *) 0 ;
46864 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46865 wxSizerItem *result = 0 ;
46866 void *argp1 = 0 ;
46867 int res1 = 0 ;
46868 int res2 = 0 ;
46869 PyObject * obj0 = 0 ;
46870 PyObject * obj1 = 0 ;
46871 char * kwnames[] = {
46872 (char *) "self",(char *) "item", NULL
46873 };
46874
46875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46877 if (!SWIG_IsOK(res1)) {
46878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46879 }
46880 arg1 = reinterpret_cast< wxSizer * >(argp1);
46881 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46882 if (!SWIG_IsOK(res2)) {
46883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46884 }
46885 {
46886 PyThreadState* __tstate = wxPyBeginAllowThreads();
46887 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46888 wxPyEndAllowThreads(__tstate);
46889 if (PyErr_Occurred()) SWIG_fail;
46890 }
46891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46892 return resultobj;
46893 fail:
46894 return NULL;
46895 }
46896
46897
46898 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46899 PyObject *resultobj = 0;
46900 wxSizer *arg1 = (wxSizer *) 0 ;
46901 int arg2 ;
46902 int arg3 ;
46903 int arg4 ;
46904 int arg5 ;
46905 void *argp1 = 0 ;
46906 int res1 = 0 ;
46907 int val2 ;
46908 int ecode2 = 0 ;
46909 int val3 ;
46910 int ecode3 = 0 ;
46911 int val4 ;
46912 int ecode4 = 0 ;
46913 int val5 ;
46914 int ecode5 = 0 ;
46915 PyObject * obj0 = 0 ;
46916 PyObject * obj1 = 0 ;
46917 PyObject * obj2 = 0 ;
46918 PyObject * obj3 = 0 ;
46919 PyObject * obj4 = 0 ;
46920 char * kwnames[] = {
46921 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46922 };
46923
46924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46926 if (!SWIG_IsOK(res1)) {
46927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46928 }
46929 arg1 = reinterpret_cast< wxSizer * >(argp1);
46930 ecode2 = SWIG_AsVal_int(obj1, &val2);
46931 if (!SWIG_IsOK(ecode2)) {
46932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46933 }
46934 arg2 = static_cast< int >(val2);
46935 ecode3 = SWIG_AsVal_int(obj2, &val3);
46936 if (!SWIG_IsOK(ecode3)) {
46937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46938 }
46939 arg3 = static_cast< int >(val3);
46940 ecode4 = SWIG_AsVal_int(obj3, &val4);
46941 if (!SWIG_IsOK(ecode4)) {
46942 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46943 }
46944 arg4 = static_cast< int >(val4);
46945 ecode5 = SWIG_AsVal_int(obj4, &val5);
46946 if (!SWIG_IsOK(ecode5)) {
46947 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46948 }
46949 arg5 = static_cast< int >(val5);
46950 {
46951 PyThreadState* __tstate = wxPyBeginAllowThreads();
46952 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46953 wxPyEndAllowThreads(__tstate);
46954 if (PyErr_Occurred()) SWIG_fail;
46955 }
46956 resultobj = SWIG_Py_Void();
46957 return resultobj;
46958 fail:
46959 return NULL;
46960 }
46961
46962
46963 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46964 PyObject *resultobj = 0;
46965 wxSizer *arg1 = (wxSizer *) 0 ;
46966 wxSize *arg2 = 0 ;
46967 void *argp1 = 0 ;
46968 int res1 = 0 ;
46969 wxSize temp2 ;
46970 PyObject * obj0 = 0 ;
46971 PyObject * obj1 = 0 ;
46972 char * kwnames[] = {
46973 (char *) "self",(char *) "size", NULL
46974 };
46975
46976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46978 if (!SWIG_IsOK(res1)) {
46979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46980 }
46981 arg1 = reinterpret_cast< wxSizer * >(argp1);
46982 {
46983 arg2 = &temp2;
46984 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46985 }
46986 {
46987 PyThreadState* __tstate = wxPyBeginAllowThreads();
46988 (arg1)->SetMinSize((wxSize const &)*arg2);
46989 wxPyEndAllowThreads(__tstate);
46990 if (PyErr_Occurred()) SWIG_fail;
46991 }
46992 resultobj = SWIG_Py_Void();
46993 return resultobj;
46994 fail:
46995 return NULL;
46996 }
46997
46998
46999 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47000 PyObject *resultobj = 0;
47001 wxSizer *arg1 = (wxSizer *) 0 ;
47002 wxSize result;
47003 void *argp1 = 0 ;
47004 int res1 = 0 ;
47005 PyObject *swig_obj[1] ;
47006
47007 if (!args) SWIG_fail;
47008 swig_obj[0] = args;
47009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47010 if (!SWIG_IsOK(res1)) {
47011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47012 }
47013 arg1 = reinterpret_cast< wxSizer * >(argp1);
47014 {
47015 PyThreadState* __tstate = wxPyBeginAllowThreads();
47016 result = (arg1)->GetSize();
47017 wxPyEndAllowThreads(__tstate);
47018 if (PyErr_Occurred()) SWIG_fail;
47019 }
47020 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47021 return resultobj;
47022 fail:
47023 return NULL;
47024 }
47025
47026
47027 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47028 PyObject *resultobj = 0;
47029 wxSizer *arg1 = (wxSizer *) 0 ;
47030 wxPoint result;
47031 void *argp1 = 0 ;
47032 int res1 = 0 ;
47033 PyObject *swig_obj[1] ;
47034
47035 if (!args) SWIG_fail;
47036 swig_obj[0] = args;
47037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47038 if (!SWIG_IsOK(res1)) {
47039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47040 }
47041 arg1 = reinterpret_cast< wxSizer * >(argp1);
47042 {
47043 PyThreadState* __tstate = wxPyBeginAllowThreads();
47044 result = (arg1)->GetPosition();
47045 wxPyEndAllowThreads(__tstate);
47046 if (PyErr_Occurred()) SWIG_fail;
47047 }
47048 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47049 return resultobj;
47050 fail:
47051 return NULL;
47052 }
47053
47054
47055 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47056 PyObject *resultobj = 0;
47057 wxSizer *arg1 = (wxSizer *) 0 ;
47058 wxSize result;
47059 void *argp1 = 0 ;
47060 int res1 = 0 ;
47061 PyObject *swig_obj[1] ;
47062
47063 if (!args) SWIG_fail;
47064 swig_obj[0] = args;
47065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47066 if (!SWIG_IsOK(res1)) {
47067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47068 }
47069 arg1 = reinterpret_cast< wxSizer * >(argp1);
47070 {
47071 PyThreadState* __tstate = wxPyBeginAllowThreads();
47072 result = (arg1)->GetMinSize();
47073 wxPyEndAllowThreads(__tstate);
47074 if (PyErr_Occurred()) SWIG_fail;
47075 }
47076 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47077 return resultobj;
47078 fail:
47079 return NULL;
47080 }
47081
47082
47083 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47084 PyObject *resultobj = 0;
47085 wxSizer *arg1 = (wxSizer *) 0 ;
47086 void *argp1 = 0 ;
47087 int res1 = 0 ;
47088 PyObject *swig_obj[1] ;
47089
47090 if (!args) SWIG_fail;
47091 swig_obj[0] = args;
47092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47093 if (!SWIG_IsOK(res1)) {
47094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47095 }
47096 arg1 = reinterpret_cast< wxSizer * >(argp1);
47097 {
47098 PyThreadState* __tstate = wxPyBeginAllowThreads();
47099 (arg1)->RecalcSizes();
47100 wxPyEndAllowThreads(__tstate);
47101 if (PyErr_Occurred()) SWIG_fail;
47102 }
47103 resultobj = SWIG_Py_Void();
47104 return resultobj;
47105 fail:
47106 return NULL;
47107 }
47108
47109
47110 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47111 PyObject *resultobj = 0;
47112 wxSizer *arg1 = (wxSizer *) 0 ;
47113 wxSize result;
47114 void *argp1 = 0 ;
47115 int res1 = 0 ;
47116 PyObject *swig_obj[1] ;
47117
47118 if (!args) SWIG_fail;
47119 swig_obj[0] = args;
47120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47121 if (!SWIG_IsOK(res1)) {
47122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47123 }
47124 arg1 = reinterpret_cast< wxSizer * >(argp1);
47125 {
47126 PyThreadState* __tstate = wxPyBeginAllowThreads();
47127 result = (arg1)->CalcMin();
47128 wxPyEndAllowThreads(__tstate);
47129 if (PyErr_Occurred()) SWIG_fail;
47130 }
47131 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47132 return resultobj;
47133 fail:
47134 return NULL;
47135 }
47136
47137
47138 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47139 PyObject *resultobj = 0;
47140 wxSizer *arg1 = (wxSizer *) 0 ;
47141 void *argp1 = 0 ;
47142 int res1 = 0 ;
47143 PyObject *swig_obj[1] ;
47144
47145 if (!args) SWIG_fail;
47146 swig_obj[0] = args;
47147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47148 if (!SWIG_IsOK(res1)) {
47149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47150 }
47151 arg1 = reinterpret_cast< wxSizer * >(argp1);
47152 {
47153 PyThreadState* __tstate = wxPyBeginAllowThreads();
47154 (arg1)->Layout();
47155 wxPyEndAllowThreads(__tstate);
47156 if (PyErr_Occurred()) SWIG_fail;
47157 }
47158 resultobj = SWIG_Py_Void();
47159 return resultobj;
47160 fail:
47161 return NULL;
47162 }
47163
47164
47165 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47166 PyObject *resultobj = 0;
47167 wxSizer *arg1 = (wxSizer *) 0 ;
47168 wxWindow *arg2 = (wxWindow *) 0 ;
47169 wxSize result;
47170 void *argp1 = 0 ;
47171 int res1 = 0 ;
47172 void *argp2 = 0 ;
47173 int res2 = 0 ;
47174 PyObject * obj0 = 0 ;
47175 PyObject * obj1 = 0 ;
47176 char * kwnames[] = {
47177 (char *) "self",(char *) "window", NULL
47178 };
47179
47180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47182 if (!SWIG_IsOK(res1)) {
47183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47184 }
47185 arg1 = reinterpret_cast< wxSizer * >(argp1);
47186 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47187 if (!SWIG_IsOK(res2)) {
47188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47189 }
47190 arg2 = reinterpret_cast< wxWindow * >(argp2);
47191 {
47192 PyThreadState* __tstate = wxPyBeginAllowThreads();
47193 result = (arg1)->Fit(arg2);
47194 wxPyEndAllowThreads(__tstate);
47195 if (PyErr_Occurred()) SWIG_fail;
47196 }
47197 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47198 return resultobj;
47199 fail:
47200 return NULL;
47201 }
47202
47203
47204 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47205 PyObject *resultobj = 0;
47206 wxSizer *arg1 = (wxSizer *) 0 ;
47207 wxWindow *arg2 = (wxWindow *) 0 ;
47208 void *argp1 = 0 ;
47209 int res1 = 0 ;
47210 void *argp2 = 0 ;
47211 int res2 = 0 ;
47212 PyObject * obj0 = 0 ;
47213 PyObject * obj1 = 0 ;
47214 char * kwnames[] = {
47215 (char *) "self",(char *) "window", NULL
47216 };
47217
47218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47220 if (!SWIG_IsOK(res1)) {
47221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47222 }
47223 arg1 = reinterpret_cast< wxSizer * >(argp1);
47224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47225 if (!SWIG_IsOK(res2)) {
47226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47227 }
47228 arg2 = reinterpret_cast< wxWindow * >(argp2);
47229 {
47230 PyThreadState* __tstate = wxPyBeginAllowThreads();
47231 (arg1)->FitInside(arg2);
47232 wxPyEndAllowThreads(__tstate);
47233 if (PyErr_Occurred()) SWIG_fail;
47234 }
47235 resultobj = SWIG_Py_Void();
47236 return resultobj;
47237 fail:
47238 return NULL;
47239 }
47240
47241
47242 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47243 PyObject *resultobj = 0;
47244 wxSizer *arg1 = (wxSizer *) 0 ;
47245 wxWindow *arg2 = (wxWindow *) 0 ;
47246 void *argp1 = 0 ;
47247 int res1 = 0 ;
47248 void *argp2 = 0 ;
47249 int res2 = 0 ;
47250 PyObject * obj0 = 0 ;
47251 PyObject * obj1 = 0 ;
47252 char * kwnames[] = {
47253 (char *) "self",(char *) "window", NULL
47254 };
47255
47256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47258 if (!SWIG_IsOK(res1)) {
47259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47260 }
47261 arg1 = reinterpret_cast< wxSizer * >(argp1);
47262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47263 if (!SWIG_IsOK(res2)) {
47264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47265 }
47266 arg2 = reinterpret_cast< wxWindow * >(argp2);
47267 {
47268 PyThreadState* __tstate = wxPyBeginAllowThreads();
47269 (arg1)->SetSizeHints(arg2);
47270 wxPyEndAllowThreads(__tstate);
47271 if (PyErr_Occurred()) SWIG_fail;
47272 }
47273 resultobj = SWIG_Py_Void();
47274 return resultobj;
47275 fail:
47276 return NULL;
47277 }
47278
47279
47280 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47281 PyObject *resultobj = 0;
47282 wxSizer *arg1 = (wxSizer *) 0 ;
47283 wxWindow *arg2 = (wxWindow *) 0 ;
47284 void *argp1 = 0 ;
47285 int res1 = 0 ;
47286 void *argp2 = 0 ;
47287 int res2 = 0 ;
47288 PyObject * obj0 = 0 ;
47289 PyObject * obj1 = 0 ;
47290 char * kwnames[] = {
47291 (char *) "self",(char *) "window", NULL
47292 };
47293
47294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47296 if (!SWIG_IsOK(res1)) {
47297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47298 }
47299 arg1 = reinterpret_cast< wxSizer * >(argp1);
47300 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47301 if (!SWIG_IsOK(res2)) {
47302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47303 }
47304 arg2 = reinterpret_cast< wxWindow * >(argp2);
47305 {
47306 PyThreadState* __tstate = wxPyBeginAllowThreads();
47307 (arg1)->SetVirtualSizeHints(arg2);
47308 wxPyEndAllowThreads(__tstate);
47309 if (PyErr_Occurred()) SWIG_fail;
47310 }
47311 resultobj = SWIG_Py_Void();
47312 return resultobj;
47313 fail:
47314 return NULL;
47315 }
47316
47317
47318 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47319 PyObject *resultobj = 0;
47320 wxSizer *arg1 = (wxSizer *) 0 ;
47321 bool arg2 = (bool) false ;
47322 void *argp1 = 0 ;
47323 int res1 = 0 ;
47324 bool val2 ;
47325 int ecode2 = 0 ;
47326 PyObject * obj0 = 0 ;
47327 PyObject * obj1 = 0 ;
47328 char * kwnames[] = {
47329 (char *) "self",(char *) "deleteWindows", NULL
47330 };
47331
47332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47334 if (!SWIG_IsOK(res1)) {
47335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47336 }
47337 arg1 = reinterpret_cast< wxSizer * >(argp1);
47338 if (obj1) {
47339 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47340 if (!SWIG_IsOK(ecode2)) {
47341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47342 }
47343 arg2 = static_cast< bool >(val2);
47344 }
47345 {
47346 PyThreadState* __tstate = wxPyBeginAllowThreads();
47347 (arg1)->Clear(arg2);
47348 wxPyEndAllowThreads(__tstate);
47349 if (PyErr_Occurred()) SWIG_fail;
47350 }
47351 resultobj = SWIG_Py_Void();
47352 return resultobj;
47353 fail:
47354 return NULL;
47355 }
47356
47357
47358 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47359 PyObject *resultobj = 0;
47360 wxSizer *arg1 = (wxSizer *) 0 ;
47361 void *argp1 = 0 ;
47362 int res1 = 0 ;
47363 PyObject *swig_obj[1] ;
47364
47365 if (!args) SWIG_fail;
47366 swig_obj[0] = args;
47367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47368 if (!SWIG_IsOK(res1)) {
47369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47370 }
47371 arg1 = reinterpret_cast< wxSizer * >(argp1);
47372 {
47373 PyThreadState* __tstate = wxPyBeginAllowThreads();
47374 (arg1)->DeleteWindows();
47375 wxPyEndAllowThreads(__tstate);
47376 if (PyErr_Occurred()) SWIG_fail;
47377 }
47378 resultobj = SWIG_Py_Void();
47379 return resultobj;
47380 fail:
47381 return NULL;
47382 }
47383
47384
47385 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47386 PyObject *resultobj = 0;
47387 wxSizer *arg1 = (wxSizer *) 0 ;
47388 PyObject *result = 0 ;
47389 void *argp1 = 0 ;
47390 int res1 = 0 ;
47391 PyObject *swig_obj[1] ;
47392
47393 if (!args) SWIG_fail;
47394 swig_obj[0] = args;
47395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47396 if (!SWIG_IsOK(res1)) {
47397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47398 }
47399 arg1 = reinterpret_cast< wxSizer * >(argp1);
47400 {
47401 PyThreadState* __tstate = wxPyBeginAllowThreads();
47402 result = (PyObject *)wxSizer_GetChildren(arg1);
47403 wxPyEndAllowThreads(__tstate);
47404 if (PyErr_Occurred()) SWIG_fail;
47405 }
47406 resultobj = result;
47407 return resultobj;
47408 fail:
47409 return NULL;
47410 }
47411
47412
47413 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47414 PyObject *resultobj = 0;
47415 wxSizer *arg1 = (wxSizer *) 0 ;
47416 PyObject *arg2 = (PyObject *) 0 ;
47417 bool arg3 = (bool) true ;
47418 bool arg4 = (bool) false ;
47419 bool result;
47420 void *argp1 = 0 ;
47421 int res1 = 0 ;
47422 bool val3 ;
47423 int ecode3 = 0 ;
47424 bool val4 ;
47425 int ecode4 = 0 ;
47426 PyObject * obj0 = 0 ;
47427 PyObject * obj1 = 0 ;
47428 PyObject * obj2 = 0 ;
47429 PyObject * obj3 = 0 ;
47430 char * kwnames[] = {
47431 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47432 };
47433
47434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47436 if (!SWIG_IsOK(res1)) {
47437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47438 }
47439 arg1 = reinterpret_cast< wxSizer * >(argp1);
47440 arg2 = obj1;
47441 if (obj2) {
47442 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47443 if (!SWIG_IsOK(ecode3)) {
47444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47445 }
47446 arg3 = static_cast< bool >(val3);
47447 }
47448 if (obj3) {
47449 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47450 if (!SWIG_IsOK(ecode4)) {
47451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47452 }
47453 arg4 = static_cast< bool >(val4);
47454 }
47455 {
47456 PyThreadState* __tstate = wxPyBeginAllowThreads();
47457 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47458 wxPyEndAllowThreads(__tstate);
47459 if (PyErr_Occurred()) SWIG_fail;
47460 }
47461 {
47462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47463 }
47464 return resultobj;
47465 fail:
47466 return NULL;
47467 }
47468
47469
47470 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47471 PyObject *resultobj = 0;
47472 wxSizer *arg1 = (wxSizer *) 0 ;
47473 PyObject *arg2 = (PyObject *) 0 ;
47474 bool result;
47475 void *argp1 = 0 ;
47476 int res1 = 0 ;
47477 PyObject * obj0 = 0 ;
47478 PyObject * obj1 = 0 ;
47479 char * kwnames[] = {
47480 (char *) "self",(char *) "item", NULL
47481 };
47482
47483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47485 if (!SWIG_IsOK(res1)) {
47486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47487 }
47488 arg1 = reinterpret_cast< wxSizer * >(argp1);
47489 arg2 = obj1;
47490 {
47491 PyThreadState* __tstate = wxPyBeginAllowThreads();
47492 result = (bool)wxSizer_IsShown(arg1,arg2);
47493 wxPyEndAllowThreads(__tstate);
47494 if (PyErr_Occurred()) SWIG_fail;
47495 }
47496 {
47497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47498 }
47499 return resultobj;
47500 fail:
47501 return NULL;
47502 }
47503
47504
47505 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47506 PyObject *resultobj = 0;
47507 wxSizer *arg1 = (wxSizer *) 0 ;
47508 bool arg2 ;
47509 void *argp1 = 0 ;
47510 int res1 = 0 ;
47511 bool val2 ;
47512 int ecode2 = 0 ;
47513 PyObject * obj0 = 0 ;
47514 PyObject * obj1 = 0 ;
47515 char * kwnames[] = {
47516 (char *) "self",(char *) "show", NULL
47517 };
47518
47519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47521 if (!SWIG_IsOK(res1)) {
47522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47523 }
47524 arg1 = reinterpret_cast< wxSizer * >(argp1);
47525 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47526 if (!SWIG_IsOK(ecode2)) {
47527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47528 }
47529 arg2 = static_cast< bool >(val2);
47530 {
47531 PyThreadState* __tstate = wxPyBeginAllowThreads();
47532 (arg1)->ShowItems(arg2);
47533 wxPyEndAllowThreads(__tstate);
47534 if (PyErr_Occurred()) SWIG_fail;
47535 }
47536 resultobj = SWIG_Py_Void();
47537 return resultobj;
47538 fail:
47539 return NULL;
47540 }
47541
47542
47543 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47544 PyObject *obj;
47545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47546 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47547 return SWIG_Py_Void();
47548 }
47549
47550 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47551 PyObject *resultobj = 0;
47552 wxPySizer *result = 0 ;
47553
47554 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47555 {
47556 PyThreadState* __tstate = wxPyBeginAllowThreads();
47557 result = (wxPySizer *)new wxPySizer();
47558 wxPyEndAllowThreads(__tstate);
47559 if (PyErr_Occurred()) SWIG_fail;
47560 }
47561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47562 return resultobj;
47563 fail:
47564 return NULL;
47565 }
47566
47567
47568 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47569 PyObject *resultobj = 0;
47570 wxPySizer *arg1 = (wxPySizer *) 0 ;
47571 PyObject *arg2 = (PyObject *) 0 ;
47572 PyObject *arg3 = (PyObject *) 0 ;
47573 void *argp1 = 0 ;
47574 int res1 = 0 ;
47575 PyObject * obj0 = 0 ;
47576 PyObject * obj1 = 0 ;
47577 PyObject * obj2 = 0 ;
47578 char * kwnames[] = {
47579 (char *) "self",(char *) "self",(char *) "_class", NULL
47580 };
47581
47582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47584 if (!SWIG_IsOK(res1)) {
47585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47586 }
47587 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47588 arg2 = obj1;
47589 arg3 = obj2;
47590 {
47591 PyThreadState* __tstate = wxPyBeginAllowThreads();
47592 (arg1)->_setCallbackInfo(arg2,arg3);
47593 wxPyEndAllowThreads(__tstate);
47594 if (PyErr_Occurred()) SWIG_fail;
47595 }
47596 resultobj = SWIG_Py_Void();
47597 return resultobj;
47598 fail:
47599 return NULL;
47600 }
47601
47602
47603 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47604 PyObject *obj;
47605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47606 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47607 return SWIG_Py_Void();
47608 }
47609
47610 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47611 return SWIG_Python_InitShadowInstance(args);
47612 }
47613
47614 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47615 PyObject *resultobj = 0;
47616 int arg1 = (int) wxHORIZONTAL ;
47617 wxBoxSizer *result = 0 ;
47618 int val1 ;
47619 int ecode1 = 0 ;
47620 PyObject * obj0 = 0 ;
47621 char * kwnames[] = {
47622 (char *) "orient", NULL
47623 };
47624
47625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47626 if (obj0) {
47627 ecode1 = SWIG_AsVal_int(obj0, &val1);
47628 if (!SWIG_IsOK(ecode1)) {
47629 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47630 }
47631 arg1 = static_cast< int >(val1);
47632 }
47633 {
47634 PyThreadState* __tstate = wxPyBeginAllowThreads();
47635 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47636 wxPyEndAllowThreads(__tstate);
47637 if (PyErr_Occurred()) SWIG_fail;
47638 }
47639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47640 return resultobj;
47641 fail:
47642 return NULL;
47643 }
47644
47645
47646 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47647 PyObject *resultobj = 0;
47648 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47649 int result;
47650 void *argp1 = 0 ;
47651 int res1 = 0 ;
47652 PyObject *swig_obj[1] ;
47653
47654 if (!args) SWIG_fail;
47655 swig_obj[0] = args;
47656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47657 if (!SWIG_IsOK(res1)) {
47658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47659 }
47660 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47661 {
47662 PyThreadState* __tstate = wxPyBeginAllowThreads();
47663 result = (int)(arg1)->GetOrientation();
47664 wxPyEndAllowThreads(__tstate);
47665 if (PyErr_Occurred()) SWIG_fail;
47666 }
47667 resultobj = SWIG_From_int(static_cast< int >(result));
47668 return resultobj;
47669 fail:
47670 return NULL;
47671 }
47672
47673
47674 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47675 PyObject *resultobj = 0;
47676 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47677 int arg2 ;
47678 void *argp1 = 0 ;
47679 int res1 = 0 ;
47680 int val2 ;
47681 int ecode2 = 0 ;
47682 PyObject * obj0 = 0 ;
47683 PyObject * obj1 = 0 ;
47684 char * kwnames[] = {
47685 (char *) "self",(char *) "orient", NULL
47686 };
47687
47688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47690 if (!SWIG_IsOK(res1)) {
47691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47692 }
47693 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47694 ecode2 = SWIG_AsVal_int(obj1, &val2);
47695 if (!SWIG_IsOK(ecode2)) {
47696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47697 }
47698 arg2 = static_cast< int >(val2);
47699 {
47700 PyThreadState* __tstate = wxPyBeginAllowThreads();
47701 (arg1)->SetOrientation(arg2);
47702 wxPyEndAllowThreads(__tstate);
47703 if (PyErr_Occurred()) SWIG_fail;
47704 }
47705 resultobj = SWIG_Py_Void();
47706 return resultobj;
47707 fail:
47708 return NULL;
47709 }
47710
47711
47712 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47713 PyObject *obj;
47714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47715 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47716 return SWIG_Py_Void();
47717 }
47718
47719 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47720 return SWIG_Python_InitShadowInstance(args);
47721 }
47722
47723 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47724 PyObject *resultobj = 0;
47725 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47726 int arg2 = (int) wxHORIZONTAL ;
47727 wxStaticBoxSizer *result = 0 ;
47728 void *argp1 = 0 ;
47729 int res1 = 0 ;
47730 int val2 ;
47731 int ecode2 = 0 ;
47732 PyObject * obj0 = 0 ;
47733 PyObject * obj1 = 0 ;
47734 char * kwnames[] = {
47735 (char *) "box",(char *) "orient", NULL
47736 };
47737
47738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47740 if (!SWIG_IsOK(res1)) {
47741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47742 }
47743 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47744 if (obj1) {
47745 ecode2 = SWIG_AsVal_int(obj1, &val2);
47746 if (!SWIG_IsOK(ecode2)) {
47747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47748 }
47749 arg2 = static_cast< int >(val2);
47750 }
47751 {
47752 PyThreadState* __tstate = wxPyBeginAllowThreads();
47753 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47754 wxPyEndAllowThreads(__tstate);
47755 if (PyErr_Occurred()) SWIG_fail;
47756 }
47757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47758 return resultobj;
47759 fail:
47760 return NULL;
47761 }
47762
47763
47764 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47765 PyObject *resultobj = 0;
47766 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47767 wxStaticBox *result = 0 ;
47768 void *argp1 = 0 ;
47769 int res1 = 0 ;
47770 PyObject *swig_obj[1] ;
47771
47772 if (!args) SWIG_fail;
47773 swig_obj[0] = args;
47774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47775 if (!SWIG_IsOK(res1)) {
47776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47777 }
47778 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47779 {
47780 PyThreadState* __tstate = wxPyBeginAllowThreads();
47781 result = (wxStaticBox *)(arg1)->GetStaticBox();
47782 wxPyEndAllowThreads(__tstate);
47783 if (PyErr_Occurred()) SWIG_fail;
47784 }
47785 {
47786 resultobj = wxPyMake_wxObject(result, (bool)0);
47787 }
47788 return resultobj;
47789 fail:
47790 return NULL;
47791 }
47792
47793
47794 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47795 PyObject *obj;
47796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47797 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47798 return SWIG_Py_Void();
47799 }
47800
47801 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47802 return SWIG_Python_InitShadowInstance(args);
47803 }
47804
47805 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47806 PyObject *resultobj = 0;
47807 int arg1 = (int) 1 ;
47808 int arg2 = (int) 0 ;
47809 int arg3 = (int) 0 ;
47810 int arg4 = (int) 0 ;
47811 wxGridSizer *result = 0 ;
47812 int val1 ;
47813 int ecode1 = 0 ;
47814 int val2 ;
47815 int ecode2 = 0 ;
47816 int val3 ;
47817 int ecode3 = 0 ;
47818 int val4 ;
47819 int ecode4 = 0 ;
47820 PyObject * obj0 = 0 ;
47821 PyObject * obj1 = 0 ;
47822 PyObject * obj2 = 0 ;
47823 PyObject * obj3 = 0 ;
47824 char * kwnames[] = {
47825 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47826 };
47827
47828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47829 if (obj0) {
47830 ecode1 = SWIG_AsVal_int(obj0, &val1);
47831 if (!SWIG_IsOK(ecode1)) {
47832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47833 }
47834 arg1 = static_cast< int >(val1);
47835 }
47836 if (obj1) {
47837 ecode2 = SWIG_AsVal_int(obj1, &val2);
47838 if (!SWIG_IsOK(ecode2)) {
47839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47840 }
47841 arg2 = static_cast< int >(val2);
47842 }
47843 if (obj2) {
47844 ecode3 = SWIG_AsVal_int(obj2, &val3);
47845 if (!SWIG_IsOK(ecode3)) {
47846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47847 }
47848 arg3 = static_cast< int >(val3);
47849 }
47850 if (obj3) {
47851 ecode4 = SWIG_AsVal_int(obj3, &val4);
47852 if (!SWIG_IsOK(ecode4)) {
47853 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47854 }
47855 arg4 = static_cast< int >(val4);
47856 }
47857 {
47858 PyThreadState* __tstate = wxPyBeginAllowThreads();
47859 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47860 wxPyEndAllowThreads(__tstate);
47861 if (PyErr_Occurred()) SWIG_fail;
47862 }
47863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47864 return resultobj;
47865 fail:
47866 return NULL;
47867 }
47868
47869
47870 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47871 PyObject *resultobj = 0;
47872 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47873 int arg2 ;
47874 void *argp1 = 0 ;
47875 int res1 = 0 ;
47876 int val2 ;
47877 int ecode2 = 0 ;
47878 PyObject * obj0 = 0 ;
47879 PyObject * obj1 = 0 ;
47880 char * kwnames[] = {
47881 (char *) "self",(char *) "cols", NULL
47882 };
47883
47884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47886 if (!SWIG_IsOK(res1)) {
47887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47888 }
47889 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47890 ecode2 = SWIG_AsVal_int(obj1, &val2);
47891 if (!SWIG_IsOK(ecode2)) {
47892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47893 }
47894 arg2 = static_cast< int >(val2);
47895 {
47896 PyThreadState* __tstate = wxPyBeginAllowThreads();
47897 (arg1)->SetCols(arg2);
47898 wxPyEndAllowThreads(__tstate);
47899 if (PyErr_Occurred()) SWIG_fail;
47900 }
47901 resultobj = SWIG_Py_Void();
47902 return resultobj;
47903 fail:
47904 return NULL;
47905 }
47906
47907
47908 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47909 PyObject *resultobj = 0;
47910 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47911 int arg2 ;
47912 void *argp1 = 0 ;
47913 int res1 = 0 ;
47914 int val2 ;
47915 int ecode2 = 0 ;
47916 PyObject * obj0 = 0 ;
47917 PyObject * obj1 = 0 ;
47918 char * kwnames[] = {
47919 (char *) "self",(char *) "rows", NULL
47920 };
47921
47922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47924 if (!SWIG_IsOK(res1)) {
47925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47926 }
47927 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47928 ecode2 = SWIG_AsVal_int(obj1, &val2);
47929 if (!SWIG_IsOK(ecode2)) {
47930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47931 }
47932 arg2 = static_cast< int >(val2);
47933 {
47934 PyThreadState* __tstate = wxPyBeginAllowThreads();
47935 (arg1)->SetRows(arg2);
47936 wxPyEndAllowThreads(__tstate);
47937 if (PyErr_Occurred()) SWIG_fail;
47938 }
47939 resultobj = SWIG_Py_Void();
47940 return resultobj;
47941 fail:
47942 return NULL;
47943 }
47944
47945
47946 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47947 PyObject *resultobj = 0;
47948 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47949 int arg2 ;
47950 void *argp1 = 0 ;
47951 int res1 = 0 ;
47952 int val2 ;
47953 int ecode2 = 0 ;
47954 PyObject * obj0 = 0 ;
47955 PyObject * obj1 = 0 ;
47956 char * kwnames[] = {
47957 (char *) "self",(char *) "gap", NULL
47958 };
47959
47960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47962 if (!SWIG_IsOK(res1)) {
47963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47964 }
47965 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47966 ecode2 = SWIG_AsVal_int(obj1, &val2);
47967 if (!SWIG_IsOK(ecode2)) {
47968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47969 }
47970 arg2 = static_cast< int >(val2);
47971 {
47972 PyThreadState* __tstate = wxPyBeginAllowThreads();
47973 (arg1)->SetVGap(arg2);
47974 wxPyEndAllowThreads(__tstate);
47975 if (PyErr_Occurred()) SWIG_fail;
47976 }
47977 resultobj = SWIG_Py_Void();
47978 return resultobj;
47979 fail:
47980 return NULL;
47981 }
47982
47983
47984 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47985 PyObject *resultobj = 0;
47986 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47987 int arg2 ;
47988 void *argp1 = 0 ;
47989 int res1 = 0 ;
47990 int val2 ;
47991 int ecode2 = 0 ;
47992 PyObject * obj0 = 0 ;
47993 PyObject * obj1 = 0 ;
47994 char * kwnames[] = {
47995 (char *) "self",(char *) "gap", NULL
47996 };
47997
47998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48000 if (!SWIG_IsOK(res1)) {
48001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48002 }
48003 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48004 ecode2 = SWIG_AsVal_int(obj1, &val2);
48005 if (!SWIG_IsOK(ecode2)) {
48006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48007 }
48008 arg2 = static_cast< int >(val2);
48009 {
48010 PyThreadState* __tstate = wxPyBeginAllowThreads();
48011 (arg1)->SetHGap(arg2);
48012 wxPyEndAllowThreads(__tstate);
48013 if (PyErr_Occurred()) SWIG_fail;
48014 }
48015 resultobj = SWIG_Py_Void();
48016 return resultobj;
48017 fail:
48018 return NULL;
48019 }
48020
48021
48022 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48023 PyObject *resultobj = 0;
48024 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48025 int result;
48026 void *argp1 = 0 ;
48027 int res1 = 0 ;
48028 PyObject *swig_obj[1] ;
48029
48030 if (!args) SWIG_fail;
48031 swig_obj[0] = args;
48032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48033 if (!SWIG_IsOK(res1)) {
48034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48035 }
48036 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48037 {
48038 PyThreadState* __tstate = wxPyBeginAllowThreads();
48039 result = (int)(arg1)->GetCols();
48040 wxPyEndAllowThreads(__tstate);
48041 if (PyErr_Occurred()) SWIG_fail;
48042 }
48043 resultobj = SWIG_From_int(static_cast< int >(result));
48044 return resultobj;
48045 fail:
48046 return NULL;
48047 }
48048
48049
48050 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48051 PyObject *resultobj = 0;
48052 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48053 int result;
48054 void *argp1 = 0 ;
48055 int res1 = 0 ;
48056 PyObject *swig_obj[1] ;
48057
48058 if (!args) SWIG_fail;
48059 swig_obj[0] = args;
48060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48061 if (!SWIG_IsOK(res1)) {
48062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48063 }
48064 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48065 {
48066 PyThreadState* __tstate = wxPyBeginAllowThreads();
48067 result = (int)(arg1)->GetRows();
48068 wxPyEndAllowThreads(__tstate);
48069 if (PyErr_Occurred()) SWIG_fail;
48070 }
48071 resultobj = SWIG_From_int(static_cast< int >(result));
48072 return resultobj;
48073 fail:
48074 return NULL;
48075 }
48076
48077
48078 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48079 PyObject *resultobj = 0;
48080 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48081 int result;
48082 void *argp1 = 0 ;
48083 int res1 = 0 ;
48084 PyObject *swig_obj[1] ;
48085
48086 if (!args) SWIG_fail;
48087 swig_obj[0] = args;
48088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48089 if (!SWIG_IsOK(res1)) {
48090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48091 }
48092 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48093 {
48094 PyThreadState* __tstate = wxPyBeginAllowThreads();
48095 result = (int)(arg1)->GetVGap();
48096 wxPyEndAllowThreads(__tstate);
48097 if (PyErr_Occurred()) SWIG_fail;
48098 }
48099 resultobj = SWIG_From_int(static_cast< int >(result));
48100 return resultobj;
48101 fail:
48102 return NULL;
48103 }
48104
48105
48106 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48107 PyObject *resultobj = 0;
48108 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48109 int result;
48110 void *argp1 = 0 ;
48111 int res1 = 0 ;
48112 PyObject *swig_obj[1] ;
48113
48114 if (!args) SWIG_fail;
48115 swig_obj[0] = args;
48116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48117 if (!SWIG_IsOK(res1)) {
48118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48119 }
48120 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48121 {
48122 PyThreadState* __tstate = wxPyBeginAllowThreads();
48123 result = (int)(arg1)->GetHGap();
48124 wxPyEndAllowThreads(__tstate);
48125 if (PyErr_Occurred()) SWIG_fail;
48126 }
48127 resultobj = SWIG_From_int(static_cast< int >(result));
48128 return resultobj;
48129 fail:
48130 return NULL;
48131 }
48132
48133
48134 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48135 PyObject *obj;
48136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48137 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48138 return SWIG_Py_Void();
48139 }
48140
48141 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48142 return SWIG_Python_InitShadowInstance(args);
48143 }
48144
48145 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48146 PyObject *resultobj = 0;
48147 int arg1 = (int) 1 ;
48148 int arg2 = (int) 0 ;
48149 int arg3 = (int) 0 ;
48150 int arg4 = (int) 0 ;
48151 wxFlexGridSizer *result = 0 ;
48152 int val1 ;
48153 int ecode1 = 0 ;
48154 int val2 ;
48155 int ecode2 = 0 ;
48156 int val3 ;
48157 int ecode3 = 0 ;
48158 int val4 ;
48159 int ecode4 = 0 ;
48160 PyObject * obj0 = 0 ;
48161 PyObject * obj1 = 0 ;
48162 PyObject * obj2 = 0 ;
48163 PyObject * obj3 = 0 ;
48164 char * kwnames[] = {
48165 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48166 };
48167
48168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48169 if (obj0) {
48170 ecode1 = SWIG_AsVal_int(obj0, &val1);
48171 if (!SWIG_IsOK(ecode1)) {
48172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48173 }
48174 arg1 = static_cast< int >(val1);
48175 }
48176 if (obj1) {
48177 ecode2 = SWIG_AsVal_int(obj1, &val2);
48178 if (!SWIG_IsOK(ecode2)) {
48179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48180 }
48181 arg2 = static_cast< int >(val2);
48182 }
48183 if (obj2) {
48184 ecode3 = SWIG_AsVal_int(obj2, &val3);
48185 if (!SWIG_IsOK(ecode3)) {
48186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48187 }
48188 arg3 = static_cast< int >(val3);
48189 }
48190 if (obj3) {
48191 ecode4 = SWIG_AsVal_int(obj3, &val4);
48192 if (!SWIG_IsOK(ecode4)) {
48193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48194 }
48195 arg4 = static_cast< int >(val4);
48196 }
48197 {
48198 PyThreadState* __tstate = wxPyBeginAllowThreads();
48199 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48200 wxPyEndAllowThreads(__tstate);
48201 if (PyErr_Occurred()) SWIG_fail;
48202 }
48203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48204 return resultobj;
48205 fail:
48206 return NULL;
48207 }
48208
48209
48210 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48211 PyObject *resultobj = 0;
48212 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48213 size_t arg2 ;
48214 int arg3 = (int) 0 ;
48215 void *argp1 = 0 ;
48216 int res1 = 0 ;
48217 size_t val2 ;
48218 int ecode2 = 0 ;
48219 int val3 ;
48220 int ecode3 = 0 ;
48221 PyObject * obj0 = 0 ;
48222 PyObject * obj1 = 0 ;
48223 PyObject * obj2 = 0 ;
48224 char * kwnames[] = {
48225 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48226 };
48227
48228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48230 if (!SWIG_IsOK(res1)) {
48231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48232 }
48233 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48234 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48235 if (!SWIG_IsOK(ecode2)) {
48236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48237 }
48238 arg2 = static_cast< size_t >(val2);
48239 if (obj2) {
48240 ecode3 = SWIG_AsVal_int(obj2, &val3);
48241 if (!SWIG_IsOK(ecode3)) {
48242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48243 }
48244 arg3 = static_cast< int >(val3);
48245 }
48246 {
48247 PyThreadState* __tstate = wxPyBeginAllowThreads();
48248 (arg1)->AddGrowableRow(arg2,arg3);
48249 wxPyEndAllowThreads(__tstate);
48250 if (PyErr_Occurred()) SWIG_fail;
48251 }
48252 resultobj = SWIG_Py_Void();
48253 return resultobj;
48254 fail:
48255 return NULL;
48256 }
48257
48258
48259 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48260 PyObject *resultobj = 0;
48261 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48262 size_t arg2 ;
48263 void *argp1 = 0 ;
48264 int res1 = 0 ;
48265 size_t val2 ;
48266 int ecode2 = 0 ;
48267 PyObject * obj0 = 0 ;
48268 PyObject * obj1 = 0 ;
48269 char * kwnames[] = {
48270 (char *) "self",(char *) "idx", NULL
48271 };
48272
48273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48275 if (!SWIG_IsOK(res1)) {
48276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48277 }
48278 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48279 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48280 if (!SWIG_IsOK(ecode2)) {
48281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48282 }
48283 arg2 = static_cast< size_t >(val2);
48284 {
48285 PyThreadState* __tstate = wxPyBeginAllowThreads();
48286 (arg1)->RemoveGrowableRow(arg2);
48287 wxPyEndAllowThreads(__tstate);
48288 if (PyErr_Occurred()) SWIG_fail;
48289 }
48290 resultobj = SWIG_Py_Void();
48291 return resultobj;
48292 fail:
48293 return NULL;
48294 }
48295
48296
48297 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48298 PyObject *resultobj = 0;
48299 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48300 size_t arg2 ;
48301 int arg3 = (int) 0 ;
48302 void *argp1 = 0 ;
48303 int res1 = 0 ;
48304 size_t val2 ;
48305 int ecode2 = 0 ;
48306 int val3 ;
48307 int ecode3 = 0 ;
48308 PyObject * obj0 = 0 ;
48309 PyObject * obj1 = 0 ;
48310 PyObject * obj2 = 0 ;
48311 char * kwnames[] = {
48312 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48313 };
48314
48315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48317 if (!SWIG_IsOK(res1)) {
48318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48319 }
48320 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48321 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48322 if (!SWIG_IsOK(ecode2)) {
48323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48324 }
48325 arg2 = static_cast< size_t >(val2);
48326 if (obj2) {
48327 ecode3 = SWIG_AsVal_int(obj2, &val3);
48328 if (!SWIG_IsOK(ecode3)) {
48329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48330 }
48331 arg3 = static_cast< int >(val3);
48332 }
48333 {
48334 PyThreadState* __tstate = wxPyBeginAllowThreads();
48335 (arg1)->AddGrowableCol(arg2,arg3);
48336 wxPyEndAllowThreads(__tstate);
48337 if (PyErr_Occurred()) SWIG_fail;
48338 }
48339 resultobj = SWIG_Py_Void();
48340 return resultobj;
48341 fail:
48342 return NULL;
48343 }
48344
48345
48346 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48347 PyObject *resultobj = 0;
48348 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48349 size_t arg2 ;
48350 void *argp1 = 0 ;
48351 int res1 = 0 ;
48352 size_t val2 ;
48353 int ecode2 = 0 ;
48354 PyObject * obj0 = 0 ;
48355 PyObject * obj1 = 0 ;
48356 char * kwnames[] = {
48357 (char *) "self",(char *) "idx", NULL
48358 };
48359
48360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48362 if (!SWIG_IsOK(res1)) {
48363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48364 }
48365 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48366 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48367 if (!SWIG_IsOK(ecode2)) {
48368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48369 }
48370 arg2 = static_cast< size_t >(val2);
48371 {
48372 PyThreadState* __tstate = wxPyBeginAllowThreads();
48373 (arg1)->RemoveGrowableCol(arg2);
48374 wxPyEndAllowThreads(__tstate);
48375 if (PyErr_Occurred()) SWIG_fail;
48376 }
48377 resultobj = SWIG_Py_Void();
48378 return resultobj;
48379 fail:
48380 return NULL;
48381 }
48382
48383
48384 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48385 PyObject *resultobj = 0;
48386 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48387 int arg2 ;
48388 void *argp1 = 0 ;
48389 int res1 = 0 ;
48390 int val2 ;
48391 int ecode2 = 0 ;
48392 PyObject * obj0 = 0 ;
48393 PyObject * obj1 = 0 ;
48394 char * kwnames[] = {
48395 (char *) "self",(char *) "direction", NULL
48396 };
48397
48398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48400 if (!SWIG_IsOK(res1)) {
48401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48402 }
48403 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48404 ecode2 = SWIG_AsVal_int(obj1, &val2);
48405 if (!SWIG_IsOK(ecode2)) {
48406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48407 }
48408 arg2 = static_cast< int >(val2);
48409 {
48410 PyThreadState* __tstate = wxPyBeginAllowThreads();
48411 (arg1)->SetFlexibleDirection(arg2);
48412 wxPyEndAllowThreads(__tstate);
48413 if (PyErr_Occurred()) SWIG_fail;
48414 }
48415 resultobj = SWIG_Py_Void();
48416 return resultobj;
48417 fail:
48418 return NULL;
48419 }
48420
48421
48422 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48423 PyObject *resultobj = 0;
48424 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48425 int result;
48426 void *argp1 = 0 ;
48427 int res1 = 0 ;
48428 PyObject *swig_obj[1] ;
48429
48430 if (!args) SWIG_fail;
48431 swig_obj[0] = args;
48432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48433 if (!SWIG_IsOK(res1)) {
48434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48435 }
48436 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48437 {
48438 PyThreadState* __tstate = wxPyBeginAllowThreads();
48439 result = (int)(arg1)->GetFlexibleDirection();
48440 wxPyEndAllowThreads(__tstate);
48441 if (PyErr_Occurred()) SWIG_fail;
48442 }
48443 resultobj = SWIG_From_int(static_cast< int >(result));
48444 return resultobj;
48445 fail:
48446 return NULL;
48447 }
48448
48449
48450 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48451 PyObject *resultobj = 0;
48452 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48453 wxFlexSizerGrowMode arg2 ;
48454 void *argp1 = 0 ;
48455 int res1 = 0 ;
48456 int val2 ;
48457 int ecode2 = 0 ;
48458 PyObject * obj0 = 0 ;
48459 PyObject * obj1 = 0 ;
48460 char * kwnames[] = {
48461 (char *) "self",(char *) "mode", NULL
48462 };
48463
48464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48466 if (!SWIG_IsOK(res1)) {
48467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48468 }
48469 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48470 ecode2 = SWIG_AsVal_int(obj1, &val2);
48471 if (!SWIG_IsOK(ecode2)) {
48472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48473 }
48474 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48475 {
48476 PyThreadState* __tstate = wxPyBeginAllowThreads();
48477 (arg1)->SetNonFlexibleGrowMode(arg2);
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_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48489 PyObject *resultobj = 0;
48490 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48491 wxFlexSizerGrowMode result;
48492 void *argp1 = 0 ;
48493 int res1 = 0 ;
48494 PyObject *swig_obj[1] ;
48495
48496 if (!args) SWIG_fail;
48497 swig_obj[0] = args;
48498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48499 if (!SWIG_IsOK(res1)) {
48500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48501 }
48502 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48503 {
48504 PyThreadState* __tstate = wxPyBeginAllowThreads();
48505 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48506 wxPyEndAllowThreads(__tstate);
48507 if (PyErr_Occurred()) SWIG_fail;
48508 }
48509 resultobj = SWIG_From_int(static_cast< int >(result));
48510 return resultobj;
48511 fail:
48512 return NULL;
48513 }
48514
48515
48516 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48517 PyObject *resultobj = 0;
48518 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48519 wxArrayInt *result = 0 ;
48520 void *argp1 = 0 ;
48521 int res1 = 0 ;
48522 PyObject *swig_obj[1] ;
48523
48524 if (!args) SWIG_fail;
48525 swig_obj[0] = args;
48526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48527 if (!SWIG_IsOK(res1)) {
48528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48529 }
48530 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48531 {
48532 PyThreadState* __tstate = wxPyBeginAllowThreads();
48533 {
48534 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48535 result = (wxArrayInt *) &_result_ref;
48536 }
48537 wxPyEndAllowThreads(__tstate);
48538 if (PyErr_Occurred()) SWIG_fail;
48539 }
48540 {
48541 resultobj = PyList_New(0);
48542 size_t idx;
48543 for (idx = 0; idx < result->GetCount(); idx += 1) {
48544 PyObject* val = PyInt_FromLong( result->Item(idx) );
48545 PyList_Append(resultobj, val);
48546 Py_DECREF(val);
48547 }
48548 }
48549 return resultobj;
48550 fail:
48551 return NULL;
48552 }
48553
48554
48555 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48556 PyObject *resultobj = 0;
48557 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48558 wxArrayInt *result = 0 ;
48559 void *argp1 = 0 ;
48560 int res1 = 0 ;
48561 PyObject *swig_obj[1] ;
48562
48563 if (!args) SWIG_fail;
48564 swig_obj[0] = args;
48565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48566 if (!SWIG_IsOK(res1)) {
48567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48568 }
48569 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48570 {
48571 PyThreadState* __tstate = wxPyBeginAllowThreads();
48572 {
48573 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48574 result = (wxArrayInt *) &_result_ref;
48575 }
48576 wxPyEndAllowThreads(__tstate);
48577 if (PyErr_Occurred()) SWIG_fail;
48578 }
48579 {
48580 resultobj = PyList_New(0);
48581 size_t idx;
48582 for (idx = 0; idx < result->GetCount(); idx += 1) {
48583 PyObject* val = PyInt_FromLong( result->Item(idx) );
48584 PyList_Append(resultobj, val);
48585 Py_DECREF(val);
48586 }
48587 }
48588 return resultobj;
48589 fail:
48590 return NULL;
48591 }
48592
48593
48594 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48595 PyObject *obj;
48596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48597 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48598 return SWIG_Py_Void();
48599 }
48600
48601 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48602 return SWIG_Python_InitShadowInstance(args);
48603 }
48604
48605 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48606 PyObject *resultobj = 0;
48607 wxStdDialogButtonSizer *result = 0 ;
48608
48609 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48610 {
48611 PyThreadState* __tstate = wxPyBeginAllowThreads();
48612 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48613 wxPyEndAllowThreads(__tstate);
48614 if (PyErr_Occurred()) SWIG_fail;
48615 }
48616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48617 return resultobj;
48618 fail:
48619 return NULL;
48620 }
48621
48622
48623 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48624 PyObject *resultobj = 0;
48625 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48626 wxButton *arg2 = (wxButton *) 0 ;
48627 void *argp1 = 0 ;
48628 int res1 = 0 ;
48629 void *argp2 = 0 ;
48630 int res2 = 0 ;
48631 PyObject * obj0 = 0 ;
48632 PyObject * obj1 = 0 ;
48633 char * kwnames[] = {
48634 (char *) "self",(char *) "button", NULL
48635 };
48636
48637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48639 if (!SWIG_IsOK(res1)) {
48640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48641 }
48642 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48643 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48644 if (!SWIG_IsOK(res2)) {
48645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48646 }
48647 arg2 = reinterpret_cast< wxButton * >(argp2);
48648 {
48649 PyThreadState* __tstate = wxPyBeginAllowThreads();
48650 (arg1)->AddButton(arg2);
48651 wxPyEndAllowThreads(__tstate);
48652 if (PyErr_Occurred()) SWIG_fail;
48653 }
48654 resultobj = SWIG_Py_Void();
48655 return resultobj;
48656 fail:
48657 return NULL;
48658 }
48659
48660
48661 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48662 PyObject *resultobj = 0;
48663 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48664 void *argp1 = 0 ;
48665 int res1 = 0 ;
48666 PyObject *swig_obj[1] ;
48667
48668 if (!args) SWIG_fail;
48669 swig_obj[0] = args;
48670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48671 if (!SWIG_IsOK(res1)) {
48672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48673 }
48674 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48675 {
48676 PyThreadState* __tstate = wxPyBeginAllowThreads();
48677 (arg1)->Realize();
48678 wxPyEndAllowThreads(__tstate);
48679 if (PyErr_Occurred()) SWIG_fail;
48680 }
48681 resultobj = SWIG_Py_Void();
48682 return resultobj;
48683 fail:
48684 return NULL;
48685 }
48686
48687
48688 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48689 PyObject *resultobj = 0;
48690 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48691 wxButton *arg2 = (wxButton *) 0 ;
48692 void *argp1 = 0 ;
48693 int res1 = 0 ;
48694 void *argp2 = 0 ;
48695 int res2 = 0 ;
48696 PyObject * obj0 = 0 ;
48697 PyObject * obj1 = 0 ;
48698 char * kwnames[] = {
48699 (char *) "self",(char *) "button", NULL
48700 };
48701
48702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48704 if (!SWIG_IsOK(res1)) {
48705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48706 }
48707 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48708 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48709 if (!SWIG_IsOK(res2)) {
48710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48711 }
48712 arg2 = reinterpret_cast< wxButton * >(argp2);
48713 {
48714 PyThreadState* __tstate = wxPyBeginAllowThreads();
48715 (arg1)->SetAffirmativeButton(arg2);
48716 wxPyEndAllowThreads(__tstate);
48717 if (PyErr_Occurred()) SWIG_fail;
48718 }
48719 resultobj = SWIG_Py_Void();
48720 return resultobj;
48721 fail:
48722 return NULL;
48723 }
48724
48725
48726 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48727 PyObject *resultobj = 0;
48728 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48729 wxButton *arg2 = (wxButton *) 0 ;
48730 void *argp1 = 0 ;
48731 int res1 = 0 ;
48732 void *argp2 = 0 ;
48733 int res2 = 0 ;
48734 PyObject * obj0 = 0 ;
48735 PyObject * obj1 = 0 ;
48736 char * kwnames[] = {
48737 (char *) "self",(char *) "button", NULL
48738 };
48739
48740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48742 if (!SWIG_IsOK(res1)) {
48743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48744 }
48745 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48747 if (!SWIG_IsOK(res2)) {
48748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48749 }
48750 arg2 = reinterpret_cast< wxButton * >(argp2);
48751 {
48752 PyThreadState* __tstate = wxPyBeginAllowThreads();
48753 (arg1)->SetNegativeButton(arg2);
48754 wxPyEndAllowThreads(__tstate);
48755 if (PyErr_Occurred()) SWIG_fail;
48756 }
48757 resultobj = SWIG_Py_Void();
48758 return resultobj;
48759 fail:
48760 return NULL;
48761 }
48762
48763
48764 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48765 PyObject *resultobj = 0;
48766 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48767 wxButton *arg2 = (wxButton *) 0 ;
48768 void *argp1 = 0 ;
48769 int res1 = 0 ;
48770 void *argp2 = 0 ;
48771 int res2 = 0 ;
48772 PyObject * obj0 = 0 ;
48773 PyObject * obj1 = 0 ;
48774 char * kwnames[] = {
48775 (char *) "self",(char *) "button", NULL
48776 };
48777
48778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48780 if (!SWIG_IsOK(res1)) {
48781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48782 }
48783 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48784 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48785 if (!SWIG_IsOK(res2)) {
48786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48787 }
48788 arg2 = reinterpret_cast< wxButton * >(argp2);
48789 {
48790 PyThreadState* __tstate = wxPyBeginAllowThreads();
48791 (arg1)->SetCancelButton(arg2);
48792 wxPyEndAllowThreads(__tstate);
48793 if (PyErr_Occurred()) SWIG_fail;
48794 }
48795 resultobj = SWIG_Py_Void();
48796 return resultobj;
48797 fail:
48798 return NULL;
48799 }
48800
48801
48802 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48803 PyObject *resultobj = 0;
48804 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48805 wxButton *result = 0 ;
48806 void *argp1 = 0 ;
48807 int res1 = 0 ;
48808 PyObject *swig_obj[1] ;
48809
48810 if (!args) SWIG_fail;
48811 swig_obj[0] = args;
48812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48813 if (!SWIG_IsOK(res1)) {
48814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48815 }
48816 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48817 {
48818 PyThreadState* __tstate = wxPyBeginAllowThreads();
48819 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48820 wxPyEndAllowThreads(__tstate);
48821 if (PyErr_Occurred()) SWIG_fail;
48822 }
48823 {
48824 resultobj = wxPyMake_wxObject(result, (bool)0);
48825 }
48826 return resultobj;
48827 fail:
48828 return NULL;
48829 }
48830
48831
48832 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48833 PyObject *resultobj = 0;
48834 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48835 wxButton *result = 0 ;
48836 void *argp1 = 0 ;
48837 int res1 = 0 ;
48838 PyObject *swig_obj[1] ;
48839
48840 if (!args) SWIG_fail;
48841 swig_obj[0] = args;
48842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48843 if (!SWIG_IsOK(res1)) {
48844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48845 }
48846 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48847 {
48848 PyThreadState* __tstate = wxPyBeginAllowThreads();
48849 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48850 wxPyEndAllowThreads(__tstate);
48851 if (PyErr_Occurred()) SWIG_fail;
48852 }
48853 {
48854 resultobj = wxPyMake_wxObject(result, (bool)0);
48855 }
48856 return resultobj;
48857 fail:
48858 return NULL;
48859 }
48860
48861
48862 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48863 PyObject *resultobj = 0;
48864 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48865 wxButton *result = 0 ;
48866 void *argp1 = 0 ;
48867 int res1 = 0 ;
48868 PyObject *swig_obj[1] ;
48869
48870 if (!args) SWIG_fail;
48871 swig_obj[0] = args;
48872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48873 if (!SWIG_IsOK(res1)) {
48874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48875 }
48876 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48877 {
48878 PyThreadState* __tstate = wxPyBeginAllowThreads();
48879 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48880 wxPyEndAllowThreads(__tstate);
48881 if (PyErr_Occurred()) SWIG_fail;
48882 }
48883 {
48884 resultobj = wxPyMake_wxObject(result, (bool)0);
48885 }
48886 return resultobj;
48887 fail:
48888 return NULL;
48889 }
48890
48891
48892 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48893 PyObject *resultobj = 0;
48894 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48895 wxButton *result = 0 ;
48896 void *argp1 = 0 ;
48897 int res1 = 0 ;
48898 PyObject *swig_obj[1] ;
48899
48900 if (!args) SWIG_fail;
48901 swig_obj[0] = args;
48902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48903 if (!SWIG_IsOK(res1)) {
48904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48905 }
48906 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48907 {
48908 PyThreadState* __tstate = wxPyBeginAllowThreads();
48909 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48910 wxPyEndAllowThreads(__tstate);
48911 if (PyErr_Occurred()) SWIG_fail;
48912 }
48913 {
48914 resultobj = wxPyMake_wxObject(result, (bool)0);
48915 }
48916 return resultobj;
48917 fail:
48918 return NULL;
48919 }
48920
48921
48922 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48923 PyObject *resultobj = 0;
48924 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48925 wxButton *result = 0 ;
48926 void *argp1 = 0 ;
48927 int res1 = 0 ;
48928 PyObject *swig_obj[1] ;
48929
48930 if (!args) SWIG_fail;
48931 swig_obj[0] = args;
48932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48933 if (!SWIG_IsOK(res1)) {
48934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48935 }
48936 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48937 {
48938 PyThreadState* __tstate = wxPyBeginAllowThreads();
48939 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48940 wxPyEndAllowThreads(__tstate);
48941 if (PyErr_Occurred()) SWIG_fail;
48942 }
48943 {
48944 resultobj = wxPyMake_wxObject(result, (bool)0);
48945 }
48946 return resultobj;
48947 fail:
48948 return NULL;
48949 }
48950
48951
48952 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48953 PyObject *obj;
48954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48955 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48956 return SWIG_Py_Void();
48957 }
48958
48959 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48960 return SWIG_Python_InitShadowInstance(args);
48961 }
48962
48963 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48964 PyObject *resultobj = 0;
48965 int arg1 = (int) 0 ;
48966 int arg2 = (int) 0 ;
48967 wxGBPosition *result = 0 ;
48968 int val1 ;
48969 int ecode1 = 0 ;
48970 int val2 ;
48971 int ecode2 = 0 ;
48972 PyObject * obj0 = 0 ;
48973 PyObject * obj1 = 0 ;
48974 char * kwnames[] = {
48975 (char *) "row",(char *) "col", NULL
48976 };
48977
48978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48979 if (obj0) {
48980 ecode1 = SWIG_AsVal_int(obj0, &val1);
48981 if (!SWIG_IsOK(ecode1)) {
48982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48983 }
48984 arg1 = static_cast< int >(val1);
48985 }
48986 if (obj1) {
48987 ecode2 = SWIG_AsVal_int(obj1, &val2);
48988 if (!SWIG_IsOK(ecode2)) {
48989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48990 }
48991 arg2 = static_cast< int >(val2);
48992 }
48993 {
48994 PyThreadState* __tstate = wxPyBeginAllowThreads();
48995 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48996 wxPyEndAllowThreads(__tstate);
48997 if (PyErr_Occurred()) SWIG_fail;
48998 }
48999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49000 return resultobj;
49001 fail:
49002 return NULL;
49003 }
49004
49005
49006 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49007 PyObject *resultobj = 0;
49008 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49009 void *argp1 = 0 ;
49010 int res1 = 0 ;
49011 PyObject *swig_obj[1] ;
49012
49013 if (!args) SWIG_fail;
49014 swig_obj[0] = args;
49015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49016 if (!SWIG_IsOK(res1)) {
49017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49018 }
49019 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49020 {
49021 PyThreadState* __tstate = wxPyBeginAllowThreads();
49022 delete arg1;
49023
49024 wxPyEndAllowThreads(__tstate);
49025 if (PyErr_Occurred()) SWIG_fail;
49026 }
49027 resultobj = SWIG_Py_Void();
49028 return resultobj;
49029 fail:
49030 return NULL;
49031 }
49032
49033
49034 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49035 PyObject *resultobj = 0;
49036 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49037 int result;
49038 void *argp1 = 0 ;
49039 int res1 = 0 ;
49040 PyObject *swig_obj[1] ;
49041
49042 if (!args) SWIG_fail;
49043 swig_obj[0] = args;
49044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49045 if (!SWIG_IsOK(res1)) {
49046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49047 }
49048 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49049 {
49050 PyThreadState* __tstate = wxPyBeginAllowThreads();
49051 result = (int)((wxGBPosition const *)arg1)->GetRow();
49052 wxPyEndAllowThreads(__tstate);
49053 if (PyErr_Occurred()) SWIG_fail;
49054 }
49055 resultobj = SWIG_From_int(static_cast< int >(result));
49056 return resultobj;
49057 fail:
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49063 PyObject *resultobj = 0;
49064 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49065 int result;
49066 void *argp1 = 0 ;
49067 int res1 = 0 ;
49068 PyObject *swig_obj[1] ;
49069
49070 if (!args) SWIG_fail;
49071 swig_obj[0] = args;
49072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49073 if (!SWIG_IsOK(res1)) {
49074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49075 }
49076 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49077 {
49078 PyThreadState* __tstate = wxPyBeginAllowThreads();
49079 result = (int)((wxGBPosition const *)arg1)->GetCol();
49080 wxPyEndAllowThreads(__tstate);
49081 if (PyErr_Occurred()) SWIG_fail;
49082 }
49083 resultobj = SWIG_From_int(static_cast< int >(result));
49084 return resultobj;
49085 fail:
49086 return NULL;
49087 }
49088
49089
49090 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49091 PyObject *resultobj = 0;
49092 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49093 int arg2 ;
49094 void *argp1 = 0 ;
49095 int res1 = 0 ;
49096 int val2 ;
49097 int ecode2 = 0 ;
49098 PyObject * obj0 = 0 ;
49099 PyObject * obj1 = 0 ;
49100 char * kwnames[] = {
49101 (char *) "self",(char *) "row", NULL
49102 };
49103
49104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49106 if (!SWIG_IsOK(res1)) {
49107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49108 }
49109 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49110 ecode2 = SWIG_AsVal_int(obj1, &val2);
49111 if (!SWIG_IsOK(ecode2)) {
49112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49113 }
49114 arg2 = static_cast< int >(val2);
49115 {
49116 PyThreadState* __tstate = wxPyBeginAllowThreads();
49117 (arg1)->SetRow(arg2);
49118 wxPyEndAllowThreads(__tstate);
49119 if (PyErr_Occurred()) SWIG_fail;
49120 }
49121 resultobj = SWIG_Py_Void();
49122 return resultobj;
49123 fail:
49124 return NULL;
49125 }
49126
49127
49128 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49129 PyObject *resultobj = 0;
49130 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49131 int arg2 ;
49132 void *argp1 = 0 ;
49133 int res1 = 0 ;
49134 int val2 ;
49135 int ecode2 = 0 ;
49136 PyObject * obj0 = 0 ;
49137 PyObject * obj1 = 0 ;
49138 char * kwnames[] = {
49139 (char *) "self",(char *) "col", NULL
49140 };
49141
49142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49144 if (!SWIG_IsOK(res1)) {
49145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49146 }
49147 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49148 ecode2 = SWIG_AsVal_int(obj1, &val2);
49149 if (!SWIG_IsOK(ecode2)) {
49150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49151 }
49152 arg2 = static_cast< int >(val2);
49153 {
49154 PyThreadState* __tstate = wxPyBeginAllowThreads();
49155 (arg1)->SetCol(arg2);
49156 wxPyEndAllowThreads(__tstate);
49157 if (PyErr_Occurred()) SWIG_fail;
49158 }
49159 resultobj = SWIG_Py_Void();
49160 return resultobj;
49161 fail:
49162 return NULL;
49163 }
49164
49165
49166 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49167 PyObject *resultobj = 0;
49168 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49169 PyObject *arg2 = (PyObject *) 0 ;
49170 bool result;
49171 void *argp1 = 0 ;
49172 int res1 = 0 ;
49173 PyObject * obj0 = 0 ;
49174 PyObject * obj1 = 0 ;
49175 char * kwnames[] = {
49176 (char *) "self",(char *) "other", NULL
49177 };
49178
49179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49181 if (!SWIG_IsOK(res1)) {
49182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49183 }
49184 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49185 arg2 = obj1;
49186 {
49187 result = (bool)wxGBPosition___eq__(arg1,arg2);
49188 if (PyErr_Occurred()) SWIG_fail;
49189 }
49190 {
49191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49192 }
49193 return resultobj;
49194 fail:
49195 return NULL;
49196 }
49197
49198
49199 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49200 PyObject *resultobj = 0;
49201 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49202 PyObject *arg2 = (PyObject *) 0 ;
49203 bool result;
49204 void *argp1 = 0 ;
49205 int res1 = 0 ;
49206 PyObject * obj0 = 0 ;
49207 PyObject * obj1 = 0 ;
49208 char * kwnames[] = {
49209 (char *) "self",(char *) "other", NULL
49210 };
49211
49212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49214 if (!SWIG_IsOK(res1)) {
49215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49216 }
49217 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49218 arg2 = obj1;
49219 {
49220 result = (bool)wxGBPosition___ne__(arg1,arg2);
49221 if (PyErr_Occurred()) SWIG_fail;
49222 }
49223 {
49224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49225 }
49226 return resultobj;
49227 fail:
49228 return NULL;
49229 }
49230
49231
49232 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49233 PyObject *resultobj = 0;
49234 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49235 int arg2 = (int) 0 ;
49236 int arg3 = (int) 0 ;
49237 void *argp1 = 0 ;
49238 int res1 = 0 ;
49239 int val2 ;
49240 int ecode2 = 0 ;
49241 int val3 ;
49242 int ecode3 = 0 ;
49243 PyObject * obj0 = 0 ;
49244 PyObject * obj1 = 0 ;
49245 PyObject * obj2 = 0 ;
49246 char * kwnames[] = {
49247 (char *) "self",(char *) "row",(char *) "col", NULL
49248 };
49249
49250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49252 if (!SWIG_IsOK(res1)) {
49253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49254 }
49255 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49256 if (obj1) {
49257 ecode2 = SWIG_AsVal_int(obj1, &val2);
49258 if (!SWIG_IsOK(ecode2)) {
49259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49260 }
49261 arg2 = static_cast< int >(val2);
49262 }
49263 if (obj2) {
49264 ecode3 = SWIG_AsVal_int(obj2, &val3);
49265 if (!SWIG_IsOK(ecode3)) {
49266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49267 }
49268 arg3 = static_cast< int >(val3);
49269 }
49270 {
49271 PyThreadState* __tstate = wxPyBeginAllowThreads();
49272 wxGBPosition_Set(arg1,arg2,arg3);
49273 wxPyEndAllowThreads(__tstate);
49274 if (PyErr_Occurred()) SWIG_fail;
49275 }
49276 resultobj = SWIG_Py_Void();
49277 return resultobj;
49278 fail:
49279 return NULL;
49280 }
49281
49282
49283 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49284 PyObject *resultobj = 0;
49285 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49286 PyObject *result = 0 ;
49287 void *argp1 = 0 ;
49288 int res1 = 0 ;
49289 PyObject *swig_obj[1] ;
49290
49291 if (!args) SWIG_fail;
49292 swig_obj[0] = args;
49293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49294 if (!SWIG_IsOK(res1)) {
49295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49296 }
49297 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49298 {
49299 PyThreadState* __tstate = wxPyBeginAllowThreads();
49300 result = (PyObject *)wxGBPosition_Get(arg1);
49301 wxPyEndAllowThreads(__tstate);
49302 if (PyErr_Occurred()) SWIG_fail;
49303 }
49304 resultobj = result;
49305 return resultobj;
49306 fail:
49307 return NULL;
49308 }
49309
49310
49311 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49312 PyObject *obj;
49313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49314 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49315 return SWIG_Py_Void();
49316 }
49317
49318 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49319 return SWIG_Python_InitShadowInstance(args);
49320 }
49321
49322 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49323 PyObject *resultobj = 0;
49324 int arg1 = (int) 1 ;
49325 int arg2 = (int) 1 ;
49326 wxGBSpan *result = 0 ;
49327 int val1 ;
49328 int ecode1 = 0 ;
49329 int val2 ;
49330 int ecode2 = 0 ;
49331 PyObject * obj0 = 0 ;
49332 PyObject * obj1 = 0 ;
49333 char * kwnames[] = {
49334 (char *) "rowspan",(char *) "colspan", NULL
49335 };
49336
49337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49338 if (obj0) {
49339 ecode1 = SWIG_AsVal_int(obj0, &val1);
49340 if (!SWIG_IsOK(ecode1)) {
49341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49342 }
49343 arg1 = static_cast< int >(val1);
49344 }
49345 if (obj1) {
49346 ecode2 = SWIG_AsVal_int(obj1, &val2);
49347 if (!SWIG_IsOK(ecode2)) {
49348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49349 }
49350 arg2 = static_cast< int >(val2);
49351 }
49352 {
49353 PyThreadState* __tstate = wxPyBeginAllowThreads();
49354 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49355 wxPyEndAllowThreads(__tstate);
49356 if (PyErr_Occurred()) SWIG_fail;
49357 }
49358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49359 return resultobj;
49360 fail:
49361 return NULL;
49362 }
49363
49364
49365 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49366 PyObject *resultobj = 0;
49367 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49368 void *argp1 = 0 ;
49369 int res1 = 0 ;
49370 PyObject *swig_obj[1] ;
49371
49372 if (!args) SWIG_fail;
49373 swig_obj[0] = args;
49374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49375 if (!SWIG_IsOK(res1)) {
49376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49377 }
49378 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49379 {
49380 PyThreadState* __tstate = wxPyBeginAllowThreads();
49381 delete arg1;
49382
49383 wxPyEndAllowThreads(__tstate);
49384 if (PyErr_Occurred()) SWIG_fail;
49385 }
49386 resultobj = SWIG_Py_Void();
49387 return resultobj;
49388 fail:
49389 return NULL;
49390 }
49391
49392
49393 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49394 PyObject *resultobj = 0;
49395 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49396 int result;
49397 void *argp1 = 0 ;
49398 int res1 = 0 ;
49399 PyObject *swig_obj[1] ;
49400
49401 if (!args) SWIG_fail;
49402 swig_obj[0] = args;
49403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49404 if (!SWIG_IsOK(res1)) {
49405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49406 }
49407 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49408 {
49409 PyThreadState* __tstate = wxPyBeginAllowThreads();
49410 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49411 wxPyEndAllowThreads(__tstate);
49412 if (PyErr_Occurred()) SWIG_fail;
49413 }
49414 resultobj = SWIG_From_int(static_cast< int >(result));
49415 return resultobj;
49416 fail:
49417 return NULL;
49418 }
49419
49420
49421 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49422 PyObject *resultobj = 0;
49423 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49424 int result;
49425 void *argp1 = 0 ;
49426 int res1 = 0 ;
49427 PyObject *swig_obj[1] ;
49428
49429 if (!args) SWIG_fail;
49430 swig_obj[0] = args;
49431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49432 if (!SWIG_IsOK(res1)) {
49433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49434 }
49435 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49436 {
49437 PyThreadState* __tstate = wxPyBeginAllowThreads();
49438 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49439 wxPyEndAllowThreads(__tstate);
49440 if (PyErr_Occurred()) SWIG_fail;
49441 }
49442 resultobj = SWIG_From_int(static_cast< int >(result));
49443 return resultobj;
49444 fail:
49445 return NULL;
49446 }
49447
49448
49449 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49450 PyObject *resultobj = 0;
49451 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49452 int arg2 ;
49453 void *argp1 = 0 ;
49454 int res1 = 0 ;
49455 int val2 ;
49456 int ecode2 = 0 ;
49457 PyObject * obj0 = 0 ;
49458 PyObject * obj1 = 0 ;
49459 char * kwnames[] = {
49460 (char *) "self",(char *) "rowspan", NULL
49461 };
49462
49463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49465 if (!SWIG_IsOK(res1)) {
49466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49467 }
49468 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49469 ecode2 = SWIG_AsVal_int(obj1, &val2);
49470 if (!SWIG_IsOK(ecode2)) {
49471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49472 }
49473 arg2 = static_cast< int >(val2);
49474 {
49475 PyThreadState* __tstate = wxPyBeginAllowThreads();
49476 (arg1)->SetRowspan(arg2);
49477 wxPyEndAllowThreads(__tstate);
49478 if (PyErr_Occurred()) SWIG_fail;
49479 }
49480 resultobj = SWIG_Py_Void();
49481 return resultobj;
49482 fail:
49483 return NULL;
49484 }
49485
49486
49487 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49488 PyObject *resultobj = 0;
49489 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49490 int arg2 ;
49491 void *argp1 = 0 ;
49492 int res1 = 0 ;
49493 int val2 ;
49494 int ecode2 = 0 ;
49495 PyObject * obj0 = 0 ;
49496 PyObject * obj1 = 0 ;
49497 char * kwnames[] = {
49498 (char *) "self",(char *) "colspan", NULL
49499 };
49500
49501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49503 if (!SWIG_IsOK(res1)) {
49504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49505 }
49506 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49507 ecode2 = SWIG_AsVal_int(obj1, &val2);
49508 if (!SWIG_IsOK(ecode2)) {
49509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49510 }
49511 arg2 = static_cast< int >(val2);
49512 {
49513 PyThreadState* __tstate = wxPyBeginAllowThreads();
49514 (arg1)->SetColspan(arg2);
49515 wxPyEndAllowThreads(__tstate);
49516 if (PyErr_Occurred()) SWIG_fail;
49517 }
49518 resultobj = SWIG_Py_Void();
49519 return resultobj;
49520 fail:
49521 return NULL;
49522 }
49523
49524
49525 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49526 PyObject *resultobj = 0;
49527 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49528 PyObject *arg2 = (PyObject *) 0 ;
49529 bool result;
49530 void *argp1 = 0 ;
49531 int res1 = 0 ;
49532 PyObject * obj0 = 0 ;
49533 PyObject * obj1 = 0 ;
49534 char * kwnames[] = {
49535 (char *) "self",(char *) "other", NULL
49536 };
49537
49538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49540 if (!SWIG_IsOK(res1)) {
49541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49542 }
49543 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49544 arg2 = obj1;
49545 {
49546 result = (bool)wxGBSpan___eq__(arg1,arg2);
49547 if (PyErr_Occurred()) SWIG_fail;
49548 }
49549 {
49550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49551 }
49552 return resultobj;
49553 fail:
49554 return NULL;
49555 }
49556
49557
49558 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49559 PyObject *resultobj = 0;
49560 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49561 PyObject *arg2 = (PyObject *) 0 ;
49562 bool result;
49563 void *argp1 = 0 ;
49564 int res1 = 0 ;
49565 PyObject * obj0 = 0 ;
49566 PyObject * obj1 = 0 ;
49567 char * kwnames[] = {
49568 (char *) "self",(char *) "other", NULL
49569 };
49570
49571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49573 if (!SWIG_IsOK(res1)) {
49574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49575 }
49576 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49577 arg2 = obj1;
49578 {
49579 result = (bool)wxGBSpan___ne__(arg1,arg2);
49580 if (PyErr_Occurred()) SWIG_fail;
49581 }
49582 {
49583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49584 }
49585 return resultobj;
49586 fail:
49587 return NULL;
49588 }
49589
49590
49591 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49592 PyObject *resultobj = 0;
49593 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49594 int arg2 = (int) 1 ;
49595 int arg3 = (int) 1 ;
49596 void *argp1 = 0 ;
49597 int res1 = 0 ;
49598 int val2 ;
49599 int ecode2 = 0 ;
49600 int val3 ;
49601 int ecode3 = 0 ;
49602 PyObject * obj0 = 0 ;
49603 PyObject * obj1 = 0 ;
49604 PyObject * obj2 = 0 ;
49605 char * kwnames[] = {
49606 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49607 };
49608
49609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49611 if (!SWIG_IsOK(res1)) {
49612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49613 }
49614 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49615 if (obj1) {
49616 ecode2 = SWIG_AsVal_int(obj1, &val2);
49617 if (!SWIG_IsOK(ecode2)) {
49618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49619 }
49620 arg2 = static_cast< int >(val2);
49621 }
49622 if (obj2) {
49623 ecode3 = SWIG_AsVal_int(obj2, &val3);
49624 if (!SWIG_IsOK(ecode3)) {
49625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49626 }
49627 arg3 = static_cast< int >(val3);
49628 }
49629 {
49630 PyThreadState* __tstate = wxPyBeginAllowThreads();
49631 wxGBSpan_Set(arg1,arg2,arg3);
49632 wxPyEndAllowThreads(__tstate);
49633 if (PyErr_Occurred()) SWIG_fail;
49634 }
49635 resultobj = SWIG_Py_Void();
49636 return resultobj;
49637 fail:
49638 return NULL;
49639 }
49640
49641
49642 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49643 PyObject *resultobj = 0;
49644 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49645 PyObject *result = 0 ;
49646 void *argp1 = 0 ;
49647 int res1 = 0 ;
49648 PyObject *swig_obj[1] ;
49649
49650 if (!args) SWIG_fail;
49651 swig_obj[0] = args;
49652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49653 if (!SWIG_IsOK(res1)) {
49654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49655 }
49656 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49657 {
49658 PyThreadState* __tstate = wxPyBeginAllowThreads();
49659 result = (PyObject *)wxGBSpan_Get(arg1);
49660 wxPyEndAllowThreads(__tstate);
49661 if (PyErr_Occurred()) SWIG_fail;
49662 }
49663 resultobj = result;
49664 return resultobj;
49665 fail:
49666 return NULL;
49667 }
49668
49669
49670 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49671 PyObject *obj;
49672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49673 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49674 return SWIG_Py_Void();
49675 }
49676
49677 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49678 return SWIG_Python_InitShadowInstance(args);
49679 }
49680
49681 SWIGINTERN int DefaultSpan_set(PyObject *) {
49682 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49683 return 1;
49684 }
49685
49686
49687 SWIGINTERN PyObject *DefaultSpan_get(void) {
49688 PyObject *pyobj = 0;
49689
49690 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49691 return pyobj;
49692 }
49693
49694
49695 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49696 PyObject *resultobj = 0;
49697 wxGBSizerItem *result = 0 ;
49698
49699 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49700 {
49701 PyThreadState* __tstate = wxPyBeginAllowThreads();
49702 result = (wxGBSizerItem *)new wxGBSizerItem();
49703 wxPyEndAllowThreads(__tstate);
49704 if (PyErr_Occurred()) SWIG_fail;
49705 }
49706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49707 return resultobj;
49708 fail:
49709 return NULL;
49710 }
49711
49712
49713 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49714 PyObject *resultobj = 0;
49715 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49716 void *argp1 = 0 ;
49717 int res1 = 0 ;
49718 PyObject *swig_obj[1] ;
49719
49720 if (!args) SWIG_fail;
49721 swig_obj[0] = args;
49722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49723 if (!SWIG_IsOK(res1)) {
49724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49725 }
49726 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49727 {
49728 PyThreadState* __tstate = wxPyBeginAllowThreads();
49729 delete arg1;
49730
49731 wxPyEndAllowThreads(__tstate);
49732 if (PyErr_Occurred()) SWIG_fail;
49733 }
49734 resultobj = SWIG_Py_Void();
49735 return resultobj;
49736 fail:
49737 return NULL;
49738 }
49739
49740
49741 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49742 PyObject *resultobj = 0;
49743 wxWindow *arg1 = (wxWindow *) 0 ;
49744 wxGBPosition *arg2 = 0 ;
49745 wxGBSpan *arg3 = 0 ;
49746 int arg4 ;
49747 int arg5 ;
49748 PyObject *arg6 = (PyObject *) NULL ;
49749 wxGBSizerItem *result = 0 ;
49750 void *argp1 = 0 ;
49751 int res1 = 0 ;
49752 wxGBPosition temp2 ;
49753 wxGBSpan temp3 ;
49754 int val4 ;
49755 int ecode4 = 0 ;
49756 int val5 ;
49757 int ecode5 = 0 ;
49758 PyObject * obj0 = 0 ;
49759 PyObject * obj1 = 0 ;
49760 PyObject * obj2 = 0 ;
49761 PyObject * obj3 = 0 ;
49762 PyObject * obj4 = 0 ;
49763 PyObject * obj5 = 0 ;
49764 char * kwnames[] = {
49765 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49766 };
49767
49768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49770 if (!SWIG_IsOK(res1)) {
49771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49772 }
49773 arg1 = reinterpret_cast< wxWindow * >(argp1);
49774 {
49775 arg2 = &temp2;
49776 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49777 }
49778 {
49779 arg3 = &temp3;
49780 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49781 }
49782 ecode4 = SWIG_AsVal_int(obj3, &val4);
49783 if (!SWIG_IsOK(ecode4)) {
49784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49785 }
49786 arg4 = static_cast< int >(val4);
49787 ecode5 = SWIG_AsVal_int(obj4, &val5);
49788 if (!SWIG_IsOK(ecode5)) {
49789 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49790 }
49791 arg5 = static_cast< int >(val5);
49792 if (obj5) {
49793 arg6 = obj5;
49794 }
49795 {
49796 PyThreadState* __tstate = wxPyBeginAllowThreads();
49797 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49798 wxPyEndAllowThreads(__tstate);
49799 if (PyErr_Occurred()) SWIG_fail;
49800 }
49801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49802 return resultobj;
49803 fail:
49804 return NULL;
49805 }
49806
49807
49808 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49809 PyObject *resultobj = 0;
49810 wxSizer *arg1 = (wxSizer *) 0 ;
49811 wxGBPosition *arg2 = 0 ;
49812 wxGBSpan *arg3 = 0 ;
49813 int arg4 ;
49814 int arg5 ;
49815 PyObject *arg6 = (PyObject *) NULL ;
49816 wxGBSizerItem *result = 0 ;
49817 int res1 = 0 ;
49818 wxGBPosition temp2 ;
49819 wxGBSpan temp3 ;
49820 int val4 ;
49821 int ecode4 = 0 ;
49822 int val5 ;
49823 int ecode5 = 0 ;
49824 PyObject * obj0 = 0 ;
49825 PyObject * obj1 = 0 ;
49826 PyObject * obj2 = 0 ;
49827 PyObject * obj3 = 0 ;
49828 PyObject * obj4 = 0 ;
49829 PyObject * obj5 = 0 ;
49830 char * kwnames[] = {
49831 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49832 };
49833
49834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49835 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49836 if (!SWIG_IsOK(res1)) {
49837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49838 }
49839 {
49840 arg2 = &temp2;
49841 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49842 }
49843 {
49844 arg3 = &temp3;
49845 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49846 }
49847 ecode4 = SWIG_AsVal_int(obj3, &val4);
49848 if (!SWIG_IsOK(ecode4)) {
49849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49850 }
49851 arg4 = static_cast< int >(val4);
49852 ecode5 = SWIG_AsVal_int(obj4, &val5);
49853 if (!SWIG_IsOK(ecode5)) {
49854 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49855 }
49856 arg5 = static_cast< int >(val5);
49857 if (obj5) {
49858 arg6 = obj5;
49859 }
49860 {
49861 PyThreadState* __tstate = wxPyBeginAllowThreads();
49862 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49863 wxPyEndAllowThreads(__tstate);
49864 if (PyErr_Occurred()) SWIG_fail;
49865 }
49866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49867 return resultobj;
49868 fail:
49869 return NULL;
49870 }
49871
49872
49873 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49874 PyObject *resultobj = 0;
49875 int arg1 ;
49876 int arg2 ;
49877 wxGBPosition *arg3 = 0 ;
49878 wxGBSpan *arg4 = 0 ;
49879 int arg5 ;
49880 int arg6 ;
49881 PyObject *arg7 = (PyObject *) NULL ;
49882 wxGBSizerItem *result = 0 ;
49883 int val1 ;
49884 int ecode1 = 0 ;
49885 int val2 ;
49886 int ecode2 = 0 ;
49887 wxGBPosition temp3 ;
49888 wxGBSpan temp4 ;
49889 int val5 ;
49890 int ecode5 = 0 ;
49891 int val6 ;
49892 int ecode6 = 0 ;
49893 PyObject * obj0 = 0 ;
49894 PyObject * obj1 = 0 ;
49895 PyObject * obj2 = 0 ;
49896 PyObject * obj3 = 0 ;
49897 PyObject * obj4 = 0 ;
49898 PyObject * obj5 = 0 ;
49899 PyObject * obj6 = 0 ;
49900 char * kwnames[] = {
49901 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49902 };
49903
49904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49905 ecode1 = SWIG_AsVal_int(obj0, &val1);
49906 if (!SWIG_IsOK(ecode1)) {
49907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49908 }
49909 arg1 = static_cast< int >(val1);
49910 ecode2 = SWIG_AsVal_int(obj1, &val2);
49911 if (!SWIG_IsOK(ecode2)) {
49912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49913 }
49914 arg2 = static_cast< int >(val2);
49915 {
49916 arg3 = &temp3;
49917 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49918 }
49919 {
49920 arg4 = &temp4;
49921 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49922 }
49923 ecode5 = SWIG_AsVal_int(obj4, &val5);
49924 if (!SWIG_IsOK(ecode5)) {
49925 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49926 }
49927 arg5 = static_cast< int >(val5);
49928 ecode6 = SWIG_AsVal_int(obj5, &val6);
49929 if (!SWIG_IsOK(ecode6)) {
49930 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49931 }
49932 arg6 = static_cast< int >(val6);
49933 if (obj6) {
49934 arg7 = obj6;
49935 }
49936 {
49937 PyThreadState* __tstate = wxPyBeginAllowThreads();
49938 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49939 wxPyEndAllowThreads(__tstate);
49940 if (PyErr_Occurred()) SWIG_fail;
49941 }
49942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49943 return resultobj;
49944 fail:
49945 return NULL;
49946 }
49947
49948
49949 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49950 PyObject *resultobj = 0;
49951 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49952 wxGBPosition result;
49953 void *argp1 = 0 ;
49954 int res1 = 0 ;
49955 PyObject *swig_obj[1] ;
49956
49957 if (!args) SWIG_fail;
49958 swig_obj[0] = args;
49959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49960 if (!SWIG_IsOK(res1)) {
49961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49962 }
49963 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49964 {
49965 PyThreadState* __tstate = wxPyBeginAllowThreads();
49966 result = ((wxGBSizerItem const *)arg1)->GetPos();
49967 wxPyEndAllowThreads(__tstate);
49968 if (PyErr_Occurred()) SWIG_fail;
49969 }
49970 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49971 return resultobj;
49972 fail:
49973 return NULL;
49974 }
49975
49976
49977 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49978 PyObject *resultobj = 0;
49979 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49980 wxGBSpan result;
49981 void *argp1 = 0 ;
49982 int res1 = 0 ;
49983 PyObject *swig_obj[1] ;
49984
49985 if (!args) SWIG_fail;
49986 swig_obj[0] = args;
49987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49988 if (!SWIG_IsOK(res1)) {
49989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49990 }
49991 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49992 {
49993 PyThreadState* __tstate = wxPyBeginAllowThreads();
49994 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49995 wxPyEndAllowThreads(__tstate);
49996 if (PyErr_Occurred()) SWIG_fail;
49997 }
49998 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49999 return resultobj;
50000 fail:
50001 return NULL;
50002 }
50003
50004
50005 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50006 PyObject *resultobj = 0;
50007 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50008 wxGBPosition *arg2 = 0 ;
50009 bool result;
50010 void *argp1 = 0 ;
50011 int res1 = 0 ;
50012 wxGBPosition temp2 ;
50013 PyObject * obj0 = 0 ;
50014 PyObject * obj1 = 0 ;
50015 char * kwnames[] = {
50016 (char *) "self",(char *) "pos", NULL
50017 };
50018
50019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50021 if (!SWIG_IsOK(res1)) {
50022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50023 }
50024 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50025 {
50026 arg2 = &temp2;
50027 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50028 }
50029 {
50030 PyThreadState* __tstate = wxPyBeginAllowThreads();
50031 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50032 wxPyEndAllowThreads(__tstate);
50033 if (PyErr_Occurred()) SWIG_fail;
50034 }
50035 {
50036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50037 }
50038 return resultobj;
50039 fail:
50040 return NULL;
50041 }
50042
50043
50044 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50045 PyObject *resultobj = 0;
50046 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50047 wxGBSpan *arg2 = 0 ;
50048 bool result;
50049 void *argp1 = 0 ;
50050 int res1 = 0 ;
50051 wxGBSpan temp2 ;
50052 PyObject * obj0 = 0 ;
50053 PyObject * obj1 = 0 ;
50054 char * kwnames[] = {
50055 (char *) "self",(char *) "span", NULL
50056 };
50057
50058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50060 if (!SWIG_IsOK(res1)) {
50061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50062 }
50063 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50064 {
50065 arg2 = &temp2;
50066 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50067 }
50068 {
50069 PyThreadState* __tstate = wxPyBeginAllowThreads();
50070 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50071 wxPyEndAllowThreads(__tstate);
50072 if (PyErr_Occurred()) SWIG_fail;
50073 }
50074 {
50075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50076 }
50077 return resultobj;
50078 fail:
50079 return NULL;
50080 }
50081
50082
50083 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50084 PyObject *resultobj = 0;
50085 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50086 wxGBSizerItem *arg2 = 0 ;
50087 bool result;
50088 void *argp1 = 0 ;
50089 int res1 = 0 ;
50090 void *argp2 = 0 ;
50091 int res2 = 0 ;
50092 PyObject * obj0 = 0 ;
50093 PyObject * obj1 = 0 ;
50094 char * kwnames[] = {
50095 (char *) "self",(char *) "other", NULL
50096 };
50097
50098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50100 if (!SWIG_IsOK(res1)) {
50101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50102 }
50103 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50104 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50105 if (!SWIG_IsOK(res2)) {
50106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50107 }
50108 if (!argp2) {
50109 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50110 }
50111 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50112 {
50113 PyThreadState* __tstate = wxPyBeginAllowThreads();
50114 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50115 wxPyEndAllowThreads(__tstate);
50116 if (PyErr_Occurred()) SWIG_fail;
50117 }
50118 {
50119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50120 }
50121 return resultobj;
50122 fail:
50123 return NULL;
50124 }
50125
50126
50127 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50128 PyObject *resultobj = 0;
50129 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50130 wxGBPosition *arg2 = 0 ;
50131 wxGBSpan *arg3 = 0 ;
50132 bool result;
50133 void *argp1 = 0 ;
50134 int res1 = 0 ;
50135 wxGBPosition temp2 ;
50136 wxGBSpan temp3 ;
50137 PyObject * obj0 = 0 ;
50138 PyObject * obj1 = 0 ;
50139 PyObject * obj2 = 0 ;
50140 char * kwnames[] = {
50141 (char *) "self",(char *) "pos",(char *) "span", NULL
50142 };
50143
50144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50146 if (!SWIG_IsOK(res1)) {
50147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50148 }
50149 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50150 {
50151 arg2 = &temp2;
50152 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50153 }
50154 {
50155 arg3 = &temp3;
50156 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50157 }
50158 {
50159 PyThreadState* __tstate = wxPyBeginAllowThreads();
50160 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50161 wxPyEndAllowThreads(__tstate);
50162 if (PyErr_Occurred()) SWIG_fail;
50163 }
50164 {
50165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50166 }
50167 return resultobj;
50168 fail:
50169 return NULL;
50170 }
50171
50172
50173 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50174 PyObject *resultobj = 0;
50175 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50176 wxGBPosition result;
50177 void *argp1 = 0 ;
50178 int res1 = 0 ;
50179 PyObject *swig_obj[1] ;
50180
50181 if (!args) SWIG_fail;
50182 swig_obj[0] = args;
50183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50184 if (!SWIG_IsOK(res1)) {
50185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50186 }
50187 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50188 {
50189 PyThreadState* __tstate = wxPyBeginAllowThreads();
50190 result = wxGBSizerItem_GetEndPos(arg1);
50191 wxPyEndAllowThreads(__tstate);
50192 if (PyErr_Occurred()) SWIG_fail;
50193 }
50194 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50195 return resultobj;
50196 fail:
50197 return NULL;
50198 }
50199
50200
50201 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50202 PyObject *resultobj = 0;
50203 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50204 wxGridBagSizer *result = 0 ;
50205 void *argp1 = 0 ;
50206 int res1 = 0 ;
50207 PyObject *swig_obj[1] ;
50208
50209 if (!args) SWIG_fail;
50210 swig_obj[0] = args;
50211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50212 if (!SWIG_IsOK(res1)) {
50213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50214 }
50215 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50216 {
50217 PyThreadState* __tstate = wxPyBeginAllowThreads();
50218 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50219 wxPyEndAllowThreads(__tstate);
50220 if (PyErr_Occurred()) SWIG_fail;
50221 }
50222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50223 return resultobj;
50224 fail:
50225 return NULL;
50226 }
50227
50228
50229 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50230 PyObject *resultobj = 0;
50231 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50232 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50233 void *argp1 = 0 ;
50234 int res1 = 0 ;
50235 void *argp2 = 0 ;
50236 int res2 = 0 ;
50237 PyObject * obj0 = 0 ;
50238 PyObject * obj1 = 0 ;
50239 char * kwnames[] = {
50240 (char *) "self",(char *) "sizer", NULL
50241 };
50242
50243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50245 if (!SWIG_IsOK(res1)) {
50246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50247 }
50248 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50249 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50250 if (!SWIG_IsOK(res2)) {
50251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50252 }
50253 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50254 {
50255 PyThreadState* __tstate = wxPyBeginAllowThreads();
50256 (arg1)->SetGBSizer(arg2);
50257 wxPyEndAllowThreads(__tstate);
50258 if (PyErr_Occurred()) SWIG_fail;
50259 }
50260 resultobj = SWIG_Py_Void();
50261 return resultobj;
50262 fail:
50263 return NULL;
50264 }
50265
50266
50267 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50268 PyObject *obj;
50269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50270 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50271 return SWIG_Py_Void();
50272 }
50273
50274 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50275 return SWIG_Python_InitShadowInstance(args);
50276 }
50277
50278 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50279 PyObject *resultobj = 0;
50280 int arg1 = (int) 0 ;
50281 int arg2 = (int) 0 ;
50282 wxGridBagSizer *result = 0 ;
50283 int val1 ;
50284 int ecode1 = 0 ;
50285 int val2 ;
50286 int ecode2 = 0 ;
50287 PyObject * obj0 = 0 ;
50288 PyObject * obj1 = 0 ;
50289 char * kwnames[] = {
50290 (char *) "vgap",(char *) "hgap", NULL
50291 };
50292
50293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50294 if (obj0) {
50295 ecode1 = SWIG_AsVal_int(obj0, &val1);
50296 if (!SWIG_IsOK(ecode1)) {
50297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50298 }
50299 arg1 = static_cast< int >(val1);
50300 }
50301 if (obj1) {
50302 ecode2 = SWIG_AsVal_int(obj1, &val2);
50303 if (!SWIG_IsOK(ecode2)) {
50304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50305 }
50306 arg2 = static_cast< int >(val2);
50307 }
50308 {
50309 PyThreadState* __tstate = wxPyBeginAllowThreads();
50310 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50311 wxPyEndAllowThreads(__tstate);
50312 if (PyErr_Occurred()) SWIG_fail;
50313 }
50314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50315 return resultobj;
50316 fail:
50317 return NULL;
50318 }
50319
50320
50321 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50322 PyObject *resultobj = 0;
50323 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50324 PyObject *arg2 = (PyObject *) 0 ;
50325 wxGBPosition *arg3 = 0 ;
50326 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50327 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50328 int arg5 = (int) 0 ;
50329 int arg6 = (int) 0 ;
50330 PyObject *arg7 = (PyObject *) NULL ;
50331 wxGBSizerItem *result = 0 ;
50332 void *argp1 = 0 ;
50333 int res1 = 0 ;
50334 wxGBPosition temp3 ;
50335 wxGBSpan temp4 ;
50336 int val5 ;
50337 int ecode5 = 0 ;
50338 int val6 ;
50339 int ecode6 = 0 ;
50340 PyObject * obj0 = 0 ;
50341 PyObject * obj1 = 0 ;
50342 PyObject * obj2 = 0 ;
50343 PyObject * obj3 = 0 ;
50344 PyObject * obj4 = 0 ;
50345 PyObject * obj5 = 0 ;
50346 PyObject * obj6 = 0 ;
50347 char * kwnames[] = {
50348 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50349 };
50350
50351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50353 if (!SWIG_IsOK(res1)) {
50354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50355 }
50356 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50357 arg2 = obj1;
50358 {
50359 arg3 = &temp3;
50360 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50361 }
50362 if (obj3) {
50363 {
50364 arg4 = &temp4;
50365 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50366 }
50367 }
50368 if (obj4) {
50369 ecode5 = SWIG_AsVal_int(obj4, &val5);
50370 if (!SWIG_IsOK(ecode5)) {
50371 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50372 }
50373 arg5 = static_cast< int >(val5);
50374 }
50375 if (obj5) {
50376 ecode6 = SWIG_AsVal_int(obj5, &val6);
50377 if (!SWIG_IsOK(ecode6)) {
50378 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50379 }
50380 arg6 = static_cast< int >(val6);
50381 }
50382 if (obj6) {
50383 arg7 = obj6;
50384 }
50385 {
50386 PyThreadState* __tstate = wxPyBeginAllowThreads();
50387 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50388 wxPyEndAllowThreads(__tstate);
50389 if (PyErr_Occurred()) SWIG_fail;
50390 }
50391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50392 return resultobj;
50393 fail:
50394 return NULL;
50395 }
50396
50397
50398 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50399 PyObject *resultobj = 0;
50400 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50401 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50402 wxGBSizerItem *result = 0 ;
50403 void *argp1 = 0 ;
50404 int res1 = 0 ;
50405 int res2 = 0 ;
50406 PyObject * obj0 = 0 ;
50407 PyObject * obj1 = 0 ;
50408 char * kwnames[] = {
50409 (char *) "self",(char *) "item", NULL
50410 };
50411
50412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50414 if (!SWIG_IsOK(res1)) {
50415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50416 }
50417 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50418 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50419 if (!SWIG_IsOK(res2)) {
50420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50421 }
50422 {
50423 PyThreadState* __tstate = wxPyBeginAllowThreads();
50424 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50425 wxPyEndAllowThreads(__tstate);
50426 if (PyErr_Occurred()) SWIG_fail;
50427 }
50428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50429 return resultobj;
50430 fail:
50431 return NULL;
50432 }
50433
50434
50435 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50436 PyObject *resultobj = 0;
50437 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50438 int arg2 ;
50439 int arg3 ;
50440 wxSize result;
50441 void *argp1 = 0 ;
50442 int res1 = 0 ;
50443 int val2 ;
50444 int ecode2 = 0 ;
50445 int val3 ;
50446 int ecode3 = 0 ;
50447 PyObject * obj0 = 0 ;
50448 PyObject * obj1 = 0 ;
50449 PyObject * obj2 = 0 ;
50450 char * kwnames[] = {
50451 (char *) "self",(char *) "row",(char *) "col", NULL
50452 };
50453
50454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50456 if (!SWIG_IsOK(res1)) {
50457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50458 }
50459 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50460 ecode2 = SWIG_AsVal_int(obj1, &val2);
50461 if (!SWIG_IsOK(ecode2)) {
50462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50463 }
50464 arg2 = static_cast< int >(val2);
50465 ecode3 = SWIG_AsVal_int(obj2, &val3);
50466 if (!SWIG_IsOK(ecode3)) {
50467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50468 }
50469 arg3 = static_cast< int >(val3);
50470 {
50471 PyThreadState* __tstate = wxPyBeginAllowThreads();
50472 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50473 wxPyEndAllowThreads(__tstate);
50474 if (PyErr_Occurred()) SWIG_fail;
50475 }
50476 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50477 return resultobj;
50478 fail:
50479 return NULL;
50480 }
50481
50482
50483 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50484 PyObject *resultobj = 0;
50485 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50486 wxSize result;
50487 void *argp1 = 0 ;
50488 int res1 = 0 ;
50489 PyObject *swig_obj[1] ;
50490
50491 if (!args) SWIG_fail;
50492 swig_obj[0] = args;
50493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50494 if (!SWIG_IsOK(res1)) {
50495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50496 }
50497 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50498 {
50499 PyThreadState* __tstate = wxPyBeginAllowThreads();
50500 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50501 wxPyEndAllowThreads(__tstate);
50502 if (PyErr_Occurred()) SWIG_fail;
50503 }
50504 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50505 return resultobj;
50506 fail:
50507 return NULL;
50508 }
50509
50510
50511 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50512 PyObject *resultobj = 0;
50513 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50514 wxSize *arg2 = 0 ;
50515 void *argp1 = 0 ;
50516 int res1 = 0 ;
50517 wxSize temp2 ;
50518 PyObject * obj0 = 0 ;
50519 PyObject * obj1 = 0 ;
50520 char * kwnames[] = {
50521 (char *) "self",(char *) "sz", NULL
50522 };
50523
50524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50526 if (!SWIG_IsOK(res1)) {
50527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50528 }
50529 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50530 {
50531 arg2 = &temp2;
50532 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50533 }
50534 {
50535 PyThreadState* __tstate = wxPyBeginAllowThreads();
50536 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50537 wxPyEndAllowThreads(__tstate);
50538 if (PyErr_Occurred()) SWIG_fail;
50539 }
50540 resultobj = SWIG_Py_Void();
50541 return resultobj;
50542 fail:
50543 return NULL;
50544 }
50545
50546
50547 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50548 PyObject *resultobj = 0;
50549 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50550 wxWindow *arg2 = (wxWindow *) 0 ;
50551 wxGBPosition result;
50552 void *argp1 = 0 ;
50553 int res1 = 0 ;
50554 void *argp2 = 0 ;
50555 int res2 = 0 ;
50556
50557 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50559 if (!SWIG_IsOK(res1)) {
50560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50561 }
50562 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50563 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50564 if (!SWIG_IsOK(res2)) {
50565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50566 }
50567 arg2 = reinterpret_cast< wxWindow * >(argp2);
50568 {
50569 PyThreadState* __tstate = wxPyBeginAllowThreads();
50570 result = (arg1)->GetItemPosition(arg2);
50571 wxPyEndAllowThreads(__tstate);
50572 if (PyErr_Occurred()) SWIG_fail;
50573 }
50574 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50575 return resultobj;
50576 fail:
50577 return NULL;
50578 }
50579
50580
50581 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50582 PyObject *resultobj = 0;
50583 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50584 wxSizer *arg2 = (wxSizer *) 0 ;
50585 wxGBPosition result;
50586 void *argp1 = 0 ;
50587 int res1 = 0 ;
50588 void *argp2 = 0 ;
50589 int res2 = 0 ;
50590
50591 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50593 if (!SWIG_IsOK(res1)) {
50594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50595 }
50596 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50597 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50598 if (!SWIG_IsOK(res2)) {
50599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50600 }
50601 arg2 = reinterpret_cast< wxSizer * >(argp2);
50602 {
50603 PyThreadState* __tstate = wxPyBeginAllowThreads();
50604 result = (arg1)->GetItemPosition(arg2);
50605 wxPyEndAllowThreads(__tstate);
50606 if (PyErr_Occurred()) SWIG_fail;
50607 }
50608 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50609 return resultobj;
50610 fail:
50611 return NULL;
50612 }
50613
50614
50615 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50616 PyObject *resultobj = 0;
50617 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50618 size_t arg2 ;
50619 wxGBPosition result;
50620 void *argp1 = 0 ;
50621 int res1 = 0 ;
50622 size_t val2 ;
50623 int ecode2 = 0 ;
50624
50625 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50627 if (!SWIG_IsOK(res1)) {
50628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50629 }
50630 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50631 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50632 if (!SWIG_IsOK(ecode2)) {
50633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50634 }
50635 arg2 = static_cast< size_t >(val2);
50636 {
50637 PyThreadState* __tstate = wxPyBeginAllowThreads();
50638 result = (arg1)->GetItemPosition(arg2);
50639 wxPyEndAllowThreads(__tstate);
50640 if (PyErr_Occurred()) SWIG_fail;
50641 }
50642 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50643 return resultobj;
50644 fail:
50645 return NULL;
50646 }
50647
50648
50649 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50650 int argc;
50651 PyObject *argv[3];
50652
50653 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50654 --argc;
50655 if (argc == 2) {
50656 int _v = 0;
50657 {
50658 void *vptr = 0;
50659 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50660 _v = SWIG_CheckState(res);
50661 }
50662 if (!_v) goto check_1;
50663 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50664 }
50665 check_1:
50666
50667 if (argc == 2) {
50668 int _v = 0;
50669 {
50670 void *vptr = 0;
50671 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50672 _v = SWIG_CheckState(res);
50673 }
50674 if (!_v) goto check_2;
50675 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50676 }
50677 check_2:
50678
50679 if (argc == 2) {
50680 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50681 }
50682
50683 fail:
50684 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50685 return NULL;
50686 }
50687
50688
50689 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50690 PyObject *resultobj = 0;
50691 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50692 wxWindow *arg2 = (wxWindow *) 0 ;
50693 wxGBPosition *arg3 = 0 ;
50694 bool result;
50695 void *argp1 = 0 ;
50696 int res1 = 0 ;
50697 void *argp2 = 0 ;
50698 int res2 = 0 ;
50699 wxGBPosition temp3 ;
50700
50701 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50703 if (!SWIG_IsOK(res1)) {
50704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50705 }
50706 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50707 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50708 if (!SWIG_IsOK(res2)) {
50709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50710 }
50711 arg2 = reinterpret_cast< wxWindow * >(argp2);
50712 {
50713 arg3 = &temp3;
50714 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50715 }
50716 {
50717 PyThreadState* __tstate = wxPyBeginAllowThreads();
50718 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50719 wxPyEndAllowThreads(__tstate);
50720 if (PyErr_Occurred()) SWIG_fail;
50721 }
50722 {
50723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50724 }
50725 return resultobj;
50726 fail:
50727 return NULL;
50728 }
50729
50730
50731 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50732 PyObject *resultobj = 0;
50733 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50734 wxSizer *arg2 = (wxSizer *) 0 ;
50735 wxGBPosition *arg3 = 0 ;
50736 bool result;
50737 void *argp1 = 0 ;
50738 int res1 = 0 ;
50739 void *argp2 = 0 ;
50740 int res2 = 0 ;
50741 wxGBPosition temp3 ;
50742
50743 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50745 if (!SWIG_IsOK(res1)) {
50746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50747 }
50748 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50749 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50750 if (!SWIG_IsOK(res2)) {
50751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50752 }
50753 arg2 = reinterpret_cast< wxSizer * >(argp2);
50754 {
50755 arg3 = &temp3;
50756 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50757 }
50758 {
50759 PyThreadState* __tstate = wxPyBeginAllowThreads();
50760 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50761 wxPyEndAllowThreads(__tstate);
50762 if (PyErr_Occurred()) SWIG_fail;
50763 }
50764 {
50765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50766 }
50767 return resultobj;
50768 fail:
50769 return NULL;
50770 }
50771
50772
50773 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50774 PyObject *resultobj = 0;
50775 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50776 size_t arg2 ;
50777 wxGBPosition *arg3 = 0 ;
50778 bool result;
50779 void *argp1 = 0 ;
50780 int res1 = 0 ;
50781 size_t val2 ;
50782 int ecode2 = 0 ;
50783 wxGBPosition temp3 ;
50784
50785 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50787 if (!SWIG_IsOK(res1)) {
50788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50789 }
50790 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50791 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50792 if (!SWIG_IsOK(ecode2)) {
50793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50794 }
50795 arg2 = static_cast< size_t >(val2);
50796 {
50797 arg3 = &temp3;
50798 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50799 }
50800 {
50801 PyThreadState* __tstate = wxPyBeginAllowThreads();
50802 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50803 wxPyEndAllowThreads(__tstate);
50804 if (PyErr_Occurred()) SWIG_fail;
50805 }
50806 {
50807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50808 }
50809 return resultobj;
50810 fail:
50811 return NULL;
50812 }
50813
50814
50815 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50816 int argc;
50817 PyObject *argv[4];
50818
50819 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50820 --argc;
50821 if (argc == 3) {
50822 int _v = 0;
50823 {
50824 void *vptr = 0;
50825 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50826 _v = SWIG_CheckState(res);
50827 }
50828 if (!_v) goto check_1;
50829 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50830 }
50831 check_1:
50832
50833 if (argc == 3) {
50834 int _v = 0;
50835 {
50836 void *vptr = 0;
50837 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50838 _v = SWIG_CheckState(res);
50839 }
50840 if (!_v) goto check_2;
50841 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50842 }
50843 check_2:
50844
50845 if (argc == 3) {
50846 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50847 }
50848
50849 fail:
50850 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50851 return NULL;
50852 }
50853
50854
50855 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50856 PyObject *resultobj = 0;
50857 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50858 wxWindow *arg2 = (wxWindow *) 0 ;
50859 wxGBSpan result;
50860 void *argp1 = 0 ;
50861 int res1 = 0 ;
50862 void *argp2 = 0 ;
50863 int res2 = 0 ;
50864
50865 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50867 if (!SWIG_IsOK(res1)) {
50868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50869 }
50870 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50871 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50872 if (!SWIG_IsOK(res2)) {
50873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50874 }
50875 arg2 = reinterpret_cast< wxWindow * >(argp2);
50876 {
50877 PyThreadState* __tstate = wxPyBeginAllowThreads();
50878 result = (arg1)->GetItemSpan(arg2);
50879 wxPyEndAllowThreads(__tstate);
50880 if (PyErr_Occurred()) SWIG_fail;
50881 }
50882 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50883 return resultobj;
50884 fail:
50885 return NULL;
50886 }
50887
50888
50889 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50890 PyObject *resultobj = 0;
50891 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50892 wxSizer *arg2 = (wxSizer *) 0 ;
50893 wxGBSpan result;
50894 void *argp1 = 0 ;
50895 int res1 = 0 ;
50896 void *argp2 = 0 ;
50897 int res2 = 0 ;
50898
50899 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50901 if (!SWIG_IsOK(res1)) {
50902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50903 }
50904 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50905 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50906 if (!SWIG_IsOK(res2)) {
50907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50908 }
50909 arg2 = reinterpret_cast< wxSizer * >(argp2);
50910 {
50911 PyThreadState* __tstate = wxPyBeginAllowThreads();
50912 result = (arg1)->GetItemSpan(arg2);
50913 wxPyEndAllowThreads(__tstate);
50914 if (PyErr_Occurred()) SWIG_fail;
50915 }
50916 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50917 return resultobj;
50918 fail:
50919 return NULL;
50920 }
50921
50922
50923 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50924 PyObject *resultobj = 0;
50925 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50926 size_t arg2 ;
50927 wxGBSpan result;
50928 void *argp1 = 0 ;
50929 int res1 = 0 ;
50930 size_t val2 ;
50931 int ecode2 = 0 ;
50932
50933 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50935 if (!SWIG_IsOK(res1)) {
50936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50937 }
50938 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50939 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50940 if (!SWIG_IsOK(ecode2)) {
50941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50942 }
50943 arg2 = static_cast< size_t >(val2);
50944 {
50945 PyThreadState* __tstate = wxPyBeginAllowThreads();
50946 result = (arg1)->GetItemSpan(arg2);
50947 wxPyEndAllowThreads(__tstate);
50948 if (PyErr_Occurred()) SWIG_fail;
50949 }
50950 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50951 return resultobj;
50952 fail:
50953 return NULL;
50954 }
50955
50956
50957 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50958 int argc;
50959 PyObject *argv[3];
50960
50961 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50962 --argc;
50963 if (argc == 2) {
50964 int _v = 0;
50965 {
50966 void *vptr = 0;
50967 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50968 _v = SWIG_CheckState(res);
50969 }
50970 if (!_v) goto check_1;
50971 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50972 }
50973 check_1:
50974
50975 if (argc == 2) {
50976 int _v = 0;
50977 {
50978 void *vptr = 0;
50979 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50980 _v = SWIG_CheckState(res);
50981 }
50982 if (!_v) goto check_2;
50983 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50984 }
50985 check_2:
50986
50987 if (argc == 2) {
50988 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50989 }
50990
50991 fail:
50992 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50993 return NULL;
50994 }
50995
50996
50997 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50998 PyObject *resultobj = 0;
50999 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51000 wxWindow *arg2 = (wxWindow *) 0 ;
51001 wxGBSpan *arg3 = 0 ;
51002 bool result;
51003 void *argp1 = 0 ;
51004 int res1 = 0 ;
51005 void *argp2 = 0 ;
51006 int res2 = 0 ;
51007 wxGBSpan temp3 ;
51008
51009 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51011 if (!SWIG_IsOK(res1)) {
51012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51013 }
51014 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51015 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51016 if (!SWIG_IsOK(res2)) {
51017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51018 }
51019 arg2 = reinterpret_cast< wxWindow * >(argp2);
51020 {
51021 arg3 = &temp3;
51022 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51023 }
51024 {
51025 PyThreadState* __tstate = wxPyBeginAllowThreads();
51026 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51027 wxPyEndAllowThreads(__tstate);
51028 if (PyErr_Occurred()) SWIG_fail;
51029 }
51030 {
51031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51032 }
51033 return resultobj;
51034 fail:
51035 return NULL;
51036 }
51037
51038
51039 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51040 PyObject *resultobj = 0;
51041 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51042 wxSizer *arg2 = (wxSizer *) 0 ;
51043 wxGBSpan *arg3 = 0 ;
51044 bool result;
51045 void *argp1 = 0 ;
51046 int res1 = 0 ;
51047 void *argp2 = 0 ;
51048 int res2 = 0 ;
51049 wxGBSpan temp3 ;
51050
51051 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51053 if (!SWIG_IsOK(res1)) {
51054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51055 }
51056 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51057 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51058 if (!SWIG_IsOK(res2)) {
51059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51060 }
51061 arg2 = reinterpret_cast< wxSizer * >(argp2);
51062 {
51063 arg3 = &temp3;
51064 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51065 }
51066 {
51067 PyThreadState* __tstate = wxPyBeginAllowThreads();
51068 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51069 wxPyEndAllowThreads(__tstate);
51070 if (PyErr_Occurred()) SWIG_fail;
51071 }
51072 {
51073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51074 }
51075 return resultobj;
51076 fail:
51077 return NULL;
51078 }
51079
51080
51081 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51082 PyObject *resultobj = 0;
51083 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51084 size_t arg2 ;
51085 wxGBSpan *arg3 = 0 ;
51086 bool result;
51087 void *argp1 = 0 ;
51088 int res1 = 0 ;
51089 size_t val2 ;
51090 int ecode2 = 0 ;
51091 wxGBSpan temp3 ;
51092
51093 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51095 if (!SWIG_IsOK(res1)) {
51096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51097 }
51098 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51099 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51100 if (!SWIG_IsOK(ecode2)) {
51101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51102 }
51103 arg2 = static_cast< size_t >(val2);
51104 {
51105 arg3 = &temp3;
51106 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51107 }
51108 {
51109 PyThreadState* __tstate = wxPyBeginAllowThreads();
51110 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51111 wxPyEndAllowThreads(__tstate);
51112 if (PyErr_Occurred()) SWIG_fail;
51113 }
51114 {
51115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51116 }
51117 return resultobj;
51118 fail:
51119 return NULL;
51120 }
51121
51122
51123 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51124 int argc;
51125 PyObject *argv[4];
51126
51127 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51128 --argc;
51129 if (argc == 3) {
51130 int _v = 0;
51131 {
51132 void *vptr = 0;
51133 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51134 _v = SWIG_CheckState(res);
51135 }
51136 if (!_v) goto check_1;
51137 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51138 }
51139 check_1:
51140
51141 if (argc == 3) {
51142 int _v = 0;
51143 {
51144 void *vptr = 0;
51145 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51146 _v = SWIG_CheckState(res);
51147 }
51148 if (!_v) goto check_2;
51149 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51150 }
51151 check_2:
51152
51153 if (argc == 3) {
51154 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51155 }
51156
51157 fail:
51158 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51159 return NULL;
51160 }
51161
51162
51163 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51164 PyObject *resultobj = 0;
51165 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51166 wxWindow *arg2 = (wxWindow *) 0 ;
51167 wxGBSizerItem *result = 0 ;
51168 void *argp1 = 0 ;
51169 int res1 = 0 ;
51170 void *argp2 = 0 ;
51171 int res2 = 0 ;
51172
51173 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51175 if (!SWIG_IsOK(res1)) {
51176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51177 }
51178 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51179 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51180 if (!SWIG_IsOK(res2)) {
51181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51182 }
51183 arg2 = reinterpret_cast< wxWindow * >(argp2);
51184 {
51185 PyThreadState* __tstate = wxPyBeginAllowThreads();
51186 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51187 wxPyEndAllowThreads(__tstate);
51188 if (PyErr_Occurred()) SWIG_fail;
51189 }
51190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51191 return resultobj;
51192 fail:
51193 return NULL;
51194 }
51195
51196
51197 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51198 PyObject *resultobj = 0;
51199 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51200 wxSizer *arg2 = (wxSizer *) 0 ;
51201 wxGBSizerItem *result = 0 ;
51202 void *argp1 = 0 ;
51203 int res1 = 0 ;
51204 void *argp2 = 0 ;
51205 int res2 = 0 ;
51206
51207 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51209 if (!SWIG_IsOK(res1)) {
51210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51211 }
51212 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51213 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51214 if (!SWIG_IsOK(res2)) {
51215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51216 }
51217 arg2 = reinterpret_cast< wxSizer * >(argp2);
51218 {
51219 PyThreadState* __tstate = wxPyBeginAllowThreads();
51220 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51221 wxPyEndAllowThreads(__tstate);
51222 if (PyErr_Occurred()) SWIG_fail;
51223 }
51224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51225 return resultobj;
51226 fail:
51227 return NULL;
51228 }
51229
51230
51231 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51232 int argc;
51233 PyObject *argv[3];
51234
51235 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51236 --argc;
51237 if (argc == 2) {
51238 int _v = 0;
51239 {
51240 void *vptr = 0;
51241 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51242 _v = SWIG_CheckState(res);
51243 }
51244 if (!_v) goto check_1;
51245 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51246 }
51247 check_1:
51248
51249 if (argc == 2) {
51250 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51251 }
51252
51253 fail:
51254 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51255 return NULL;
51256 }
51257
51258
51259 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51260 PyObject *resultobj = 0;
51261 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51262 wxGBPosition *arg2 = 0 ;
51263 wxGBSizerItem *result = 0 ;
51264 void *argp1 = 0 ;
51265 int res1 = 0 ;
51266 wxGBPosition temp2 ;
51267 PyObject * obj0 = 0 ;
51268 PyObject * obj1 = 0 ;
51269 char * kwnames[] = {
51270 (char *) "self",(char *) "pos", NULL
51271 };
51272
51273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51275 if (!SWIG_IsOK(res1)) {
51276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51277 }
51278 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51279 {
51280 arg2 = &temp2;
51281 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51282 }
51283 {
51284 PyThreadState* __tstate = wxPyBeginAllowThreads();
51285 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51286 wxPyEndAllowThreads(__tstate);
51287 if (PyErr_Occurred()) SWIG_fail;
51288 }
51289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51290 return resultobj;
51291 fail:
51292 return NULL;
51293 }
51294
51295
51296 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51297 PyObject *resultobj = 0;
51298 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51299 wxPoint *arg2 = 0 ;
51300 wxGBSizerItem *result = 0 ;
51301 void *argp1 = 0 ;
51302 int res1 = 0 ;
51303 wxPoint temp2 ;
51304 PyObject * obj0 = 0 ;
51305 PyObject * obj1 = 0 ;
51306 char * kwnames[] = {
51307 (char *) "self",(char *) "pt", NULL
51308 };
51309
51310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51312 if (!SWIG_IsOK(res1)) {
51313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51314 }
51315 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51316 {
51317 arg2 = &temp2;
51318 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51319 }
51320 {
51321 PyThreadState* __tstate = wxPyBeginAllowThreads();
51322 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51323 wxPyEndAllowThreads(__tstate);
51324 if (PyErr_Occurred()) SWIG_fail;
51325 }
51326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51327 return resultobj;
51328 fail:
51329 return NULL;
51330 }
51331
51332
51333 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51334 PyObject *resultobj = 0;
51335 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51336 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51337 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51338 bool result;
51339 void *argp1 = 0 ;
51340 int res1 = 0 ;
51341 void *argp2 = 0 ;
51342 int res2 = 0 ;
51343 void *argp3 = 0 ;
51344 int res3 = 0 ;
51345 PyObject * obj0 = 0 ;
51346 PyObject * obj1 = 0 ;
51347 PyObject * obj2 = 0 ;
51348 char * kwnames[] = {
51349 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51350 };
51351
51352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51354 if (!SWIG_IsOK(res1)) {
51355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51356 }
51357 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51358 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51359 if (!SWIG_IsOK(res2)) {
51360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51361 }
51362 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51363 if (obj2) {
51364 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51365 if (!SWIG_IsOK(res3)) {
51366 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51367 }
51368 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51369 }
51370 {
51371 PyThreadState* __tstate = wxPyBeginAllowThreads();
51372 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51373 wxPyEndAllowThreads(__tstate);
51374 if (PyErr_Occurred()) SWIG_fail;
51375 }
51376 {
51377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51378 }
51379 return resultobj;
51380 fail:
51381 return NULL;
51382 }
51383
51384
51385 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51386 PyObject *resultobj = 0;
51387 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51388 wxGBPosition *arg2 = 0 ;
51389 wxGBSpan *arg3 = 0 ;
51390 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51391 bool result;
51392 void *argp1 = 0 ;
51393 int res1 = 0 ;
51394 wxGBPosition temp2 ;
51395 wxGBSpan temp3 ;
51396 void *argp4 = 0 ;
51397 int res4 = 0 ;
51398 PyObject * obj0 = 0 ;
51399 PyObject * obj1 = 0 ;
51400 PyObject * obj2 = 0 ;
51401 PyObject * obj3 = 0 ;
51402 char * kwnames[] = {
51403 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51404 };
51405
51406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51408 if (!SWIG_IsOK(res1)) {
51409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51410 }
51411 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51412 {
51413 arg2 = &temp2;
51414 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51415 }
51416 {
51417 arg3 = &temp3;
51418 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51419 }
51420 if (obj3) {
51421 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51422 if (!SWIG_IsOK(res4)) {
51423 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51424 }
51425 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51426 }
51427 {
51428 PyThreadState* __tstate = wxPyBeginAllowThreads();
51429 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51430 wxPyEndAllowThreads(__tstate);
51431 if (PyErr_Occurred()) SWIG_fail;
51432 }
51433 {
51434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51435 }
51436 return resultobj;
51437 fail:
51438 return NULL;
51439 }
51440
51441
51442 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51443 PyObject *obj;
51444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51445 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51446 return SWIG_Py_Void();
51447 }
51448
51449 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51450 return SWIG_Python_InitShadowInstance(args);
51451 }
51452
51453 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51454 PyObject *resultobj = 0;
51455 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51456 wxRelationship arg2 ;
51457 wxWindow *arg3 = (wxWindow *) 0 ;
51458 wxEdge arg4 ;
51459 int arg5 = (int) 0 ;
51460 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51461 void *argp1 = 0 ;
51462 int res1 = 0 ;
51463 int val2 ;
51464 int ecode2 = 0 ;
51465 void *argp3 = 0 ;
51466 int res3 = 0 ;
51467 int val4 ;
51468 int ecode4 = 0 ;
51469 int val5 ;
51470 int ecode5 = 0 ;
51471 int val6 ;
51472 int ecode6 = 0 ;
51473 PyObject * obj0 = 0 ;
51474 PyObject * obj1 = 0 ;
51475 PyObject * obj2 = 0 ;
51476 PyObject * obj3 = 0 ;
51477 PyObject * obj4 = 0 ;
51478 PyObject * obj5 = 0 ;
51479 char * kwnames[] = {
51480 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51481 };
51482
51483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51485 if (!SWIG_IsOK(res1)) {
51486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51487 }
51488 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51489 ecode2 = SWIG_AsVal_int(obj1, &val2);
51490 if (!SWIG_IsOK(ecode2)) {
51491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51492 }
51493 arg2 = static_cast< wxRelationship >(val2);
51494 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51495 if (!SWIG_IsOK(res3)) {
51496 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51497 }
51498 arg3 = reinterpret_cast< wxWindow * >(argp3);
51499 ecode4 = SWIG_AsVal_int(obj3, &val4);
51500 if (!SWIG_IsOK(ecode4)) {
51501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51502 }
51503 arg4 = static_cast< wxEdge >(val4);
51504 if (obj4) {
51505 ecode5 = SWIG_AsVal_int(obj4, &val5);
51506 if (!SWIG_IsOK(ecode5)) {
51507 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51508 }
51509 arg5 = static_cast< int >(val5);
51510 }
51511 if (obj5) {
51512 ecode6 = SWIG_AsVal_int(obj5, &val6);
51513 if (!SWIG_IsOK(ecode6)) {
51514 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51515 }
51516 arg6 = static_cast< int >(val6);
51517 }
51518 {
51519 PyThreadState* __tstate = wxPyBeginAllowThreads();
51520 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51521 wxPyEndAllowThreads(__tstate);
51522 if (PyErr_Occurred()) SWIG_fail;
51523 }
51524 resultobj = SWIG_Py_Void();
51525 return resultobj;
51526 fail:
51527 return NULL;
51528 }
51529
51530
51531 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51532 PyObject *resultobj = 0;
51533 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51534 wxWindow *arg2 = (wxWindow *) 0 ;
51535 int arg3 = (int) 0 ;
51536 void *argp1 = 0 ;
51537 int res1 = 0 ;
51538 void *argp2 = 0 ;
51539 int res2 = 0 ;
51540 int val3 ;
51541 int ecode3 = 0 ;
51542 PyObject * obj0 = 0 ;
51543 PyObject * obj1 = 0 ;
51544 PyObject * obj2 = 0 ;
51545 char * kwnames[] = {
51546 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51547 };
51548
51549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51551 if (!SWIG_IsOK(res1)) {
51552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51553 }
51554 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51555 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51556 if (!SWIG_IsOK(res2)) {
51557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51558 }
51559 arg2 = reinterpret_cast< wxWindow * >(argp2);
51560 if (obj2) {
51561 ecode3 = SWIG_AsVal_int(obj2, &val3);
51562 if (!SWIG_IsOK(ecode3)) {
51563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51564 }
51565 arg3 = static_cast< int >(val3);
51566 }
51567 {
51568 PyThreadState* __tstate = wxPyBeginAllowThreads();
51569 (arg1)->LeftOf(arg2,arg3);
51570 wxPyEndAllowThreads(__tstate);
51571 if (PyErr_Occurred()) SWIG_fail;
51572 }
51573 resultobj = SWIG_Py_Void();
51574 return resultobj;
51575 fail:
51576 return NULL;
51577 }
51578
51579
51580 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51581 PyObject *resultobj = 0;
51582 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51583 wxWindow *arg2 = (wxWindow *) 0 ;
51584 int arg3 = (int) 0 ;
51585 void *argp1 = 0 ;
51586 int res1 = 0 ;
51587 void *argp2 = 0 ;
51588 int res2 = 0 ;
51589 int val3 ;
51590 int ecode3 = 0 ;
51591 PyObject * obj0 = 0 ;
51592 PyObject * obj1 = 0 ;
51593 PyObject * obj2 = 0 ;
51594 char * kwnames[] = {
51595 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51596 };
51597
51598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51600 if (!SWIG_IsOK(res1)) {
51601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51602 }
51603 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51604 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51605 if (!SWIG_IsOK(res2)) {
51606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51607 }
51608 arg2 = reinterpret_cast< wxWindow * >(argp2);
51609 if (obj2) {
51610 ecode3 = SWIG_AsVal_int(obj2, &val3);
51611 if (!SWIG_IsOK(ecode3)) {
51612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51613 }
51614 arg3 = static_cast< int >(val3);
51615 }
51616 {
51617 PyThreadState* __tstate = wxPyBeginAllowThreads();
51618 (arg1)->RightOf(arg2,arg3);
51619 wxPyEndAllowThreads(__tstate);
51620 if (PyErr_Occurred()) SWIG_fail;
51621 }
51622 resultobj = SWIG_Py_Void();
51623 return resultobj;
51624 fail:
51625 return NULL;
51626 }
51627
51628
51629 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51630 PyObject *resultobj = 0;
51631 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51632 wxWindow *arg2 = (wxWindow *) 0 ;
51633 int arg3 = (int) 0 ;
51634 void *argp1 = 0 ;
51635 int res1 = 0 ;
51636 void *argp2 = 0 ;
51637 int res2 = 0 ;
51638 int val3 ;
51639 int ecode3 = 0 ;
51640 PyObject * obj0 = 0 ;
51641 PyObject * obj1 = 0 ;
51642 PyObject * obj2 = 0 ;
51643 char * kwnames[] = {
51644 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51645 };
51646
51647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51649 if (!SWIG_IsOK(res1)) {
51650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51651 }
51652 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51654 if (!SWIG_IsOK(res2)) {
51655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51656 }
51657 arg2 = reinterpret_cast< wxWindow * >(argp2);
51658 if (obj2) {
51659 ecode3 = SWIG_AsVal_int(obj2, &val3);
51660 if (!SWIG_IsOK(ecode3)) {
51661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51662 }
51663 arg3 = static_cast< int >(val3);
51664 }
51665 {
51666 PyThreadState* __tstate = wxPyBeginAllowThreads();
51667 (arg1)->Above(arg2,arg3);
51668 wxPyEndAllowThreads(__tstate);
51669 if (PyErr_Occurred()) SWIG_fail;
51670 }
51671 resultobj = SWIG_Py_Void();
51672 return resultobj;
51673 fail:
51674 return NULL;
51675 }
51676
51677
51678 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51679 PyObject *resultobj = 0;
51680 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51681 wxWindow *arg2 = (wxWindow *) 0 ;
51682 int arg3 = (int) 0 ;
51683 void *argp1 = 0 ;
51684 int res1 = 0 ;
51685 void *argp2 = 0 ;
51686 int res2 = 0 ;
51687 int val3 ;
51688 int ecode3 = 0 ;
51689 PyObject * obj0 = 0 ;
51690 PyObject * obj1 = 0 ;
51691 PyObject * obj2 = 0 ;
51692 char * kwnames[] = {
51693 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51694 };
51695
51696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51698 if (!SWIG_IsOK(res1)) {
51699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51700 }
51701 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51703 if (!SWIG_IsOK(res2)) {
51704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51705 }
51706 arg2 = reinterpret_cast< wxWindow * >(argp2);
51707 if (obj2) {
51708 ecode3 = SWIG_AsVal_int(obj2, &val3);
51709 if (!SWIG_IsOK(ecode3)) {
51710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51711 }
51712 arg3 = static_cast< int >(val3);
51713 }
51714 {
51715 PyThreadState* __tstate = wxPyBeginAllowThreads();
51716 (arg1)->Below(arg2,arg3);
51717 wxPyEndAllowThreads(__tstate);
51718 if (PyErr_Occurred()) SWIG_fail;
51719 }
51720 resultobj = SWIG_Py_Void();
51721 return resultobj;
51722 fail:
51723 return NULL;
51724 }
51725
51726
51727 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51728 PyObject *resultobj = 0;
51729 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51730 wxWindow *arg2 = (wxWindow *) 0 ;
51731 wxEdge arg3 ;
51732 int arg4 = (int) 0 ;
51733 void *argp1 = 0 ;
51734 int res1 = 0 ;
51735 void *argp2 = 0 ;
51736 int res2 = 0 ;
51737 int val3 ;
51738 int ecode3 = 0 ;
51739 int val4 ;
51740 int ecode4 = 0 ;
51741 PyObject * obj0 = 0 ;
51742 PyObject * obj1 = 0 ;
51743 PyObject * obj2 = 0 ;
51744 PyObject * obj3 = 0 ;
51745 char * kwnames[] = {
51746 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51747 };
51748
51749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51751 if (!SWIG_IsOK(res1)) {
51752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51753 }
51754 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51756 if (!SWIG_IsOK(res2)) {
51757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51758 }
51759 arg2 = reinterpret_cast< wxWindow * >(argp2);
51760 ecode3 = SWIG_AsVal_int(obj2, &val3);
51761 if (!SWIG_IsOK(ecode3)) {
51762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51763 }
51764 arg3 = static_cast< wxEdge >(val3);
51765 if (obj3) {
51766 ecode4 = SWIG_AsVal_int(obj3, &val4);
51767 if (!SWIG_IsOK(ecode4)) {
51768 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51769 }
51770 arg4 = static_cast< int >(val4);
51771 }
51772 {
51773 PyThreadState* __tstate = wxPyBeginAllowThreads();
51774 (arg1)->SameAs(arg2,arg3,arg4);
51775 wxPyEndAllowThreads(__tstate);
51776 if (PyErr_Occurred()) SWIG_fail;
51777 }
51778 resultobj = SWIG_Py_Void();
51779 return resultobj;
51780 fail:
51781 return NULL;
51782 }
51783
51784
51785 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51786 PyObject *resultobj = 0;
51787 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51788 wxWindow *arg2 = (wxWindow *) 0 ;
51789 wxEdge arg3 ;
51790 int arg4 ;
51791 void *argp1 = 0 ;
51792 int res1 = 0 ;
51793 void *argp2 = 0 ;
51794 int res2 = 0 ;
51795 int val3 ;
51796 int ecode3 = 0 ;
51797 int val4 ;
51798 int ecode4 = 0 ;
51799 PyObject * obj0 = 0 ;
51800 PyObject * obj1 = 0 ;
51801 PyObject * obj2 = 0 ;
51802 PyObject * obj3 = 0 ;
51803 char * kwnames[] = {
51804 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51805 };
51806
51807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51809 if (!SWIG_IsOK(res1)) {
51810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51811 }
51812 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51814 if (!SWIG_IsOK(res2)) {
51815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51816 }
51817 arg2 = reinterpret_cast< wxWindow * >(argp2);
51818 ecode3 = SWIG_AsVal_int(obj2, &val3);
51819 if (!SWIG_IsOK(ecode3)) {
51820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51821 }
51822 arg3 = static_cast< wxEdge >(val3);
51823 ecode4 = SWIG_AsVal_int(obj3, &val4);
51824 if (!SWIG_IsOK(ecode4)) {
51825 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51826 }
51827 arg4 = static_cast< int >(val4);
51828 {
51829 PyThreadState* __tstate = wxPyBeginAllowThreads();
51830 (arg1)->PercentOf(arg2,arg3,arg4);
51831 wxPyEndAllowThreads(__tstate);
51832 if (PyErr_Occurred()) SWIG_fail;
51833 }
51834 resultobj = SWIG_Py_Void();
51835 return resultobj;
51836 fail:
51837 return NULL;
51838 }
51839
51840
51841 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51842 PyObject *resultobj = 0;
51843 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51844 int arg2 ;
51845 void *argp1 = 0 ;
51846 int res1 = 0 ;
51847 int val2 ;
51848 int ecode2 = 0 ;
51849 PyObject * obj0 = 0 ;
51850 PyObject * obj1 = 0 ;
51851 char * kwnames[] = {
51852 (char *) "self",(char *) "val", NULL
51853 };
51854
51855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51857 if (!SWIG_IsOK(res1)) {
51858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51859 }
51860 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51861 ecode2 = SWIG_AsVal_int(obj1, &val2);
51862 if (!SWIG_IsOK(ecode2)) {
51863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51864 }
51865 arg2 = static_cast< int >(val2);
51866 {
51867 PyThreadState* __tstate = wxPyBeginAllowThreads();
51868 (arg1)->Absolute(arg2);
51869 wxPyEndAllowThreads(__tstate);
51870 if (PyErr_Occurred()) SWIG_fail;
51871 }
51872 resultobj = SWIG_Py_Void();
51873 return resultobj;
51874 fail:
51875 return NULL;
51876 }
51877
51878
51879 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51880 PyObject *resultobj = 0;
51881 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51882 void *argp1 = 0 ;
51883 int res1 = 0 ;
51884 PyObject *swig_obj[1] ;
51885
51886 if (!args) SWIG_fail;
51887 swig_obj[0] = args;
51888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51889 if (!SWIG_IsOK(res1)) {
51890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51891 }
51892 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51893 {
51894 PyThreadState* __tstate = wxPyBeginAllowThreads();
51895 (arg1)->Unconstrained();
51896 wxPyEndAllowThreads(__tstate);
51897 if (PyErr_Occurred()) SWIG_fail;
51898 }
51899 resultobj = SWIG_Py_Void();
51900 return resultobj;
51901 fail:
51902 return NULL;
51903 }
51904
51905
51906 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51907 PyObject *resultobj = 0;
51908 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51909 void *argp1 = 0 ;
51910 int res1 = 0 ;
51911 PyObject *swig_obj[1] ;
51912
51913 if (!args) SWIG_fail;
51914 swig_obj[0] = args;
51915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51916 if (!SWIG_IsOK(res1)) {
51917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51918 }
51919 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51920 {
51921 PyThreadState* __tstate = wxPyBeginAllowThreads();
51922 (arg1)->AsIs();
51923 wxPyEndAllowThreads(__tstate);
51924 if (PyErr_Occurred()) SWIG_fail;
51925 }
51926 resultobj = SWIG_Py_Void();
51927 return resultobj;
51928 fail:
51929 return NULL;
51930 }
51931
51932
51933 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51934 PyObject *resultobj = 0;
51935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51936 wxWindow *result = 0 ;
51937 void *argp1 = 0 ;
51938 int res1 = 0 ;
51939 PyObject *swig_obj[1] ;
51940
51941 if (!args) SWIG_fail;
51942 swig_obj[0] = args;
51943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51944 if (!SWIG_IsOK(res1)) {
51945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51946 }
51947 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51948 {
51949 PyThreadState* __tstate = wxPyBeginAllowThreads();
51950 result = (wxWindow *)(arg1)->GetOtherWindow();
51951 wxPyEndAllowThreads(__tstate);
51952 if (PyErr_Occurred()) SWIG_fail;
51953 }
51954 {
51955 resultobj = wxPyMake_wxObject(result, 0);
51956 }
51957 return resultobj;
51958 fail:
51959 return NULL;
51960 }
51961
51962
51963 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51964 PyObject *resultobj = 0;
51965 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51966 wxEdge result;
51967 void *argp1 = 0 ;
51968 int res1 = 0 ;
51969 PyObject *swig_obj[1] ;
51970
51971 if (!args) SWIG_fail;
51972 swig_obj[0] = args;
51973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51974 if (!SWIG_IsOK(res1)) {
51975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51976 }
51977 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51978 {
51979 PyThreadState* __tstate = wxPyBeginAllowThreads();
51980 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51981 wxPyEndAllowThreads(__tstate);
51982 if (PyErr_Occurred()) SWIG_fail;
51983 }
51984 resultobj = SWIG_From_int(static_cast< int >(result));
51985 return resultobj;
51986 fail:
51987 return NULL;
51988 }
51989
51990
51991 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51992 PyObject *resultobj = 0;
51993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51994 wxEdge arg2 ;
51995 void *argp1 = 0 ;
51996 int res1 = 0 ;
51997 int val2 ;
51998 int ecode2 = 0 ;
51999 PyObject * obj0 = 0 ;
52000 PyObject * obj1 = 0 ;
52001 char * kwnames[] = {
52002 (char *) "self",(char *) "which", NULL
52003 };
52004
52005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52007 if (!SWIG_IsOK(res1)) {
52008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52009 }
52010 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52011 ecode2 = SWIG_AsVal_int(obj1, &val2);
52012 if (!SWIG_IsOK(ecode2)) {
52013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52014 }
52015 arg2 = static_cast< wxEdge >(val2);
52016 {
52017 PyThreadState* __tstate = wxPyBeginAllowThreads();
52018 (arg1)->SetEdge(arg2);
52019 wxPyEndAllowThreads(__tstate);
52020 if (PyErr_Occurred()) SWIG_fail;
52021 }
52022 resultobj = SWIG_Py_Void();
52023 return resultobj;
52024 fail:
52025 return NULL;
52026 }
52027
52028
52029 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52030 PyObject *resultobj = 0;
52031 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52032 int arg2 ;
52033 void *argp1 = 0 ;
52034 int res1 = 0 ;
52035 int val2 ;
52036 int ecode2 = 0 ;
52037 PyObject * obj0 = 0 ;
52038 PyObject * obj1 = 0 ;
52039 char * kwnames[] = {
52040 (char *) "self",(char *) "v", NULL
52041 };
52042
52043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52045 if (!SWIG_IsOK(res1)) {
52046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52047 }
52048 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52049 ecode2 = SWIG_AsVal_int(obj1, &val2);
52050 if (!SWIG_IsOK(ecode2)) {
52051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52052 }
52053 arg2 = static_cast< int >(val2);
52054 {
52055 PyThreadState* __tstate = wxPyBeginAllowThreads();
52056 (arg1)->SetValue(arg2);
52057 wxPyEndAllowThreads(__tstate);
52058 if (PyErr_Occurred()) SWIG_fail;
52059 }
52060 resultobj = SWIG_Py_Void();
52061 return resultobj;
52062 fail:
52063 return NULL;
52064 }
52065
52066
52067 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52068 PyObject *resultobj = 0;
52069 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52070 int result;
52071 void *argp1 = 0 ;
52072 int res1 = 0 ;
52073 PyObject *swig_obj[1] ;
52074
52075 if (!args) SWIG_fail;
52076 swig_obj[0] = args;
52077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52078 if (!SWIG_IsOK(res1)) {
52079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52080 }
52081 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52082 {
52083 PyThreadState* __tstate = wxPyBeginAllowThreads();
52084 result = (int)(arg1)->GetMargin();
52085 wxPyEndAllowThreads(__tstate);
52086 if (PyErr_Occurred()) SWIG_fail;
52087 }
52088 resultobj = SWIG_From_int(static_cast< int >(result));
52089 return resultobj;
52090 fail:
52091 return NULL;
52092 }
52093
52094
52095 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52096 PyObject *resultobj = 0;
52097 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52098 int arg2 ;
52099 void *argp1 = 0 ;
52100 int res1 = 0 ;
52101 int val2 ;
52102 int ecode2 = 0 ;
52103 PyObject * obj0 = 0 ;
52104 PyObject * obj1 = 0 ;
52105 char * kwnames[] = {
52106 (char *) "self",(char *) "m", NULL
52107 };
52108
52109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52111 if (!SWIG_IsOK(res1)) {
52112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52113 }
52114 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52115 ecode2 = SWIG_AsVal_int(obj1, &val2);
52116 if (!SWIG_IsOK(ecode2)) {
52117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52118 }
52119 arg2 = static_cast< int >(val2);
52120 {
52121 PyThreadState* __tstate = wxPyBeginAllowThreads();
52122 (arg1)->SetMargin(arg2);
52123 wxPyEndAllowThreads(__tstate);
52124 if (PyErr_Occurred()) SWIG_fail;
52125 }
52126 resultobj = SWIG_Py_Void();
52127 return resultobj;
52128 fail:
52129 return NULL;
52130 }
52131
52132
52133 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52134 PyObject *resultobj = 0;
52135 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52136 int result;
52137 void *argp1 = 0 ;
52138 int res1 = 0 ;
52139 PyObject *swig_obj[1] ;
52140
52141 if (!args) SWIG_fail;
52142 swig_obj[0] = args;
52143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52144 if (!SWIG_IsOK(res1)) {
52145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52146 }
52147 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52148 {
52149 PyThreadState* __tstate = wxPyBeginAllowThreads();
52150 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52151 wxPyEndAllowThreads(__tstate);
52152 if (PyErr_Occurred()) SWIG_fail;
52153 }
52154 resultobj = SWIG_From_int(static_cast< int >(result));
52155 return resultobj;
52156 fail:
52157 return NULL;
52158 }
52159
52160
52161 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52162 PyObject *resultobj = 0;
52163 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52164 int result;
52165 void *argp1 = 0 ;
52166 int res1 = 0 ;
52167 PyObject *swig_obj[1] ;
52168
52169 if (!args) SWIG_fail;
52170 swig_obj[0] = args;
52171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52172 if (!SWIG_IsOK(res1)) {
52173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52174 }
52175 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52176 {
52177 PyThreadState* __tstate = wxPyBeginAllowThreads();
52178 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52179 wxPyEndAllowThreads(__tstate);
52180 if (PyErr_Occurred()) SWIG_fail;
52181 }
52182 resultobj = SWIG_From_int(static_cast< int >(result));
52183 return resultobj;
52184 fail:
52185 return NULL;
52186 }
52187
52188
52189 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52190 PyObject *resultobj = 0;
52191 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52192 int result;
52193 void *argp1 = 0 ;
52194 int res1 = 0 ;
52195 PyObject *swig_obj[1] ;
52196
52197 if (!args) SWIG_fail;
52198 swig_obj[0] = args;
52199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52200 if (!SWIG_IsOK(res1)) {
52201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52202 }
52203 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52204 {
52205 PyThreadState* __tstate = wxPyBeginAllowThreads();
52206 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52207 wxPyEndAllowThreads(__tstate);
52208 if (PyErr_Occurred()) SWIG_fail;
52209 }
52210 resultobj = SWIG_From_int(static_cast< int >(result));
52211 return resultobj;
52212 fail:
52213 return NULL;
52214 }
52215
52216
52217 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52218 PyObject *resultobj = 0;
52219 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52220 bool result;
52221 void *argp1 = 0 ;
52222 int res1 = 0 ;
52223 PyObject *swig_obj[1] ;
52224
52225 if (!args) SWIG_fail;
52226 swig_obj[0] = args;
52227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52228 if (!SWIG_IsOK(res1)) {
52229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52230 }
52231 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52232 {
52233 PyThreadState* __tstate = wxPyBeginAllowThreads();
52234 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52235 wxPyEndAllowThreads(__tstate);
52236 if (PyErr_Occurred()) SWIG_fail;
52237 }
52238 {
52239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52240 }
52241 return resultobj;
52242 fail:
52243 return NULL;
52244 }
52245
52246
52247 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52248 PyObject *resultobj = 0;
52249 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52250 bool arg2 ;
52251 void *argp1 = 0 ;
52252 int res1 = 0 ;
52253 bool val2 ;
52254 int ecode2 = 0 ;
52255 PyObject * obj0 = 0 ;
52256 PyObject * obj1 = 0 ;
52257 char * kwnames[] = {
52258 (char *) "self",(char *) "d", NULL
52259 };
52260
52261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52263 if (!SWIG_IsOK(res1)) {
52264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52265 }
52266 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52267 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52268 if (!SWIG_IsOK(ecode2)) {
52269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52270 }
52271 arg2 = static_cast< bool >(val2);
52272 {
52273 PyThreadState* __tstate = wxPyBeginAllowThreads();
52274 (arg1)->SetDone(arg2);
52275 wxPyEndAllowThreads(__tstate);
52276 if (PyErr_Occurred()) SWIG_fail;
52277 }
52278 resultobj = SWIG_Py_Void();
52279 return resultobj;
52280 fail:
52281 return NULL;
52282 }
52283
52284
52285 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52286 PyObject *resultobj = 0;
52287 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52288 wxRelationship result;
52289 void *argp1 = 0 ;
52290 int res1 = 0 ;
52291 PyObject *swig_obj[1] ;
52292
52293 if (!args) SWIG_fail;
52294 swig_obj[0] = args;
52295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52296 if (!SWIG_IsOK(res1)) {
52297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52298 }
52299 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52300 {
52301 PyThreadState* __tstate = wxPyBeginAllowThreads();
52302 result = (wxRelationship)(arg1)->GetRelationship();
52303 wxPyEndAllowThreads(__tstate);
52304 if (PyErr_Occurred()) SWIG_fail;
52305 }
52306 resultobj = SWIG_From_int(static_cast< int >(result));
52307 return resultobj;
52308 fail:
52309 return NULL;
52310 }
52311
52312
52313 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52314 PyObject *resultobj = 0;
52315 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52316 wxRelationship arg2 ;
52317 void *argp1 = 0 ;
52318 int res1 = 0 ;
52319 int val2 ;
52320 int ecode2 = 0 ;
52321 PyObject * obj0 = 0 ;
52322 PyObject * obj1 = 0 ;
52323 char * kwnames[] = {
52324 (char *) "self",(char *) "r", NULL
52325 };
52326
52327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52329 if (!SWIG_IsOK(res1)) {
52330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52331 }
52332 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52333 ecode2 = SWIG_AsVal_int(obj1, &val2);
52334 if (!SWIG_IsOK(ecode2)) {
52335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52336 }
52337 arg2 = static_cast< wxRelationship >(val2);
52338 {
52339 PyThreadState* __tstate = wxPyBeginAllowThreads();
52340 (arg1)->SetRelationship(arg2);
52341 wxPyEndAllowThreads(__tstate);
52342 if (PyErr_Occurred()) SWIG_fail;
52343 }
52344 resultobj = SWIG_Py_Void();
52345 return resultobj;
52346 fail:
52347 return NULL;
52348 }
52349
52350
52351 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52352 PyObject *resultobj = 0;
52353 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52354 wxWindow *arg2 = (wxWindow *) 0 ;
52355 bool result;
52356 void *argp1 = 0 ;
52357 int res1 = 0 ;
52358 void *argp2 = 0 ;
52359 int res2 = 0 ;
52360 PyObject * obj0 = 0 ;
52361 PyObject * obj1 = 0 ;
52362 char * kwnames[] = {
52363 (char *) "self",(char *) "otherW", NULL
52364 };
52365
52366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52368 if (!SWIG_IsOK(res1)) {
52369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52370 }
52371 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52372 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52373 if (!SWIG_IsOK(res2)) {
52374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52375 }
52376 arg2 = reinterpret_cast< wxWindow * >(argp2);
52377 {
52378 PyThreadState* __tstate = wxPyBeginAllowThreads();
52379 result = (bool)(arg1)->ResetIfWin(arg2);
52380 wxPyEndAllowThreads(__tstate);
52381 if (PyErr_Occurred()) SWIG_fail;
52382 }
52383 {
52384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52385 }
52386 return resultobj;
52387 fail:
52388 return NULL;
52389 }
52390
52391
52392 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52393 PyObject *resultobj = 0;
52394 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52395 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52396 wxWindow *arg3 = (wxWindow *) 0 ;
52397 bool result;
52398 void *argp1 = 0 ;
52399 int res1 = 0 ;
52400 void *argp2 = 0 ;
52401 int res2 = 0 ;
52402 void *argp3 = 0 ;
52403 int res3 = 0 ;
52404 PyObject * obj0 = 0 ;
52405 PyObject * obj1 = 0 ;
52406 PyObject * obj2 = 0 ;
52407 char * kwnames[] = {
52408 (char *) "self",(char *) "constraints",(char *) "win", NULL
52409 };
52410
52411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52413 if (!SWIG_IsOK(res1)) {
52414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52415 }
52416 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52418 if (!SWIG_IsOK(res2)) {
52419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52420 }
52421 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52422 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52423 if (!SWIG_IsOK(res3)) {
52424 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52425 }
52426 arg3 = reinterpret_cast< wxWindow * >(argp3);
52427 {
52428 PyThreadState* __tstate = wxPyBeginAllowThreads();
52429 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52430 wxPyEndAllowThreads(__tstate);
52431 if (PyErr_Occurred()) SWIG_fail;
52432 }
52433 {
52434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52435 }
52436 return resultobj;
52437 fail:
52438 return NULL;
52439 }
52440
52441
52442 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52443 PyObject *resultobj = 0;
52444 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52445 wxEdge arg2 ;
52446 wxWindow *arg3 = (wxWindow *) 0 ;
52447 wxWindow *arg4 = (wxWindow *) 0 ;
52448 int result;
52449 void *argp1 = 0 ;
52450 int res1 = 0 ;
52451 int val2 ;
52452 int ecode2 = 0 ;
52453 void *argp3 = 0 ;
52454 int res3 = 0 ;
52455 void *argp4 = 0 ;
52456 int res4 = 0 ;
52457 PyObject * obj0 = 0 ;
52458 PyObject * obj1 = 0 ;
52459 PyObject * obj2 = 0 ;
52460 PyObject * obj3 = 0 ;
52461 char * kwnames[] = {
52462 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52463 };
52464
52465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52467 if (!SWIG_IsOK(res1)) {
52468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52469 }
52470 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52471 ecode2 = SWIG_AsVal_int(obj1, &val2);
52472 if (!SWIG_IsOK(ecode2)) {
52473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52474 }
52475 arg2 = static_cast< wxEdge >(val2);
52476 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52477 if (!SWIG_IsOK(res3)) {
52478 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52479 }
52480 arg3 = reinterpret_cast< wxWindow * >(argp3);
52481 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52482 if (!SWIG_IsOK(res4)) {
52483 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52484 }
52485 arg4 = reinterpret_cast< wxWindow * >(argp4);
52486 {
52487 PyThreadState* __tstate = wxPyBeginAllowThreads();
52488 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52489 wxPyEndAllowThreads(__tstate);
52490 if (PyErr_Occurred()) SWIG_fail;
52491 }
52492 resultobj = SWIG_From_int(static_cast< int >(result));
52493 return resultobj;
52494 fail:
52495 return NULL;
52496 }
52497
52498
52499 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52500 PyObject *obj;
52501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52502 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52503 return SWIG_Py_Void();
52504 }
52505
52506 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52507 PyObject *resultobj = 0;
52508 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52509 wxIndividualLayoutConstraint *result = 0 ;
52510 void *argp1 = 0 ;
52511 int res1 = 0 ;
52512 PyObject *swig_obj[1] ;
52513
52514 if (!args) SWIG_fail;
52515 swig_obj[0] = args;
52516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52517 if (!SWIG_IsOK(res1)) {
52518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52519 }
52520 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52521 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52523 return resultobj;
52524 fail:
52525 return NULL;
52526 }
52527
52528
52529 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52530 PyObject *resultobj = 0;
52531 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52532 wxIndividualLayoutConstraint *result = 0 ;
52533 void *argp1 = 0 ;
52534 int res1 = 0 ;
52535 PyObject *swig_obj[1] ;
52536
52537 if (!args) SWIG_fail;
52538 swig_obj[0] = args;
52539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52540 if (!SWIG_IsOK(res1)) {
52541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52542 }
52543 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52544 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52546 return resultobj;
52547 fail:
52548 return NULL;
52549 }
52550
52551
52552 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52553 PyObject *resultobj = 0;
52554 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52555 wxIndividualLayoutConstraint *result = 0 ;
52556 void *argp1 = 0 ;
52557 int res1 = 0 ;
52558 PyObject *swig_obj[1] ;
52559
52560 if (!args) SWIG_fail;
52561 swig_obj[0] = args;
52562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52563 if (!SWIG_IsOK(res1)) {
52564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52565 }
52566 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52567 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52569 return resultobj;
52570 fail:
52571 return NULL;
52572 }
52573
52574
52575 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52576 PyObject *resultobj = 0;
52577 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52578 wxIndividualLayoutConstraint *result = 0 ;
52579 void *argp1 = 0 ;
52580 int res1 = 0 ;
52581 PyObject *swig_obj[1] ;
52582
52583 if (!args) SWIG_fail;
52584 swig_obj[0] = args;
52585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52586 if (!SWIG_IsOK(res1)) {
52587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52588 }
52589 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52590 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52592 return resultobj;
52593 fail:
52594 return NULL;
52595 }
52596
52597
52598 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52599 PyObject *resultobj = 0;
52600 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52601 wxIndividualLayoutConstraint *result = 0 ;
52602 void *argp1 = 0 ;
52603 int res1 = 0 ;
52604 PyObject *swig_obj[1] ;
52605
52606 if (!args) SWIG_fail;
52607 swig_obj[0] = args;
52608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52609 if (!SWIG_IsOK(res1)) {
52610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52611 }
52612 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52613 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52615 return resultobj;
52616 fail:
52617 return NULL;
52618 }
52619
52620
52621 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52622 PyObject *resultobj = 0;
52623 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52624 wxIndividualLayoutConstraint *result = 0 ;
52625 void *argp1 = 0 ;
52626 int res1 = 0 ;
52627 PyObject *swig_obj[1] ;
52628
52629 if (!args) SWIG_fail;
52630 swig_obj[0] = args;
52631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52632 if (!SWIG_IsOK(res1)) {
52633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52634 }
52635 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52636 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52638 return resultobj;
52639 fail:
52640 return NULL;
52641 }
52642
52643
52644 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52645 PyObject *resultobj = 0;
52646 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52647 wxIndividualLayoutConstraint *result = 0 ;
52648 void *argp1 = 0 ;
52649 int res1 = 0 ;
52650 PyObject *swig_obj[1] ;
52651
52652 if (!args) SWIG_fail;
52653 swig_obj[0] = args;
52654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52655 if (!SWIG_IsOK(res1)) {
52656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52657 }
52658 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52659 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52661 return resultobj;
52662 fail:
52663 return NULL;
52664 }
52665
52666
52667 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52668 PyObject *resultobj = 0;
52669 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52670 wxIndividualLayoutConstraint *result = 0 ;
52671 void *argp1 = 0 ;
52672 int res1 = 0 ;
52673 PyObject *swig_obj[1] ;
52674
52675 if (!args) SWIG_fail;
52676 swig_obj[0] = args;
52677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52678 if (!SWIG_IsOK(res1)) {
52679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52680 }
52681 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52682 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52684 return resultobj;
52685 fail:
52686 return NULL;
52687 }
52688
52689
52690 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52691 PyObject *resultobj = 0;
52692 wxLayoutConstraints *result = 0 ;
52693
52694 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52695 {
52696 PyThreadState* __tstate = wxPyBeginAllowThreads();
52697 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52698 wxPyEndAllowThreads(__tstate);
52699 if (PyErr_Occurred()) SWIG_fail;
52700 }
52701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52702 return resultobj;
52703 fail:
52704 return NULL;
52705 }
52706
52707
52708 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52709 PyObject *resultobj = 0;
52710 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52711 void *argp1 = 0 ;
52712 int res1 = 0 ;
52713 PyObject *swig_obj[1] ;
52714
52715 if (!args) SWIG_fail;
52716 swig_obj[0] = args;
52717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52718 if (!SWIG_IsOK(res1)) {
52719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52720 }
52721 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52722 {
52723 PyThreadState* __tstate = wxPyBeginAllowThreads();
52724 delete arg1;
52725
52726 wxPyEndAllowThreads(__tstate);
52727 if (PyErr_Occurred()) SWIG_fail;
52728 }
52729 resultobj = SWIG_Py_Void();
52730 return resultobj;
52731 fail:
52732 return NULL;
52733 }
52734
52735
52736 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52737 PyObject *resultobj = 0;
52738 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52739 wxWindow *arg2 = (wxWindow *) 0 ;
52740 int *arg3 = (int *) 0 ;
52741 bool result;
52742 void *argp1 = 0 ;
52743 int res1 = 0 ;
52744 void *argp2 = 0 ;
52745 int res2 = 0 ;
52746 int temp3 ;
52747 int res3 = SWIG_TMPOBJ ;
52748 PyObject * obj0 = 0 ;
52749 PyObject * obj1 = 0 ;
52750 char * kwnames[] = {
52751 (char *) "self",(char *) "win", NULL
52752 };
52753
52754 arg3 = &temp3;
52755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52757 if (!SWIG_IsOK(res1)) {
52758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52759 }
52760 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52762 if (!SWIG_IsOK(res2)) {
52763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52764 }
52765 arg2 = reinterpret_cast< wxWindow * >(argp2);
52766 {
52767 PyThreadState* __tstate = wxPyBeginAllowThreads();
52768 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52769 wxPyEndAllowThreads(__tstate);
52770 if (PyErr_Occurred()) SWIG_fail;
52771 }
52772 {
52773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52774 }
52775 if (SWIG_IsTmpObj(res3)) {
52776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52777 } else {
52778 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52780 }
52781 return resultobj;
52782 fail:
52783 return NULL;
52784 }
52785
52786
52787 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52788 PyObject *resultobj = 0;
52789 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52790 bool result;
52791 void *argp1 = 0 ;
52792 int res1 = 0 ;
52793 PyObject *swig_obj[1] ;
52794
52795 if (!args) SWIG_fail;
52796 swig_obj[0] = args;
52797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52798 if (!SWIG_IsOK(res1)) {
52799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52800 }
52801 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52802 {
52803 PyThreadState* __tstate = wxPyBeginAllowThreads();
52804 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52805 wxPyEndAllowThreads(__tstate);
52806 if (PyErr_Occurred()) SWIG_fail;
52807 }
52808 {
52809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52810 }
52811 return resultobj;
52812 fail:
52813 return NULL;
52814 }
52815
52816
52817 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52818 PyObject *obj;
52819 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52820 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52821 return SWIG_Py_Void();
52822 }
52823
52824 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52825 return SWIG_Python_InitShadowInstance(args);
52826 }
52827
52828 static PyMethodDef SwigMethods[] = {
52829 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52830 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52831 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52832 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52833 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52834 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52835 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52836 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52837 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52839 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52850 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52851 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52852 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52854 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52855 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52856 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52857 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52858 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52859 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52860 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52862 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52868 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52869 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52870 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52871 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52872 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52873 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52874 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52876 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52884 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52885 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52886 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52891 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52892 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52894 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52896 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52898 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52900 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52902 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52904 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52905 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52907 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52909 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52910 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52911 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52912 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52931 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52932 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52933 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52934 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52935 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52936 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52937 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52938 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52940 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52941 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52942 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52947 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52948 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52949 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52950 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52957 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52964 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52965 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52966 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52967 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52969 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52970 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52971 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52973 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52974 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52975 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52976 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52981 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52982 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52983 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52984 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52985 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52986 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52989 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52990 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52991 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52993 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52994 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52996 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52997 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52998 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52999 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53000 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53001 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53002 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53003 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53004 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53005 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53006 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53011 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53017 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53018 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53019 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53020 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53022 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53025 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53027 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53030 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53031 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53032 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53035 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53036 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53037 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53041 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53042 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53043 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53047 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53052 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53053 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53054 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53055 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53056 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53057 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53058 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53065 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53066 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53068 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53069 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53070 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53076 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53077 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53079 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53080 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53081 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53082 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53083 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53084 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53085 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53086 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53088 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53089 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53090 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53091 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53092 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53093 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53094 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53095 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53097 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53106 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53118 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53119 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53134 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53135 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53136 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53137 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53140 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53142 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53144 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53146 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53148 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53151 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53152 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53153 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53154 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53156 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53173 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53174 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53180 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53181 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53182 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53183 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53184 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53185 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53186 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53187 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53188 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53189 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53190 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53191 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53192 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53193 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53194 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53195 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53196 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53197 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53198 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53199 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53200 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53201 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53202 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53203 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53204 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53205 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53206 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53207 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53208 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53209 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53210 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53211 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53212 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53213 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53214 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53216 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53217 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53218 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53219 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53222 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53226 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53229 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53230 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53231 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53232 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53233 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53235 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53236 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53238 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53240 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53242 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53244 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53245 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53246 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53248 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53249 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53251 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53252 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53253 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53255 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53256 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53257 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53259 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53261 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53262 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53263 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53265 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53267 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53268 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53270 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53271 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53272 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53274 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53275 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53276 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53277 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53278 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53280 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53281 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53284 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53285 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53287 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53288 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53291 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53292 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53294 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53300 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53301 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53302 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53303 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53304 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53305 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53306 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53307 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53308 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53309 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53310 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53311 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53312 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53313 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53314 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53315 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53316 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53317 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53318 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53319 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53320 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53321 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53322 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53323 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53325 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53326 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53327 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53328 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53329 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53330 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53331 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53332 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53333 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53334 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53335 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53336 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53337 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53338 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53339 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53340 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53341 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53342 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53343 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53344 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53345 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53346 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53347 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53348 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53349 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53350 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53351 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53352 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53353 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53354 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53355 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53356 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53358 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53359 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53361 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53362 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53363 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53364 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53366 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53367 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53368 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53369 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53370 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53371 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53372 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53373 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53374 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53376 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53377 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53378 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53379 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53380 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53381 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53382 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53383 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53384 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53385 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53386 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53387 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53388 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53389 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53390 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53391 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53392 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53393 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53394 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53395 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53396 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53397 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53398 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53399 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53400 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53401 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53402 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53403 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53405 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53406 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53409 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53410 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53411 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53412 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53413 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53414 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53416 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53417 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53420 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53421 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53423 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53424 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53426 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53427 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53429 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53430 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53431 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53433 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53435 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53436 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53438 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53439 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53440 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53442 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53443 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53444 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53446 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53447 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53449 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53450 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53451 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53452 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53453 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53456 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53458 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53460 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53461 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53462 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53465 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53466 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53467 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53469 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53470 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53471 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53473 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53474 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53475 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53476 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53477 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53478 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53480 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53481 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53482 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53483 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53484 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53485 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53486 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53487 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53493 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53495 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53497 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53498 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53499 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53500 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53501 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53502 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53504 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53505 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53506 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53508 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53509 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53510 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53511 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53512 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53515 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53516 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53517 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53520 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53521 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53522 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53523 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53524 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53526 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53528 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53531 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53533 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53534 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53536 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53537 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53538 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53540 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53541 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53542 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53544 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53546 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53547 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53548 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53550 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53552 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53554 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53555 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53557 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53558 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53560 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53562 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53563 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53564 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53566 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53568 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53569 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53570 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53572 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53574 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53575 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53576 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53577 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53579 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53581 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53583 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53585 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53586 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53588 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53589 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53590 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53591 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53592 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53593 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53594 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53595 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53597 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53599 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53601 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53603 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53605 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53607 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53608 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53609 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53610 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53611 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53612 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53618 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53619 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53620 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53621 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53622 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53623 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53624 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53626 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53628 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53629 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53631 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53632 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53633 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53634 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53636 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53637 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53638 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53639 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53641 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53642 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53644 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53645 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53646 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53648 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53650 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53651 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53652 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53653 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53654 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53656 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53657 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53658 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53659 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53661 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53662 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53663 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53664 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53665 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53666 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53667 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53668 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53669 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53670 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53672 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53675 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53676 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53677 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53679 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53681 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53683 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53685 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53686 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53696 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53697 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53701 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53702 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53703 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53704 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53705 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53706 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53707 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53708 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53709 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53710 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53711 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53712 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53713 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53714 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53715 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53717 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53718 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53721 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53722 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53727 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53728 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53731 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53732 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53733 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53734 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53737 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53738 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53739 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53741 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53743 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53744 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53745 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53747 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53749 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53751 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53754 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53755 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53756 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53757 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53758 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53759 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53763 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53764 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53765 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53766 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53773 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53779 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53780 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53781 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53782 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53783 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53785 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53795 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53796 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53797 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53798 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53801 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53802 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53803 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53804 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53806 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53807 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53811 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53817 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53818 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53819 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53820 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53822 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53823 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53825 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53828 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53830 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53831 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53832 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53841 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
53845 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53846 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53848 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53858 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53859 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53860 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53861 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53865 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53868 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53870 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53873 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53875 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53876 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53879 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53881 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53882 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53883 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53884 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53885 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53890 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53891 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53892 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53894 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53895 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53896 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53898 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53900 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53901 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53902 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53904 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53905 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53908 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53916 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53923 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53931 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53934 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53935 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53948 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53950 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53952 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53953 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53955 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53957 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53958 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53960 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53961 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53962 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53966 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53985 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53986 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53988 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
53989 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53991 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53992 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53993 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53995 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53996 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53999 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54000 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54002 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54003 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54005 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54008 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54009 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54011 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54013 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54015 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54016 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54018 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54019 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54022 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54024 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54026 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54028 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54031 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54033 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54034 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54035 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54037 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54038 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54039 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54041 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54043 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54044 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54046 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54048 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54049 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54053 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54057 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54058 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54060 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54064 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54066 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54068 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54069 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54070 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54071 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54075 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54076 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54077 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54078 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54080 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54081 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54086 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54087 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54088 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54089 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54090 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54092 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54094 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54096 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54097 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54099 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54101 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54104 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54105 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54106 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54108 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54109 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54110 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54124 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54125 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54126 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54127 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54128 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54129 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54135 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54136 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54140 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54141 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54143 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54144 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54146 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54148 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54149 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54151 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54152 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54153 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54159 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54160 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54161 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54162 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54163 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54164 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54171 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54173 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54174 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54175 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54176 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54177 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54178 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54180 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54184 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54185 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54186 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54187 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54188 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54189 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54190 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54192 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54193 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54194 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54200 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54201 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54202 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54204 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54205 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54206 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54212 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54213 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54214 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54215 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54216 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54219 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54220 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54221 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54226 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54227 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54228 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54229 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54230 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54235 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54236 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54237 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54238 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54239 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54240 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54241 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54246 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54247 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54256 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54257 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54258 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54259 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54261 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54262 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54263 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54264 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54265 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54266 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54267 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54269 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54274 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54275 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54276 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54277 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54278 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54279 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54280 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54281 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54282 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54283 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54284 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54286 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54287 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54288 { NULL, NULL, 0, NULL }
54289 };
54290
54291
54292 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54293
54294 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54295 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54296 }
54297 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54298 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54299 }
54300 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54301 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54302 }
54303 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54304 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54305 }
54306 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54307 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54308 }
54309 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54310 return (void *)((wxSizer *) ((wxGridSizer *) x));
54311 }
54312 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54313 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54314 }
54315 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54316 return (void *)((wxSizer *) ((wxPySizer *) x));
54317 }
54318 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54319 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54320 }
54321 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54322 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54323 }
54324 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54325 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54326 }
54327 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54328 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54329 }
54330 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54331 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54332 }
54333 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54334 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54335 }
54336 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54337 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54338 }
54339 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54340 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54341 }
54342 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54343 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54344 }
54345 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54346 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54347 }
54348 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54349 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54350 }
54351 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54352 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54353 }
54354 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54355 return (void *)((wxEvent *) ((wxPyEvent *) x));
54356 }
54357 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54358 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54359 }
54360 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54361 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54362 }
54363 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54364 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54365 }
54366 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54367 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54368 }
54369 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54370 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54371 }
54372 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54373 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54374 }
54375 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54376 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54377 }
54378 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54379 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54380 }
54381 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54382 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54383 }
54384 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54385 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54386 }
54387 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54388 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54389 }
54390 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54391 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54392 }
54393 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54394 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54395 }
54396 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54397 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54398 }
54399 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54400 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54401 }
54402 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54403 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54404 }
54405 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54406 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54407 }
54408 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54409 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54410 }
54411 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54412 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54413 }
54414 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54415 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54416 }
54417 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54418 return (void *)((wxEvent *) ((wxShowEvent *) x));
54419 }
54420 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54421 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54422 }
54423 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54424 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54425 }
54426 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54427 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54428 }
54429 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54430 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54431 }
54432 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54433 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54434 }
54435 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54436 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54437 }
54438 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54439 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54440 }
54441 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54442 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54443 }
54444 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54445 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54446 }
54447 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54448 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54449 }
54450 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54451 return (void *)((wxControl *) ((wxControlWithItems *) x));
54452 }
54453 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54454 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54455 }
54456 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54457 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54458 }
54459 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54460 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54461 }
54462 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54463 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54464 }
54465 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54466 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54467 }
54468 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54469 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54470 }
54471 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54472 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54473 }
54474 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54475 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54476 }
54477 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54478 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54479 }
54480 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54481 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54482 }
54483 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54484 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54485 }
54486 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54487 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54488 }
54489 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54490 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54491 }
54492 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54493 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54494 }
54495 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54496 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54497 }
54498 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54499 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54500 }
54501 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54502 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54503 }
54504 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54505 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54506 }
54507 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54508 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54509 }
54510 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54511 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54512 }
54513 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54514 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54515 }
54516 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54517 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54518 }
54519 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54520 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54521 }
54522 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54523 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54524 }
54525 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54526 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54527 }
54528 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54529 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54530 }
54531 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54532 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54533 }
54534 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54535 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54536 }
54537 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54538 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54539 }
54540 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54541 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54542 }
54543 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54544 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54545 }
54546 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54547 return (void *)((wxObject *) ((wxSizerItem *) x));
54548 }
54549 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54550 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54551 }
54552 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54553 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54554 }
54555 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54556 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54557 }
54558 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54559 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54560 }
54561 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54562 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54563 }
54564 static void *_p_wxSizerTo_p_wxObject(void *x) {
54565 return (void *)((wxObject *) ((wxSizer *) x));
54566 }
54567 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54568 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54569 }
54570 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54571 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54572 }
54573 static void *_p_wxEventTo_p_wxObject(void *x) {
54574 return (void *)((wxObject *) ((wxEvent *) x));
54575 }
54576 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54577 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54578 }
54579 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54580 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54581 }
54582 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54583 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54584 }
54585 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54586 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54587 }
54588 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54589 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54590 }
54591 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54592 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54593 }
54594 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54595 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54596 }
54597 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54598 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54599 }
54600 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54601 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54602 }
54603 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54604 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54605 }
54606 static void *_p_wxControlTo_p_wxObject(void *x) {
54607 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54608 }
54609 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54610 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54611 }
54612 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54613 return (void *)((wxObject *) ((wxFSFile *) x));
54614 }
54615 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54616 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54617 }
54618 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54619 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54620 }
54621 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54622 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54623 }
54624 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54625 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54626 }
54627 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54628 return (void *)((wxObject *) ((wxMenuItem *) x));
54629 }
54630 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54631 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54632 }
54633 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54634 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54635 }
54636 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54637 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54638 }
54639 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54640 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54641 }
54642 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54643 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54644 }
54645 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54646 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54647 }
54648 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54649 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54650 }
54651 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54652 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54653 }
54654 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54655 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54656 }
54657 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54658 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54659 }
54660 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54661 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54662 }
54663 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54664 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54665 }
54666 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54667 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54668 }
54669 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54670 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54671 }
54672 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54673 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54674 }
54675 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54676 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54677 }
54678 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54679 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54680 }
54681 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54682 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54683 }
54684 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54685 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54686 }
54687 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54688 return (void *)((wxObject *) ((wxImageHandler *) x));
54689 }
54690 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54691 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54692 }
54693 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54694 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54695 }
54696 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54697 return (void *)((wxObject *) ((wxEvtHandler *) x));
54698 }
54699 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54700 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54701 }
54702 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54703 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54704 }
54705 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54706 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54707 }
54708 static void *_p_wxImageTo_p_wxObject(void *x) {
54709 return (void *)((wxObject *) ((wxImage *) x));
54710 }
54711 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54712 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54713 }
54714 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54715 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54716 }
54717 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54718 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54719 }
54720 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54721 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54722 }
54723 static void *_p_wxWindowTo_p_wxObject(void *x) {
54724 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54725 }
54726 static void *_p_wxMenuTo_p_wxObject(void *x) {
54727 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54728 }
54729 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54730 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54731 }
54732 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54733 return (void *)((wxObject *) ((wxFileSystem *) x));
54734 }
54735 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54736 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54737 }
54738 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54739 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54740 }
54741 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54742 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54743 }
54744 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54745 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54746 }
54747 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54748 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54749 }
54750 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54751 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54752 }
54753 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54754 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54755 }
54756 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54757 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54758 }
54759 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54760 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54761 }
54762 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54763 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54764 }
54765 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54766 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54767 }
54768 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54769 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54770 }
54771 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54772 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54773 }
54774 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54775 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54776 }
54777 static void *_p_wxControlTo_p_wxWindow(void *x) {
54778 return (void *)((wxWindow *) ((wxControl *) x));
54779 }
54780 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54781 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54782 }
54783 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54784 return (void *)((wxWindow *) ((wxMenuBar *) x));
54785 }
54786 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54787 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54788 }
54789 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54790 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54791 }
54792 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54793 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54794 }
54795 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54796 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54797 }
54798 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54799 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54800 }
54801 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54802 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54803 }
54804 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54805 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54806 }
54807 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54808 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54809 }
54810 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54811 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54812 }
54813 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54814 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54815 }
54816 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54817 return (void *)((wxValidator *) ((wxPyValidator *) x));
54818 }
54819 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54821 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};
54822 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54895 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54896 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54897 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
54898 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54899 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54900 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54901 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54902 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54903 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54904 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54905 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54906 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54907 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54908 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54909 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54910 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54911 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54912 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54913 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54914 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54915 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54916 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54917 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54918 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54919 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54920 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54921 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54922 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54923 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54924 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54925 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54926 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54927 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54928 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54929 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54930 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54931 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54932 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54933 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54934 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54935 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54936 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54937 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54938 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54939 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54940 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54941 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54942 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54943 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54944 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54945 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54946 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54947 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54948 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54949 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54950 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54951
54952 static swig_type_info *swig_type_initial[] = {
54953 &_swigt__p_buffer,
54954 &_swigt__p_char,
54955 &_swigt__p_form_ops_t,
54956 &_swigt__p_int,
54957 &_swigt__p_long,
54958 &_swigt__p_unsigned_char,
54959 &_swigt__p_unsigned_int,
54960 &_swigt__p_unsigned_long,
54961 &_swigt__p_wxANIHandler,
54962 &_swigt__p_wxAcceleratorEntry,
54963 &_swigt__p_wxAcceleratorTable,
54964 &_swigt__p_wxActivateEvent,
54965 &_swigt__p_wxAppTraits,
54966 &_swigt__p_wxArrayString,
54967 &_swigt__p_wxBMPHandler,
54968 &_swigt__p_wxBitmap,
54969 &_swigt__p_wxBoxSizer,
54970 &_swigt__p_wxButton,
54971 &_swigt__p_wxCURHandler,
54972 &_swigt__p_wxCaret,
54973 &_swigt__p_wxChildFocusEvent,
54974 &_swigt__p_wxClipboardTextEvent,
54975 &_swigt__p_wxCloseEvent,
54976 &_swigt__p_wxColour,
54977 &_swigt__p_wxCommandEvent,
54978 &_swigt__p_wxContextMenuEvent,
54979 &_swigt__p_wxControl,
54980 &_swigt__p_wxControlWithItems,
54981 &_swigt__p_wxCursor,
54982 &_swigt__p_wxDC,
54983 &_swigt__p_wxDateEvent,
54984 &_swigt__p_wxDateTime,
54985 &_swigt__p_wxDisplayChangedEvent,
54986 &_swigt__p_wxDropFilesEvent,
54987 &_swigt__p_wxDuplexMode,
54988 &_swigt__p_wxEraseEvent,
54989 &_swigt__p_wxEvent,
54990 &_swigt__p_wxEventLoop,
54991 &_swigt__p_wxEventLoopActivator,
54992 &_swigt__p_wxEvtHandler,
54993 &_swigt__p_wxFSFile,
54994 &_swigt__p_wxFileSystem,
54995 &_swigt__p_wxFileSystemHandler,
54996 &_swigt__p_wxFlexGridSizer,
54997 &_swigt__p_wxFocusEvent,
54998 &_swigt__p_wxFont,
54999 &_swigt__p_wxFrame,
55000 &_swigt__p_wxGBPosition,
55001 &_swigt__p_wxGBSizerItem,
55002 &_swigt__p_wxGBSpan,
55003 &_swigt__p_wxGIFHandler,
55004 &_swigt__p_wxGridBagSizer,
55005 &_swigt__p_wxGridSizer,
55006 &_swigt__p_wxHelpEvent__Origin,
55007 &_swigt__p_wxICOHandler,
55008 &_swigt__p_wxIconizeEvent,
55009 &_swigt__p_wxIdleEvent,
55010 &_swigt__p_wxImage,
55011 &_swigt__p_wxImageHandler,
55012 &_swigt__p_wxImageHistogram,
55013 &_swigt__p_wxImage_HSVValue,
55014 &_swigt__p_wxImage_RGBValue,
55015 &_swigt__p_wxIndividualLayoutConstraint,
55016 &_swigt__p_wxInitDialogEvent,
55017 &_swigt__p_wxInputStream,
55018 &_swigt__p_wxInternetFSHandler,
55019 &_swigt__p_wxItemContainer,
55020 &_swigt__p_wxJPEGHandler,
55021 &_swigt__p_wxKeyEvent,
55022 &_swigt__p_wxLayoutConstraints,
55023 &_swigt__p_wxMaximizeEvent,
55024 &_swigt__p_wxMemoryFSHandler,
55025 &_swigt__p_wxMenu,
55026 &_swigt__p_wxMenuBar,
55027 &_swigt__p_wxMenuBarBase,
55028 &_swigt__p_wxMenuEvent,
55029 &_swigt__p_wxMenuItem,
55030 &_swigt__p_wxMouseCaptureChangedEvent,
55031 &_swigt__p_wxMouseCaptureLostEvent,
55032 &_swigt__p_wxMouseEvent,
55033 &_swigt__p_wxMoveEvent,
55034 &_swigt__p_wxNavigationKeyEvent,
55035 &_swigt__p_wxNcPaintEvent,
55036 &_swigt__p_wxNotifyEvent,
55037 &_swigt__p_wxObject,
55038 &_swigt__p_wxOutputStream,
55039 &_swigt__p_wxPCXHandler,
55040 &_swigt__p_wxPNGHandler,
55041 &_swigt__p_wxPNMHandler,
55042 &_swigt__p_wxPaintEvent,
55043 &_swigt__p_wxPaletteChangedEvent,
55044 &_swigt__p_wxPaperSize,
55045 &_swigt__p_wxPoint,
55046 &_swigt__p_wxPoint2D,
55047 &_swigt__p_wxPropagateOnce,
55048 &_swigt__p_wxPropagationDisabler,
55049 &_swigt__p_wxPyApp,
55050 &_swigt__p_wxPyCommandEvent,
55051 &_swigt__p_wxPyDropTarget,
55052 &_swigt__p_wxPyEvent,
55053 &_swigt__p_wxPyFileSystemHandler,
55054 &_swigt__p_wxPyImageHandler,
55055 &_swigt__p_wxPyInputStream,
55056 &_swigt__p_wxPySizer,
55057 &_swigt__p_wxPyValidator,
55058 &_swigt__p_wxQuantize,
55059 &_swigt__p_wxQueryNewPaletteEvent,
55060 &_swigt__p_wxRealPoint,
55061 &_swigt__p_wxRect,
55062 &_swigt__p_wxRegion,
55063 &_swigt__p_wxScrollEvent,
55064 &_swigt__p_wxScrollWinEvent,
55065 &_swigt__p_wxSetCursorEvent,
55066 &_swigt__p_wxShowEvent,
55067 &_swigt__p_wxSize,
55068 &_swigt__p_wxSizeEvent,
55069 &_swigt__p_wxSizer,
55070 &_swigt__p_wxSizerItem,
55071 &_swigt__p_wxStaticBox,
55072 &_swigt__p_wxStaticBoxSizer,
55073 &_swigt__p_wxStdDialogButtonSizer,
55074 &_swigt__p_wxSysColourChangedEvent,
55075 &_swigt__p_wxTIFFHandler,
55076 &_swigt__p_wxToolTip,
55077 &_swigt__p_wxUpdateUIEvent,
55078 &_swigt__p_wxValidator,
55079 &_swigt__p_wxVisualAttributes,
55080 &_swigt__p_wxWindow,
55081 &_swigt__p_wxWindowCreateEvent,
55082 &_swigt__p_wxWindowDestroyEvent,
55083 &_swigt__p_wxXPMHandler,
55084 &_swigt__p_wxZipFSHandler,
55085 };
55086
55087 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55095 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55101 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}};
55102 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55103 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}};
55104 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55105 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}};
55106 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55109 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55110 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55111 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}};
55112 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55113 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}};
55114 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55120 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55121 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55122 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55123 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}};
55124 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55125 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55126 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}};
55127 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55128 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55129 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}};
55130 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}};
55131 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55134 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55135 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55136 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55137 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55138 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55139 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}};
55140 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55141 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}};
55142 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55143 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55144 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55145 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}};
55146 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55147 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55148 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55149 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55150 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55151 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55152 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55153 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}};
55154 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55155 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55156 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55157 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55161 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55162 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55163 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55164 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55165 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55166 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55167 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55168 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55169 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55170 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55171 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}};
55172 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55173 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55174 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55175 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55176 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55177 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55178 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55179 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55180 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55181 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55182 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55183 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55184 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55185 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55186 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55187 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55188 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55189 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55190 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55191 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55192 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55193 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55194 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55195 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55196 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55197 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55198 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55199 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55200 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55201 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55202 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55203 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}};
55204 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}};
55205 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55206 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55207 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55208 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55209 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55210 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55211 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55212 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}};
55213 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55214 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}};
55215 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55216 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55217 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55218 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55219
55220 static swig_cast_info *swig_cast_initial[] = {
55221 _swigc__p_buffer,
55222 _swigc__p_char,
55223 _swigc__p_form_ops_t,
55224 _swigc__p_int,
55225 _swigc__p_long,
55226 _swigc__p_unsigned_char,
55227 _swigc__p_unsigned_int,
55228 _swigc__p_unsigned_long,
55229 _swigc__p_wxANIHandler,
55230 _swigc__p_wxAcceleratorEntry,
55231 _swigc__p_wxAcceleratorTable,
55232 _swigc__p_wxActivateEvent,
55233 _swigc__p_wxAppTraits,
55234 _swigc__p_wxArrayString,
55235 _swigc__p_wxBMPHandler,
55236 _swigc__p_wxBitmap,
55237 _swigc__p_wxBoxSizer,
55238 _swigc__p_wxButton,
55239 _swigc__p_wxCURHandler,
55240 _swigc__p_wxCaret,
55241 _swigc__p_wxChildFocusEvent,
55242 _swigc__p_wxClipboardTextEvent,
55243 _swigc__p_wxCloseEvent,
55244 _swigc__p_wxColour,
55245 _swigc__p_wxCommandEvent,
55246 _swigc__p_wxContextMenuEvent,
55247 _swigc__p_wxControl,
55248 _swigc__p_wxControlWithItems,
55249 _swigc__p_wxCursor,
55250 _swigc__p_wxDC,
55251 _swigc__p_wxDateEvent,
55252 _swigc__p_wxDateTime,
55253 _swigc__p_wxDisplayChangedEvent,
55254 _swigc__p_wxDropFilesEvent,
55255 _swigc__p_wxDuplexMode,
55256 _swigc__p_wxEraseEvent,
55257 _swigc__p_wxEvent,
55258 _swigc__p_wxEventLoop,
55259 _swigc__p_wxEventLoopActivator,
55260 _swigc__p_wxEvtHandler,
55261 _swigc__p_wxFSFile,
55262 _swigc__p_wxFileSystem,
55263 _swigc__p_wxFileSystemHandler,
55264 _swigc__p_wxFlexGridSizer,
55265 _swigc__p_wxFocusEvent,
55266 _swigc__p_wxFont,
55267 _swigc__p_wxFrame,
55268 _swigc__p_wxGBPosition,
55269 _swigc__p_wxGBSizerItem,
55270 _swigc__p_wxGBSpan,
55271 _swigc__p_wxGIFHandler,
55272 _swigc__p_wxGridBagSizer,
55273 _swigc__p_wxGridSizer,
55274 _swigc__p_wxHelpEvent__Origin,
55275 _swigc__p_wxICOHandler,
55276 _swigc__p_wxIconizeEvent,
55277 _swigc__p_wxIdleEvent,
55278 _swigc__p_wxImage,
55279 _swigc__p_wxImageHandler,
55280 _swigc__p_wxImageHistogram,
55281 _swigc__p_wxImage_HSVValue,
55282 _swigc__p_wxImage_RGBValue,
55283 _swigc__p_wxIndividualLayoutConstraint,
55284 _swigc__p_wxInitDialogEvent,
55285 _swigc__p_wxInputStream,
55286 _swigc__p_wxInternetFSHandler,
55287 _swigc__p_wxItemContainer,
55288 _swigc__p_wxJPEGHandler,
55289 _swigc__p_wxKeyEvent,
55290 _swigc__p_wxLayoutConstraints,
55291 _swigc__p_wxMaximizeEvent,
55292 _swigc__p_wxMemoryFSHandler,
55293 _swigc__p_wxMenu,
55294 _swigc__p_wxMenuBar,
55295 _swigc__p_wxMenuBarBase,
55296 _swigc__p_wxMenuEvent,
55297 _swigc__p_wxMenuItem,
55298 _swigc__p_wxMouseCaptureChangedEvent,
55299 _swigc__p_wxMouseCaptureLostEvent,
55300 _swigc__p_wxMouseEvent,
55301 _swigc__p_wxMoveEvent,
55302 _swigc__p_wxNavigationKeyEvent,
55303 _swigc__p_wxNcPaintEvent,
55304 _swigc__p_wxNotifyEvent,
55305 _swigc__p_wxObject,
55306 _swigc__p_wxOutputStream,
55307 _swigc__p_wxPCXHandler,
55308 _swigc__p_wxPNGHandler,
55309 _swigc__p_wxPNMHandler,
55310 _swigc__p_wxPaintEvent,
55311 _swigc__p_wxPaletteChangedEvent,
55312 _swigc__p_wxPaperSize,
55313 _swigc__p_wxPoint,
55314 _swigc__p_wxPoint2D,
55315 _swigc__p_wxPropagateOnce,
55316 _swigc__p_wxPropagationDisabler,
55317 _swigc__p_wxPyApp,
55318 _swigc__p_wxPyCommandEvent,
55319 _swigc__p_wxPyDropTarget,
55320 _swigc__p_wxPyEvent,
55321 _swigc__p_wxPyFileSystemHandler,
55322 _swigc__p_wxPyImageHandler,
55323 _swigc__p_wxPyInputStream,
55324 _swigc__p_wxPySizer,
55325 _swigc__p_wxPyValidator,
55326 _swigc__p_wxQuantize,
55327 _swigc__p_wxQueryNewPaletteEvent,
55328 _swigc__p_wxRealPoint,
55329 _swigc__p_wxRect,
55330 _swigc__p_wxRegion,
55331 _swigc__p_wxScrollEvent,
55332 _swigc__p_wxScrollWinEvent,
55333 _swigc__p_wxSetCursorEvent,
55334 _swigc__p_wxShowEvent,
55335 _swigc__p_wxSize,
55336 _swigc__p_wxSizeEvent,
55337 _swigc__p_wxSizer,
55338 _swigc__p_wxSizerItem,
55339 _swigc__p_wxStaticBox,
55340 _swigc__p_wxStaticBoxSizer,
55341 _swigc__p_wxStdDialogButtonSizer,
55342 _swigc__p_wxSysColourChangedEvent,
55343 _swigc__p_wxTIFFHandler,
55344 _swigc__p_wxToolTip,
55345 _swigc__p_wxUpdateUIEvent,
55346 _swigc__p_wxValidator,
55347 _swigc__p_wxVisualAttributes,
55348 _swigc__p_wxWindow,
55349 _swigc__p_wxWindowCreateEvent,
55350 _swigc__p_wxWindowDestroyEvent,
55351 _swigc__p_wxXPMHandler,
55352 _swigc__p_wxZipFSHandler,
55353 };
55354
55355
55356 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55357
55358 static swig_const_info swig_const_table[] = {
55359 {0, 0, 0, 0.0, 0, 0}};
55360
55361 #ifdef __cplusplus
55362 }
55363 #endif
55364 /* -----------------------------------------------------------------------------
55365 * Type initialization:
55366 * This problem is tough by the requirement that no dynamic
55367 * memory is used. Also, since swig_type_info structures store pointers to
55368 * swig_cast_info structures and swig_cast_info structures store pointers back
55369 * to swig_type_info structures, we need some lookup code at initialization.
55370 * The idea is that swig generates all the structures that are needed.
55371 * The runtime then collects these partially filled structures.
55372 * The SWIG_InitializeModule function takes these initial arrays out of
55373 * swig_module, and does all the lookup, filling in the swig_module.types
55374 * array with the correct data and linking the correct swig_cast_info
55375 * structures together.
55376 *
55377 * The generated swig_type_info structures are assigned staticly to an initial
55378 * array. We just loop though that array, and handle each type individually.
55379 * First we lookup if this type has been already loaded, and if so, use the
55380 * loaded structure instead of the generated one. Then we have to fill in the
55381 * cast linked list. The cast data is initially stored in something like a
55382 * two-dimensional array. Each row corresponds to a type (there are the same
55383 * number of rows as there are in the swig_type_initial array). Each entry in
55384 * a column is one of the swig_cast_info structures for that type.
55385 * The cast_initial array is actually an array of arrays, because each row has
55386 * a variable number of columns. So to actually build the cast linked list,
55387 * we find the array of casts associated with the type, and loop through it
55388 * adding the casts to the list. The one last trick we need to do is making
55389 * sure the type pointer in the swig_cast_info struct is correct.
55390 *
55391 * First off, we lookup the cast->type name to see if it is already loaded.
55392 * There are three cases to handle:
55393 * 1) If the cast->type has already been loaded AND the type we are adding
55394 * casting info to has not been loaded (it is in this module), THEN we
55395 * replace the cast->type pointer with the type pointer that has already
55396 * been loaded.
55397 * 2) If BOTH types (the one we are adding casting info to, and the
55398 * cast->type) are loaded, THEN the cast info has already been loaded by
55399 * the previous module so we just ignore it.
55400 * 3) Finally, if cast->type has not already been loaded, then we add that
55401 * swig_cast_info to the linked list (because the cast->type) pointer will
55402 * be correct.
55403 * ----------------------------------------------------------------------------- */
55404
55405 #ifdef __cplusplus
55406 extern "C" {
55407 #if 0
55408 } /* c-mode */
55409 #endif
55410 #endif
55411
55412 #if 0
55413 #define SWIGRUNTIME_DEBUG
55414 #endif
55415
55416 SWIGRUNTIME void
55417 SWIG_InitializeModule(void *clientdata) {
55418 size_t i;
55419 swig_module_info *module_head;
55420 static int init_run = 0;
55421
55422 clientdata = clientdata;
55423
55424 if (init_run) return;
55425 init_run = 1;
55426
55427 /* Initialize the swig_module */
55428 swig_module.type_initial = swig_type_initial;
55429 swig_module.cast_initial = swig_cast_initial;
55430
55431 /* Try and load any already created modules */
55432 module_head = SWIG_GetModule(clientdata);
55433 if (module_head) {
55434 swig_module.next = module_head->next;
55435 module_head->next = &swig_module;
55436 } else {
55437 /* This is the first module loaded */
55438 swig_module.next = &swig_module;
55439 SWIG_SetModule(clientdata, &swig_module);
55440 }
55441
55442 /* Now work on filling in swig_module.types */
55443 #ifdef SWIGRUNTIME_DEBUG
55444 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55445 #endif
55446 for (i = 0; i < swig_module.size; ++i) {
55447 swig_type_info *type = 0;
55448 swig_type_info *ret;
55449 swig_cast_info *cast;
55450
55451 #ifdef SWIGRUNTIME_DEBUG
55452 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55453 #endif
55454
55455 /* if there is another module already loaded */
55456 if (swig_module.next != &swig_module) {
55457 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55458 }
55459 if (type) {
55460 /* Overwrite clientdata field */
55461 #ifdef SWIGRUNTIME_DEBUG
55462 printf("SWIG_InitializeModule: found type %s\n", type->name);
55463 #endif
55464 if (swig_module.type_initial[i]->clientdata) {
55465 type->clientdata = swig_module.type_initial[i]->clientdata;
55466 #ifdef SWIGRUNTIME_DEBUG
55467 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55468 #endif
55469 }
55470 } else {
55471 type = swig_module.type_initial[i];
55472 }
55473
55474 /* Insert casting types */
55475 cast = swig_module.cast_initial[i];
55476 while (cast->type) {
55477 /* Don't need to add information already in the list */
55478 ret = 0;
55479 #ifdef SWIGRUNTIME_DEBUG
55480 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55481 #endif
55482 if (swig_module.next != &swig_module) {
55483 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55484 #ifdef SWIGRUNTIME_DEBUG
55485 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55486 #endif
55487 }
55488 if (ret) {
55489 if (type == swig_module.type_initial[i]) {
55490 #ifdef SWIGRUNTIME_DEBUG
55491 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55492 #endif
55493 cast->type = ret;
55494 ret = 0;
55495 } else {
55496 /* Check for casting already in the list */
55497 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55498 #ifdef SWIGRUNTIME_DEBUG
55499 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55500 #endif
55501 if (!ocast) ret = 0;
55502 }
55503 }
55504
55505 if (!ret) {
55506 #ifdef SWIGRUNTIME_DEBUG
55507 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55508 #endif
55509 if (type->cast) {
55510 type->cast->prev = cast;
55511 cast->next = type->cast;
55512 }
55513 type->cast = cast;
55514 }
55515 cast++;
55516 }
55517 /* Set entry in modules->types array equal to the type */
55518 swig_module.types[i] = type;
55519 }
55520 swig_module.types[i] = 0;
55521
55522 #ifdef SWIGRUNTIME_DEBUG
55523 printf("**** SWIG_InitializeModule: Cast List ******\n");
55524 for (i = 0; i < swig_module.size; ++i) {
55525 int j = 0;
55526 swig_cast_info *cast = swig_module.cast_initial[i];
55527 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55528 while (cast->type) {
55529 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55530 cast++;
55531 ++j;
55532 }
55533 printf("---- Total casts: %d\n",j);
55534 }
55535 printf("**** SWIG_InitializeModule: Cast List ******\n");
55536 #endif
55537 }
55538
55539 /* This function will propagate the clientdata field of type to
55540 * any new swig_type_info structures that have been added into the list
55541 * of equivalent types. It is like calling
55542 * SWIG_TypeClientData(type, clientdata) a second time.
55543 */
55544 SWIGRUNTIME void
55545 SWIG_PropagateClientData(void) {
55546 size_t i;
55547 swig_cast_info *equiv;
55548 static int init_run = 0;
55549
55550 if (init_run) return;
55551 init_run = 1;
55552
55553 for (i = 0; i < swig_module.size; i++) {
55554 if (swig_module.types[i]->clientdata) {
55555 equiv = swig_module.types[i]->cast;
55556 while (equiv) {
55557 if (!equiv->converter) {
55558 if (equiv->type && !equiv->type->clientdata)
55559 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55560 }
55561 equiv = equiv->next;
55562 }
55563 }
55564 }
55565 }
55566
55567 #ifdef __cplusplus
55568 #if 0
55569 {
55570 /* c-mode */
55571 #endif
55572 }
55573 #endif
55574
55575
55576
55577 #ifdef __cplusplus
55578 extern "C" {
55579 #endif
55580
55581 /* Python-specific SWIG API */
55582 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55583 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55584 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55585
55586 /* -----------------------------------------------------------------------------
55587 * global variable support code.
55588 * ----------------------------------------------------------------------------- */
55589
55590 typedef struct swig_globalvar {
55591 char *name; /* Name of global variable */
55592 PyObject *(*get_attr)(void); /* Return the current value */
55593 int (*set_attr)(PyObject *); /* Set the value */
55594 struct swig_globalvar *next;
55595 } swig_globalvar;
55596
55597 typedef struct swig_varlinkobject {
55598 PyObject_HEAD
55599 swig_globalvar *vars;
55600 } swig_varlinkobject;
55601
55602 SWIGINTERN PyObject *
55603 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55604 return PyString_FromString("<Swig global variables>");
55605 }
55606
55607 SWIGINTERN PyObject *
55608 swig_varlink_str(swig_varlinkobject *v) {
55609 PyObject *str = PyString_FromString("(");
55610 swig_globalvar *var;
55611 for (var = v->vars; var; var=var->next) {
55612 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55613 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55614 }
55615 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55616 return str;
55617 }
55618
55619 SWIGINTERN int
55620 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55621 PyObject *str = swig_varlink_str(v);
55622 fprintf(fp,"Swig global variables ");
55623 fprintf(fp,"%s\n", PyString_AsString(str));
55624 Py_DECREF(str);
55625 return 0;
55626 }
55627
55628 SWIGINTERN void
55629 swig_varlink_dealloc(swig_varlinkobject *v) {
55630 swig_globalvar *var = v->vars;
55631 while (var) {
55632 swig_globalvar *n = var->next;
55633 free(var->name);
55634 free(var);
55635 var = n;
55636 }
55637 }
55638
55639 SWIGINTERN PyObject *
55640 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55641 PyObject *res = NULL;
55642 swig_globalvar *var = v->vars;
55643 while (var) {
55644 if (strcmp(var->name,n) == 0) {
55645 res = (*var->get_attr)();
55646 break;
55647 }
55648 var = var->next;
55649 }
55650 if (res == NULL && !PyErr_Occurred()) {
55651 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55652 }
55653 return res;
55654 }
55655
55656 SWIGINTERN int
55657 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55658 int res = 1;
55659 swig_globalvar *var = v->vars;
55660 while (var) {
55661 if (strcmp(var->name,n) == 0) {
55662 res = (*var->set_attr)(p);
55663 break;
55664 }
55665 var = var->next;
55666 }
55667 if (res == 1 && !PyErr_Occurred()) {
55668 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55669 }
55670 return res;
55671 }
55672
55673 SWIGINTERN PyTypeObject*
55674 swig_varlink_type(void) {
55675 static char varlink__doc__[] = "Swig var link object";
55676 static PyTypeObject varlink_type;
55677 static int type_init = 0;
55678 if (!type_init) {
55679 const PyTypeObject tmp
55680 = {
55681 PyObject_HEAD_INIT(NULL)
55682 0, /* Number of items in variable part (ob_size) */
55683 (char *)"swigvarlink", /* Type name (tp_name) */
55684 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55685 0, /* Itemsize (tp_itemsize) */
55686 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55687 (printfunc) swig_varlink_print, /* Print (tp_print) */
55688 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55689 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55690 0, /* tp_compare */
55691 (reprfunc) swig_varlink_repr, /* tp_repr */
55692 0, /* tp_as_number */
55693 0, /* tp_as_sequence */
55694 0, /* tp_as_mapping */
55695 0, /* tp_hash */
55696 0, /* tp_call */
55697 (reprfunc)swig_varlink_str, /* tp_str */
55698 0, /* tp_getattro */
55699 0, /* tp_setattro */
55700 0, /* tp_as_buffer */
55701 0, /* tp_flags */
55702 varlink__doc__, /* tp_doc */
55703 0, /* tp_traverse */
55704 0, /* tp_clear */
55705 0, /* tp_richcompare */
55706 0, /* tp_weaklistoffset */
55707 #if PY_VERSION_HEX >= 0x02020000
55708 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55709 #endif
55710 #if PY_VERSION_HEX >= 0x02030000
55711 0, /* tp_del */
55712 #endif
55713 #ifdef COUNT_ALLOCS
55714 0,0,0,0 /* tp_alloc -> tp_next */
55715 #endif
55716 };
55717 varlink_type = tmp;
55718 varlink_type.ob_type = &PyType_Type;
55719 type_init = 1;
55720 }
55721 return &varlink_type;
55722 }
55723
55724 /* Create a variable linking object for use later */
55725 SWIGINTERN PyObject *
55726 SWIG_Python_newvarlink(void) {
55727 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55728 if (result) {
55729 result->vars = 0;
55730 }
55731 return ((PyObject*) result);
55732 }
55733
55734 SWIGINTERN void
55735 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55736 swig_varlinkobject *v = (swig_varlinkobject *) p;
55737 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55738 if (gv) {
55739 size_t size = strlen(name)+1;
55740 gv->name = (char *)malloc(size);
55741 if (gv->name) {
55742 strncpy(gv->name,name,size);
55743 gv->get_attr = get_attr;
55744 gv->set_attr = set_attr;
55745 gv->next = v->vars;
55746 }
55747 }
55748 v->vars = gv;
55749 }
55750
55751 SWIGINTERN PyObject *
55752 SWIG_globals() {
55753 static PyObject *_SWIG_globals = 0;
55754 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55755 return _SWIG_globals;
55756 }
55757
55758 /* -----------------------------------------------------------------------------
55759 * constants/methods manipulation
55760 * ----------------------------------------------------------------------------- */
55761
55762 /* Install Constants */
55763 SWIGINTERN void
55764 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55765 PyObject *obj = 0;
55766 size_t i;
55767 for (i = 0; constants[i].type; ++i) {
55768 switch(constants[i].type) {
55769 case SWIG_PY_POINTER:
55770 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55771 break;
55772 case SWIG_PY_BINARY:
55773 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55774 break;
55775 default:
55776 obj = 0;
55777 break;
55778 }
55779 if (obj) {
55780 PyDict_SetItemString(d, constants[i].name, obj);
55781 Py_DECREF(obj);
55782 }
55783 }
55784 }
55785
55786 /* -----------------------------------------------------------------------------*/
55787 /* Fix SwigMethods to carry the callback ptrs when needed */
55788 /* -----------------------------------------------------------------------------*/
55789
55790 SWIGINTERN void
55791 SWIG_Python_FixMethods(PyMethodDef *methods,
55792 swig_const_info *const_table,
55793 swig_type_info **types,
55794 swig_type_info **types_initial) {
55795 size_t i;
55796 for (i = 0; methods[i].ml_name; ++i) {
55797 const char *c = methods[i].ml_doc;
55798 if (c && (c = strstr(c, "swig_ptr: "))) {
55799 int j;
55800 swig_const_info *ci = 0;
55801 const char *name = c + 10;
55802 for (j = 0; const_table[j].type; ++j) {
55803 if (strncmp(const_table[j].name, name,
55804 strlen(const_table[j].name)) == 0) {
55805 ci = &(const_table[j]);
55806 break;
55807 }
55808 }
55809 if (ci) {
55810 size_t shift = (ci->ptype) - types;
55811 swig_type_info *ty = types_initial[shift];
55812 size_t ldoc = (c - methods[i].ml_doc);
55813 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55814 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55815 if (ndoc) {
55816 char *buff = ndoc;
55817 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55818 if (ptr) {
55819 strncpy(buff, methods[i].ml_doc, ldoc);
55820 buff += ldoc;
55821 strncpy(buff, "swig_ptr: ", 10);
55822 buff += 10;
55823 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55824 methods[i].ml_doc = ndoc;
55825 }
55826 }
55827 }
55828 }
55829 }
55830 }
55831
55832 #ifdef __cplusplus
55833 }
55834 #endif
55835
55836 /* -----------------------------------------------------------------------------*
55837 * Partial Init method
55838 * -----------------------------------------------------------------------------*/
55839
55840 #ifdef __cplusplus
55841 extern "C"
55842 #endif
55843 SWIGEXPORT void SWIG_init(void) {
55844 PyObject *m, *d;
55845
55846 /* Fix SwigMethods to carry the callback ptrs when needed */
55847 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55848
55849 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55850 d = PyModule_GetDict(m);
55851
55852 SWIG_InitializeModule(0);
55853 SWIG_InstallConstants(d,swig_const_table);
55854
55855
55856
55857 #ifndef wxPyUSE_EXPORT
55858 // Make our API structure a CObject so other modules can import it
55859 // from this module.
55860 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55861 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55862 Py_XDECREF(cobj);
55863 #endif
55864
55865 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55866 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55867 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55868 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55869 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55870 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55871 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55872 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55873 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55874 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55875 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55876 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55877 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55878 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55879 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55880 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55881 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55882 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55883 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55884 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55885 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55886 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55887 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55888 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55889 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55890 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55891 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55892 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55893 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55894 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55895 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55896 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55897 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55898 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55899 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55900 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55901 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55902 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55903 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55904 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55905 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55906 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55907 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55908 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55909 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55910 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55911 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55912 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55913 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55914 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55915 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55916 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55917 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55918 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55919 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55920 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55921 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55922 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55923 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55924 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55925 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55926 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55927 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55928 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55929 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55930 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55931 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55932 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55933 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55934 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55935 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55936 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55937 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55938 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55939 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55940 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55941 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55942 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55943 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55944 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55945 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55946 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55947 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55948 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55949 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55950 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55951 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55952 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55953 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55954 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55955 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55956 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55957 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55958 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55959 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55960 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55961 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55962 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55963 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55964 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55965 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55966 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55967 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55968 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55969 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55970 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55971 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55972 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55973 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55974 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55975 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55976 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55977 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55978 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55979 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55980 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55981 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55982 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55983 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55984 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55985 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
55986 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
55987 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55988 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55989 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55990 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55991 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55992 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55993 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55994 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55995 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55996 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55997 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55998 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55999 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56000 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56001 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56002 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56003 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56004 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56005 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56006 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56007 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56008 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56009 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56010 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56011 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56012 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56013 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56014 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56015 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56016 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56017 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56018 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56019 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56020 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56021 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56022 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56023 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56024 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56025 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56026 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56027 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56028 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56029 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56030 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56031 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56032 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56033 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56034 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56035 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56036 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56037 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56038 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56039 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56040 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56041 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56042 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56043 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56044 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56045 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56046 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56047 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56048 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56049 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56050 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56051 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56052 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56053 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56054 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56055 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56056 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56057 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56058 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56059 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56060 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56061 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56062 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56063 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56064 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56065 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56066 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56067 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56068 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56069 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56070 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56071 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56072 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56073 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56074 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56075 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56076 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56077 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56078 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56079 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56080 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56081 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56082 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56083 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56084 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56085 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56086 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56087 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56088 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56089 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56090 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56091 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56092 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56093 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56094 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56095 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56096 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56097 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56098 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56099 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56100 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56101 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56102 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56103 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56104 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56105 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56106 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56107 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56108 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56109 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56110 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56111 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56112 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56113 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56114 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56115 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56116 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56117 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56118 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56119 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56120 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56121 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56122 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56123 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56124 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56125 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56126 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56127 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56128 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56129 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56130 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56131 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56132 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56133 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56134 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56135 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56136 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56137 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56138 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56139 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56140 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56141 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56142 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56143 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56144 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56145 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56146 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56147 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56148 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56149 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56150 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56151 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56152 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56153 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56154 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56155 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56156 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56157 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56158 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56159 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56160 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56161 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56162 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56163 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56164 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56165 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56166 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56167 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56168 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56169 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56170 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56171 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56172 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56173 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56174 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56175 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56176 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56177 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56178 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56179 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56180 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56181 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56182 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56183 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56184 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56185 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56186 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56187 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56188 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56189 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56190 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56191 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56192 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56193 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56194 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56195 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56196 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56197 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56198 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56199 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56200 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56201 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56202 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56203 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56204 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56205 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56206 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56207 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56208 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56209 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56210 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56211 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56212 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56213 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56214 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56215 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56216 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56217 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56218 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56219 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56220 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56221 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56222 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56223 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56224 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56225 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56226 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56227 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56228 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56229 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56230 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56231 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56232 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56233 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56234 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56235 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56236 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56237 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56238 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56239 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56240 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56241 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56242 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56243 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56244 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56245 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56246 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56247 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56248 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56249 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56250 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56251 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56252 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56253 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56254 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56255 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56256 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56257 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56258 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56259 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56260 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56261 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56262 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56263 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56264 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56265 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56266 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56267 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56268 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56269 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56270 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56271 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56272 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56273 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56274 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56275 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56276 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56277 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56278 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56279 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56280 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56281 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56282 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56283 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56284 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56285 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56286 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56287 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56288 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56289 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56290 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56291 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56292 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56293 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56294 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56295 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56296 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56297 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56298 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56299 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56300 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56301 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56302 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56303 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56304 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56305 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56306 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56307 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56308 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56309 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56310 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56311 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56312 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56313 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56314 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56315 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56316 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56317 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56318 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56319 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56320 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56321 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56322 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56323 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56324 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56325 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56326 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56327 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56328 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56329 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56330 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56331 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56332 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56333 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56334 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56335 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56336 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56337 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56338 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56339 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56340 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56341 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56342 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56343 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56344 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56345 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56346 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56347 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56348 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56349 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56350 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56351 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56352 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56353 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56354 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56355 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56356 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56357 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56358 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56359 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56360 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56361 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56362 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56363 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56364 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56365 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56366 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56367 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56368 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56369 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56370 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56371 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56372 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56373 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56374 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56375 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56376 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56377 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56378 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56379 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56380 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56381 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56382 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56383 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56384 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56385 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56386 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56387 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56388 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56389 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56390 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56391 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56392 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56393 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56394 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56395 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56396 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56397 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56398 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56399 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56400 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56401 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56402 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56403 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56404 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56405 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56406 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56407 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56408 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56409 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56410 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56411 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56412 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56413 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56414 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56415 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56416 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56417 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56418 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56419 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56420 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56421 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56422 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56423 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56424 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56425 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56426 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56427 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56428 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56429 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56430 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56431 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56432 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56433 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56434 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56435 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56436 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56437 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56438 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56439 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56440 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56441 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56442 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56443 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56444 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56445 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56446 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56447 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56448 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56449 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56450 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56451 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56452 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56453 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56454 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56455 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56456 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56457 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56458 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56459 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56460 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56461 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56462 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56463 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56464 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56465 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56466 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56467 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56468 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56469 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56470 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56471 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56472 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56473 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56474 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56475 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56476 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56477 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56478 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56479 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56480 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56481 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56482 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56483 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56484 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56485 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56486 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56487 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56488 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56489 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56490 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56491 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56492 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56493 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56494 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56495 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56496 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56497 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56498 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56499 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56500 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56501 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56502 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56503 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56504 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56505 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56506 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56507 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56508 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56509 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56510 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56511 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56512 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56513 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56514 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56515 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56516 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56517 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56518 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56519 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56520 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56521 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56522 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56523 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56524 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56525 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56526 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56527 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56528 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56529 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56530
56531 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56532
56533
56534 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56535
56536 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56537 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56538 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56539 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56540 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56541 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56542 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56543 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56544 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56545 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56546 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56547 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56548 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56549 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56550 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56551 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56552 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56553 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56554 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56555 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56556 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56557 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56558 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56559 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56560 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56561 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56562 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56563 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56564 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56565 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56566 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56567 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56568 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56569 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56570 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56571 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56572 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56573 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56574 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56575 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56576 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56577 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56578 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56579 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56580 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56581 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56582 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56583 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56584 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56585 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56586 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56587 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56588 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56589 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56590 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56591 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56592 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56593 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56594 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56595 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56596 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56597 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56598 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56599 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56600 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56601 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56602 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56603 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56604 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56605 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56606 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56607 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56608 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56609 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56610 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56611 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56612 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56613 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56614 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56615 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56616 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56617 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56618 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56619 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56620 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56621 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56622 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56623 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56624 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56625 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56626 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56627 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56628 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56629 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56630 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56631 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56632 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56633 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56634 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56635 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56636 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56637 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56638 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56639 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56640 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56641 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56642 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56643 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56644 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56645 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56646 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56647 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56648 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56649 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56650 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56651 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56652 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56653 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56654 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56655 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56656 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56657 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56658 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56659 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56660 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56661 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56662 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56663 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56664 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56665 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56666 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56667 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56668 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56669 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56670 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56671 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56672 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56673 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56674 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56675 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56676 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56677 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56678 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56679 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56680 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56681 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56682 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56683 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56684 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56685 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56686 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56687 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56688 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56689 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56690 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56691 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56692 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56693 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56694 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56695 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56696 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56697 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56698 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56699 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56700 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56701 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56702 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56703 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56704 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56705 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56706 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56707 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56708 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56709 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56710 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56711 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56712 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56713 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56714 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56715 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56716 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56717 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56718 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56719 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56720 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56721 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56722 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56723 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56724 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56725 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56726 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56727 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56728 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56729 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56730 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56731 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56732 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56733 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56734 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56735 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56736 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56737 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56738 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56739 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56740 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56741 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56742 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56743
56744 // Initialize threading, some globals and such
56745 __wxPyPreStart(d);
56746
56747
56748 // Although these are defined in __version__ they need to be here too so
56749 // that an assert can be done to ensure that the wxPython and the wxWindows
56750 // versions match.
56751 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56752 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56753 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56754
56755 }
56756
wxWidgets (Impactor)