]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
more informative assert message
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3864
3865 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3866 return wxWindow::FindWindowById(id, parent);
3867 }
3868
3869 wxWindow* wxFindWindowByName( const wxString& name,
3870 const wxWindow *parent = NULL ) {
3871 return wxWindow::FindWindowByName(name, parent);
3872 }
3873
3874 wxWindow* wxFindWindowByLabel( const wxString& label,
3875 const wxWindow *parent = NULL ) {
3876 return wxWindow::FindWindowByLabel(label, parent);
3877 }
3878
3879
3880 #ifdef __WXMSW__
3881 #include <wx/msw/private.h> // to get wxGetWindowId
3882 #endif
3883
3884
3885 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3886 #ifdef __WXMSW__
3887 WXHWND hWnd = (WXHWND)_hWnd;
3888 long id = wxGetWindowId(hWnd);
3889 wxWindow* win = new wxWindow;
3890 if (parent)
3891 parent->AddChild(win);
3892 win->SetEventHandler(win);
3893 win->SetHWND(hWnd);
3894 win->SetId(id);
3895 win->SubclassWin(hWnd);
3896 win->AdoptAttributesFromHWND();
3897 win->SetupColours();
3898 return win;
3899 #else
3900 wxPyRaiseNotImplemented();
3901 return NULL;
3902 #endif
3903 }
3904
3905
3906 PyObject* GetTopLevelWindows() {
3907 return wxPy_ConvertList(&wxTopLevelWindows);
3908 }
3909
3910
3911 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3914
3915 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3916
3917
3918 SWIGINTERNINLINE int
3919 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3920 {
3921 unsigned long v;
3922 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3923 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3924 return res;
3925 }
3926
3927 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3928 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3929 wxMenuItemList& list = self->GetMenuItems();
3930 return wxPy_ConvertList(&list);
3931 }
3932 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3933 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3934 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3935 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3936 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3937 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3938 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3939 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3941 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3942 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3943 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3944 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3945 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3946 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3947 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3948 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3949 static const wxString wxPyControlNameStr(wxControlNameStr);
3950 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3951 if (clientData) {
3952 wxPyClientData* data = new wxPyClientData(clientData);
3953 return self->Append(item, data);
3954 } else
3955 return self->Append(item);
3956 }
3957 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3958 if (clientData) {
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 return self->Insert(item, pos, data);
3961 } else
3962 return self->Insert(item, pos);
3963 }
3964 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3965 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3966 if (data) {
3967 Py_INCREF(data->m_obj);
3968 return data->m_obj;
3969 } else {
3970 Py_INCREF(Py_None);
3971 return Py_None;
3972 }
3973 }
3974 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3975 wxPyClientData* data = new wxPyClientData(clientData);
3976 self->SetClientObject(n, data);
3977 }
3978
3979
3980 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3981 wxPyUserData* data = NULL;
3982 if ( userData ) {
3983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3984 data = new wxPyUserData(userData);
3985 wxPyEndBlockThreads(blocked);
3986 }
3987 return new wxSizerItem(window, proportion, flag, border, data);
3988 }
3989 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3990 wxPyUserData* data = NULL;
3991 if ( userData ) {
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 data = new wxPyUserData(userData);
3994 wxPyEndBlockThreads(blocked);
3995 }
3996 return new wxSizerItem(width, height, proportion, flag, border, data);
3997 }
3998 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3999 wxPyUserData* data = NULL;
4000 if ( userData ) {
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 data = new wxPyUserData(userData);
4003 wxPyEndBlockThreads(blocked);
4004 }
4005 return new wxSizerItem(sizer, proportion, flag, border, data);
4006 }
4007
4008 SWIGINTERNINLINE PyObject *
4009 SWIG_From_float (float value)
4010 {
4011 return SWIG_From_double (value);
4012 }
4013
4014 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4015 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4016 if (data) {
4017 Py_INCREF(data->m_obj);
4018 return data->m_obj;
4019 } else {
4020 Py_INCREF(Py_None);
4021 return Py_None;
4022 }
4023 }
4024 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 self->SetUserData(data);
4032 }
4033
4034 // Figure out the type of the sizer item
4035
4036 struct wxPySizerItemInfo {
4037 wxPySizerItemInfo()
4038 : window(NULL), sizer(NULL), gotSize(false),
4039 size(wxDefaultSize), gotPos(false), pos(-1)
4040 {}
4041
4042 wxWindow* window;
4043 wxSizer* sizer;
4044 bool gotSize;
4045 wxSize size;
4046 bool gotPos;
4047 int pos;
4048 };
4049
4050 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4051
4052 wxPySizerItemInfo info;
4053 wxSize size;
4054 wxSize* sizePtr = &size;
4055
4056 // Find out what the type of the item is
4057 // try wxWindow
4058 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4059 PyErr_Clear();
4060 info.window = NULL;
4061
4062 // try wxSizer
4063 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4064 PyErr_Clear();
4065 info.sizer = NULL;
4066
4067 // try wxSize or (w,h)
4068 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4069 info.size = *sizePtr;
4070 info.gotSize = true;
4071 }
4072
4073 // or a single int
4074 if (checkIdx && PyInt_Check(item)) {
4075 info.pos = PyInt_AsLong(item);
4076 info.gotPos = true;
4077 }
4078 }
4079 }
4080
4081 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4082 // no expected type, figure out what kind of error message to generate
4083 if ( !checkSize && !checkIdx )
4084 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4085 else if ( checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4087 else if ( !checkSize && checkIdx)
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4089 else
4090 // can this one happen?
4091 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4092 }
4093
4094 return info;
4095 }
4096
4097 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4098 if (!self->GetClientObject())
4099 self->SetClientObject(new wxPyOORClientData(_self));
4100 }
4101 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4102
4103 wxPyUserData* data = NULL;
4104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4105 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4106 if ( userData && (info.window || info.sizer || info.gotSize) )
4107 data = new wxPyUserData(userData);
4108 if ( info.sizer )
4109 PyObject_SetAttrString(item,"thisown",Py_False);
4110 wxPyEndBlockThreads(blocked);
4111
4112 // Now call the real Add method if a valid item type was found
4113 if ( info.window )
4114 return self->Add(info.window, proportion, flag, border, data);
4115 else if ( info.sizer )
4116 return self->Add(info.sizer, proportion, flag, border, data);
4117 else if (info.gotSize)
4118 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4119 proportion, flag, border, data);
4120 else
4121 return NULL;
4122 }
4123 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4124
4125 wxPyUserData* data = NULL;
4126 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4127 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4128 if ( userData && (info.window || info.sizer || info.gotSize) )
4129 data = new wxPyUserData(userData);
4130 if ( info.sizer )
4131 PyObject_SetAttrString(item,"thisown",Py_False);
4132 wxPyEndBlockThreads(blocked);
4133
4134 // Now call the real Insert method if a valid item type was found
4135 if ( info.window )
4136 return self->Insert(before, info.window, proportion, flag, border, data);
4137 else if ( info.sizer )
4138 return self->Insert(before, info.sizer, proportion, flag, border, data);
4139 else if (info.gotSize)
4140 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4141 proportion, flag, border, data);
4142 else
4143 return NULL;
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Prepend method if a valid item type was found
4157 if ( info.window )
4158 return self->Prepend(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Prepend(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4170 wxPyEndBlockThreads(blocked);
4171 if ( info.window )
4172 return self->Remove(info.window);
4173 else if ( info.sizer )
4174 return self->Remove(info.sizer);
4175 else if ( info.gotPos )
4176 return self->Remove(info.pos);
4177 else
4178 return false;
4179 }
4180 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4183 wxPyEndBlockThreads(blocked);
4184 if ( info.window )
4185 return self->Detach(info.window);
4186 else if ( info.sizer )
4187 return self->Detach(info.sizer);
4188 else if ( info.gotPos )
4189 return self->Detach(info.pos);
4190 else
4191 return false;
4192 }
4193 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4195 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4196 wxPyEndBlockThreads(blocked);
4197 if ( info.window )
4198 return self->GetItem(info.window);
4199 else if ( info.sizer )
4200 return self->GetItem(info.sizer);
4201 else if ( info.gotPos )
4202 return self->GetItem(info.pos);
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4209 wxPyEndBlockThreads(blocked);
4210 if ( info.window )
4211 self->SetItemMinSize(info.window, size);
4212 else if ( info.sizer )
4213 self->SetItemMinSize(info.sizer, size);
4214 else if ( info.gotPos )
4215 self->SetItemMinSize(info.pos, size);
4216 }
4217 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4218 wxSizerItemList& list = self->GetChildren();
4219 return wxPy_ConvertList(&list);
4220 }
4221 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->Show(info.window, show, recursive);
4227 else if ( info.sizer )
4228 return self->Show(info.sizer, show, recursive);
4229 else if ( info.gotPos )
4230 return self->Show(info.pos, show);
4231 else
4232 return false;
4233 }
4234 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 return self->IsShown(info.window);
4240 else if ( info.sizer )
4241 return self->IsShown(info.sizer);
4242 else if ( info.gotPos )
4243 return self->IsShown(info.pos);
4244 else
4245 return false;
4246 }
4247
4248 // See pyclasses.h
4249 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4250 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4251 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4252
4253
4254
4255
4256 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4257 {
4258 if (source == Py_None) {
4259 **obj = wxGBPosition(-1,-1);
4260 return true;
4261 }
4262 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4263 }
4264
4265 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4266 {
4267 if (source == Py_None) {
4268 **obj = wxGBSpan(-1,-1);
4269 return true;
4270 }
4271 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4272 }
4273
4274
4275 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4276 wxGBPosition temp, *obj = &temp;
4277 if ( other == Py_None ) return false;
4278 if ( ! wxGBPosition_helper(other, &obj) ) {
4279 PyErr_Clear();
4280 return false;
4281 }
4282 return self->operator==(*obj);
4283 }
4284 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4285 wxGBPosition temp, *obj = &temp;
4286 if ( other == Py_None ) return true;
4287 if ( ! wxGBPosition_helper(other, &obj)) {
4288 PyErr_Clear();
4289 return true;
4290 }
4291 return self->operator!=(*obj);
4292 }
4293 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4294 self->SetRow(row);
4295 self->SetCol(col);
4296 }
4297 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 PyObject* tup = PyTuple_New(2);
4300 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4301 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4302 wxPyEndBlockThreads(blocked);
4303 return tup;
4304 }
4305 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4306 wxGBSpan temp, *obj = &temp;
4307 if ( other == Py_None ) return false;
4308 if ( ! wxGBSpan_helper(other, &obj) ) {
4309 PyErr_Clear();
4310 return false;
4311 }
4312 return self->operator==(*obj);
4313 }
4314 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4315 wxGBSpan temp, *obj = &temp;
4316 if ( other == Py_None ) return true;
4317 if ( ! wxGBSpan_helper(other, &obj)) {
4318 PyErr_Clear();
4319 return true;
4320 }
4321 return self->operator!=(*obj);
4322 }
4323 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4324 self->SetRowspan(rowspan);
4325 self->SetColspan(colspan);
4326 }
4327 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4329 PyObject* tup = PyTuple_New(2);
4330 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4331 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4332 wxPyEndBlockThreads(blocked);
4333 return tup;
4334 }
4335 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4336 wxPyUserData* data = NULL;
4337 if ( userData ) {
4338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4339 data = new wxPyUserData(userData);
4340 wxPyEndBlockThreads(blocked);
4341 }
4342 return new wxGBSizerItem(window, pos, span, flag, border, data);
4343 }
4344 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4345 wxPyUserData* data = NULL;
4346 if ( userData ) {
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 data = new wxPyUserData(userData);
4349 wxPyEndBlockThreads(blocked);
4350 }
4351 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4352 }
4353 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4354 wxPyUserData* data = NULL;
4355 if ( userData ) {
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 data = new wxPyUserData(userData);
4358 wxPyEndBlockThreads(blocked);
4359 }
4360 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4361 }
4362 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4363 int row, col;
4364 self->GetEndPos(row, col);
4365 return wxGBPosition(row, col);
4366 }
4367 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4368
4369 wxPyUserData* data = NULL;
4370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4371 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4372 if ( userData && (info.window || info.sizer || info.gotSize) )
4373 data = new wxPyUserData(userData);
4374 if ( info.sizer )
4375 PyObject_SetAttrString(item,"thisown",Py_False);
4376 wxPyEndBlockThreads(blocked);
4377
4378 // Now call the real Add method if a valid item type was found
4379 if ( info.window )
4380 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4381 else if ( info.sizer )
4382 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4383 else if (info.gotSize)
4384 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4385 pos, span, flag, border, data);
4386 return NULL;
4387 }
4388
4389
4390 #ifdef __cplusplus
4391 extern "C" {
4392 #endif
4393 SWIGINTERN int EmptyString_set(PyObject *) {
4394 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4395 return 1;
4396 }
4397
4398
4399 SWIGINTERN PyObject *EmptyString_get(void) {
4400 PyObject *pyobj = 0;
4401
4402 {
4403 #if wxUSE_UNICODE
4404 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4405 #else
4406 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #endif
4408 }
4409 return pyobj;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 wxString result;
4417 void *argp1 = 0 ;
4418 int res1 = 0 ;
4419 PyObject *swig_obj[1] ;
4420
4421 if (!args) SWIG_fail;
4422 swig_obj[0] = args;
4423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4424 if (!SWIG_IsOK(res1)) {
4425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4426 }
4427 arg1 = reinterpret_cast< wxObject * >(argp1);
4428 {
4429 PyThreadState* __tstate = wxPyBeginAllowThreads();
4430 result = wxObject_GetClassName(arg1);
4431 wxPyEndAllowThreads(__tstate);
4432 if (PyErr_Occurred()) SWIG_fail;
4433 }
4434 {
4435 #if wxUSE_UNICODE
4436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4437 #else
4438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4439 #endif
4440 }
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxObject *arg1 = (wxObject *) 0 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 PyObject *swig_obj[1] ;
4453
4454 if (!args) SWIG_fail;
4455 swig_obj[0] = args;
4456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4457 if (!SWIG_IsOK(res1)) {
4458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4459 }
4460 arg1 = reinterpret_cast< wxObject * >(argp1);
4461 {
4462 PyThreadState* __tstate = wxPyBeginAllowThreads();
4463 wxObject_Destroy(arg1);
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = SWIG_Py_Void();
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4475 PyObject *obj;
4476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4477 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4478 return SWIG_Py_Void();
4479 }
4480
4481 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4482 PyObject *resultobj = 0;
4483 wxSize *arg1 = (wxSize *) 0 ;
4484 int arg2 ;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 int val2 ;
4488 int ecode2 = 0 ;
4489 PyObject *swig_obj[2] ;
4490
4491 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4493 if (!SWIG_IsOK(res1)) {
4494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4495 }
4496 arg1 = reinterpret_cast< wxSize * >(argp1);
4497 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4498 if (!SWIG_IsOK(ecode2)) {
4499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4500 }
4501 arg2 = static_cast< int >(val2);
4502 if (arg1) (arg1)->x = arg2;
4503
4504 resultobj = SWIG_Py_Void();
4505 return resultobj;
4506 fail:
4507 return NULL;
4508 }
4509
4510
4511 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4512 PyObject *resultobj = 0;
4513 wxSize *arg1 = (wxSize *) 0 ;
4514 int result;
4515 void *argp1 = 0 ;
4516 int res1 = 0 ;
4517 PyObject *swig_obj[1] ;
4518
4519 if (!args) SWIG_fail;
4520 swig_obj[0] = args;
4521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4522 if (!SWIG_IsOK(res1)) {
4523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4524 }
4525 arg1 = reinterpret_cast< wxSize * >(argp1);
4526 result = (int) ((arg1)->x);
4527 resultobj = SWIG_From_int(static_cast< int >(result));
4528 return resultobj;
4529 fail:
4530 return NULL;
4531 }
4532
4533
4534 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4535 PyObject *resultobj = 0;
4536 wxSize *arg1 = (wxSize *) 0 ;
4537 int arg2 ;
4538 void *argp1 = 0 ;
4539 int res1 = 0 ;
4540 int val2 ;
4541 int ecode2 = 0 ;
4542 PyObject *swig_obj[2] ;
4543
4544 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4546 if (!SWIG_IsOK(res1)) {
4547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4548 }
4549 arg1 = reinterpret_cast< wxSize * >(argp1);
4550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4551 if (!SWIG_IsOK(ecode2)) {
4552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4553 }
4554 arg2 = static_cast< int >(val2);
4555 if (arg1) (arg1)->y = arg2;
4556
4557 resultobj = SWIG_Py_Void();
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxSize *arg1 = (wxSize *) 0 ;
4567 int result;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4577 }
4578 arg1 = reinterpret_cast< wxSize * >(argp1);
4579 result = (int) ((arg1)->y);
4580 resultobj = SWIG_From_int(static_cast< int >(result));
4581 return resultobj;
4582 fail:
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4588 PyObject *resultobj = 0;
4589 int arg1 = (int) 0 ;
4590 int arg2 = (int) 0 ;
4591 wxSize *result = 0 ;
4592 int val1 ;
4593 int ecode1 = 0 ;
4594 int val2 ;
4595 int ecode2 = 0 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char * kwnames[] = {
4599 (char *) "w",(char *) "h", NULL
4600 };
4601
4602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4603 if (obj0) {
4604 ecode1 = SWIG_AsVal_int(obj0, &val1);
4605 if (!SWIG_IsOK(ecode1)) {
4606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4607 }
4608 arg1 = static_cast< int >(val1);
4609 }
4610 if (obj1) {
4611 ecode2 = SWIG_AsVal_int(obj1, &val2);
4612 if (!SWIG_IsOK(ecode2)) {
4613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4614 }
4615 arg2 = static_cast< int >(val2);
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 result = (wxSize *)new wxSize(arg1,arg2);
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4624 return resultobj;
4625 fail:
4626 return NULL;
4627 }
4628
4629
4630 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 PyObject *resultobj = 0;
4632 wxSize *arg1 = (wxSize *) 0 ;
4633 void *argp1 = 0 ;
4634 int res1 = 0 ;
4635 PyObject *swig_obj[1] ;
4636
4637 if (!args) SWIG_fail;
4638 swig_obj[0] = args;
4639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4642 }
4643 arg1 = reinterpret_cast< wxSize * >(argp1);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 delete arg1;
4647
4648 wxPyEndAllowThreads(__tstate);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 resultobj = SWIG_Py_Void();
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4659 PyObject *resultobj = 0;
4660 wxSize *arg1 = (wxSize *) 0 ;
4661 PyObject *arg2 = (PyObject *) 0 ;
4662 bool result;
4663 void *argp1 = 0 ;
4664 int res1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 PyObject * obj1 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "self",(char *) "other", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4675 }
4676 arg1 = reinterpret_cast< wxSize * >(argp1);
4677 arg2 = obj1;
4678 {
4679 result = (bool)wxSize___eq__(arg1,arg2);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 {
4683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4684 }
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj = 0;
4693 wxSize *arg1 = (wxSize *) 0 ;
4694 PyObject *arg2 = (PyObject *) 0 ;
4695 bool result;
4696 void *argp1 = 0 ;
4697 int res1 = 0 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "other", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 arg2 = obj1;
4711 {
4712 result = (bool)wxSize___ne__(arg1,arg2);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 {
4716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4717 }
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 wxSize *arg2 = 0 ;
4728 wxSize result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 wxSize temp2 ;
4732 PyObject * obj0 = 0 ;
4733 PyObject * obj1 = 0 ;
4734 char * kwnames[] = {
4735 (char *) "self",(char *) "sz", NULL
4736 };
4737
4738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4740 if (!SWIG_IsOK(res1)) {
4741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4742 }
4743 arg1 = reinterpret_cast< wxSize * >(argp1);
4744 {
4745 arg2 = &temp2;
4746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = (arg1)->operator +((wxSize const &)*arg2);
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 wxSize *arg1 = (wxSize *) 0 ;
4764 wxSize *arg2 = 0 ;
4765 wxSize result;
4766 void *argp1 = 0 ;
4767 int res1 = 0 ;
4768 wxSize temp2 ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "self",(char *) "sz", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4779 }
4780 arg1 = reinterpret_cast< wxSize * >(argp1);
4781 {
4782 arg2 = &temp2;
4783 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4784 }
4785 {
4786 PyThreadState* __tstate = wxPyBeginAllowThreads();
4787 result = (arg1)->operator -((wxSize const &)*arg2);
4788 wxPyEndAllowThreads(__tstate);
4789 if (PyErr_Occurred()) SWIG_fail;
4790 }
4791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 wxSize *arg1 = (wxSize *) 0 ;
4801 wxSize *arg2 = 0 ;
4802 void *argp1 = 0 ;
4803 int res1 = 0 ;
4804 wxSize temp2 ;
4805 PyObject * obj0 = 0 ;
4806 PyObject * obj1 = 0 ;
4807 char * kwnames[] = {
4808 (char *) "self",(char *) "sz", NULL
4809 };
4810
4811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4813 if (!SWIG_IsOK(res1)) {
4814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4815 }
4816 arg1 = reinterpret_cast< wxSize * >(argp1);
4817 {
4818 arg2 = &temp2;
4819 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 (arg1)->IncTo((wxSize const &)*arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 resultobj = SWIG_Py_Void();
4828 return resultobj;
4829 fail:
4830 return NULL;
4831 }
4832
4833
4834 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4835 PyObject *resultobj = 0;
4836 wxSize *arg1 = (wxSize *) 0 ;
4837 wxSize *arg2 = 0 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 wxSize temp2 ;
4841 PyObject * obj0 = 0 ;
4842 PyObject * obj1 = 0 ;
4843 char * kwnames[] = {
4844 (char *) "self",(char *) "sz", NULL
4845 };
4846
4847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4849 if (!SWIG_IsOK(res1)) {
4850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4851 }
4852 arg1 = reinterpret_cast< wxSize * >(argp1);
4853 {
4854 arg2 = &temp2;
4855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4856 }
4857 {
4858 PyThreadState* __tstate = wxPyBeginAllowThreads();
4859 (arg1)->DecTo((wxSize const &)*arg2);
4860 wxPyEndAllowThreads(__tstate);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 resultobj = SWIG_Py_Void();
4864 return resultobj;
4865 fail:
4866 return NULL;
4867 }
4868
4869
4870 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4871 PyObject *resultobj = 0;
4872 wxSize *arg1 = (wxSize *) 0 ;
4873 int arg2 ;
4874 int arg3 ;
4875 void *argp1 = 0 ;
4876 int res1 = 0 ;
4877 int val2 ;
4878 int ecode2 = 0 ;
4879 int val3 ;
4880 int ecode3 = 0 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 PyObject * obj2 = 0 ;
4884 char * kwnames[] = {
4885 (char *) "self",(char *) "dx",(char *) "dy", NULL
4886 };
4887
4888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4890 if (!SWIG_IsOK(res1)) {
4891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4892 }
4893 arg1 = reinterpret_cast< wxSize * >(argp1);
4894 ecode2 = SWIG_AsVal_int(obj1, &val2);
4895 if (!SWIG_IsOK(ecode2)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4897 }
4898 arg2 = static_cast< int >(val2);
4899 ecode3 = SWIG_AsVal_int(obj2, &val3);
4900 if (!SWIG_IsOK(ecode3)) {
4901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4902 }
4903 arg3 = static_cast< int >(val3);
4904 {
4905 PyThreadState* __tstate = wxPyBeginAllowThreads();
4906 (arg1)->IncBy(arg2,arg3);
4907 wxPyEndAllowThreads(__tstate);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_Py_Void();
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 int arg2 ;
4921 int arg3 ;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 int val2 ;
4925 int ecode2 = 0 ;
4926 int val3 ;
4927 int ecode3 = 0 ;
4928 PyObject * obj0 = 0 ;
4929 PyObject * obj1 = 0 ;
4930 PyObject * obj2 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "dx",(char *) "dy", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4937 if (!SWIG_IsOK(res1)) {
4938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4939 }
4940 arg1 = reinterpret_cast< wxSize * >(argp1);
4941 ecode2 = SWIG_AsVal_int(obj1, &val2);
4942 if (!SWIG_IsOK(ecode2)) {
4943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 ecode3 = SWIG_AsVal_int(obj2, &val3);
4947 if (!SWIG_IsOK(ecode3)) {
4948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4949 }
4950 arg3 = static_cast< int >(val3);
4951 {
4952 PyThreadState* __tstate = wxPyBeginAllowThreads();
4953 (arg1)->DecBy(arg2,arg3);
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 resultobj = SWIG_Py_Void();
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj = 0;
4966 wxSize *arg1 = (wxSize *) 0 ;
4967 float arg2 ;
4968 float arg3 ;
4969 void *argp1 = 0 ;
4970 int res1 = 0 ;
4971 float val2 ;
4972 int ecode2 = 0 ;
4973 float val3 ;
4974 int ecode3 = 0 ;
4975 PyObject * obj0 = 0 ;
4976 PyObject * obj1 = 0 ;
4977 PyObject * obj2 = 0 ;
4978 char * kwnames[] = {
4979 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4980 };
4981
4982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4984 if (!SWIG_IsOK(res1)) {
4985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4986 }
4987 arg1 = reinterpret_cast< wxSize * >(argp1);
4988 ecode2 = SWIG_AsVal_float(obj1, &val2);
4989 if (!SWIG_IsOK(ecode2)) {
4990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4991 }
4992 arg2 = static_cast< float >(val2);
4993 ecode3 = SWIG_AsVal_float(obj2, &val3);
4994 if (!SWIG_IsOK(ecode3)) {
4995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4996 }
4997 arg3 = static_cast< float >(val3);
4998 {
4999 PyThreadState* __tstate = wxPyBeginAllowThreads();
5000 (arg1)->Scale(arg2,arg3);
5001 wxPyEndAllowThreads(__tstate);
5002 if (PyErr_Occurred()) SWIG_fail;
5003 }
5004 resultobj = SWIG_Py_Void();
5005 return resultobj;
5006 fail:
5007 return NULL;
5008 }
5009
5010
5011 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5012 PyObject *resultobj = 0;
5013 wxSize *arg1 = (wxSize *) 0 ;
5014 int arg2 ;
5015 int arg3 ;
5016 void *argp1 = 0 ;
5017 int res1 = 0 ;
5018 int val2 ;
5019 int ecode2 = 0 ;
5020 int val3 ;
5021 int ecode3 = 0 ;
5022 PyObject * obj0 = 0 ;
5023 PyObject * obj1 = 0 ;
5024 PyObject * obj2 = 0 ;
5025 char * kwnames[] = {
5026 (char *) "self",(char *) "w",(char *) "h", NULL
5027 };
5028
5029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5031 if (!SWIG_IsOK(res1)) {
5032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5033 }
5034 arg1 = reinterpret_cast< wxSize * >(argp1);
5035 ecode2 = SWIG_AsVal_int(obj1, &val2);
5036 if (!SWIG_IsOK(ecode2)) {
5037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5038 }
5039 arg2 = static_cast< int >(val2);
5040 ecode3 = SWIG_AsVal_int(obj2, &val3);
5041 if (!SWIG_IsOK(ecode3)) {
5042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5043 }
5044 arg3 = static_cast< int >(val3);
5045 {
5046 PyThreadState* __tstate = wxPyBeginAllowThreads();
5047 (arg1)->Set(arg2,arg3);
5048 wxPyEndAllowThreads(__tstate);
5049 if (PyErr_Occurred()) SWIG_fail;
5050 }
5051 resultobj = SWIG_Py_Void();
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5059 PyObject *resultobj = 0;
5060 wxSize *arg1 = (wxSize *) 0 ;
5061 int arg2 ;
5062 void *argp1 = 0 ;
5063 int res1 = 0 ;
5064 int val2 ;
5065 int ecode2 = 0 ;
5066 PyObject * obj0 = 0 ;
5067 PyObject * obj1 = 0 ;
5068 char * kwnames[] = {
5069 (char *) "self",(char *) "w", NULL
5070 };
5071
5072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5074 if (!SWIG_IsOK(res1)) {
5075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5076 }
5077 arg1 = reinterpret_cast< wxSize * >(argp1);
5078 ecode2 = SWIG_AsVal_int(obj1, &val2);
5079 if (!SWIG_IsOK(ecode2)) {
5080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5081 }
5082 arg2 = static_cast< int >(val2);
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 (arg1)->SetWidth(arg2);
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_Py_Void();
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5097 PyObject *resultobj = 0;
5098 wxSize *arg1 = (wxSize *) 0 ;
5099 int arg2 ;
5100 void *argp1 = 0 ;
5101 int res1 = 0 ;
5102 int val2 ;
5103 int ecode2 = 0 ;
5104 PyObject * obj0 = 0 ;
5105 PyObject * obj1 = 0 ;
5106 char * kwnames[] = {
5107 (char *) "self",(char *) "h", NULL
5108 };
5109
5110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5112 if (!SWIG_IsOK(res1)) {
5113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5114 }
5115 arg1 = reinterpret_cast< wxSize * >(argp1);
5116 ecode2 = SWIG_AsVal_int(obj1, &val2);
5117 if (!SWIG_IsOK(ecode2)) {
5118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5119 }
5120 arg2 = static_cast< int >(val2);
5121 {
5122 PyThreadState* __tstate = wxPyBeginAllowThreads();
5123 (arg1)->SetHeight(arg2);
5124 wxPyEndAllowThreads(__tstate);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 resultobj = SWIG_Py_Void();
5128 return resultobj;
5129 fail:
5130 return NULL;
5131 }
5132
5133
5134 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5135 PyObject *resultobj = 0;
5136 wxSize *arg1 = (wxSize *) 0 ;
5137 int result;
5138 void *argp1 = 0 ;
5139 int res1 = 0 ;
5140 PyObject *swig_obj[1] ;
5141
5142 if (!args) SWIG_fail;
5143 swig_obj[0] = args;
5144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5145 if (!SWIG_IsOK(res1)) {
5146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5147 }
5148 arg1 = reinterpret_cast< wxSize * >(argp1);
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 result = (int)((wxSize const *)arg1)->GetWidth();
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_From_int(static_cast< int >(result));
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 int result;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 PyObject *swig_obj[1] ;
5169
5170 if (!args) SWIG_fail;
5171 swig_obj[0] = args;
5172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5175 }
5176 arg1 = reinterpret_cast< wxSize * >(argp1);
5177 {
5178 PyThreadState* __tstate = wxPyBeginAllowThreads();
5179 result = (int)((wxSize const *)arg1)->GetHeight();
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 resultobj = SWIG_From_int(static_cast< int >(result));
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5191 PyObject *resultobj = 0;
5192 wxSize *arg1 = (wxSize *) 0 ;
5193 bool result;
5194 void *argp1 = 0 ;
5195 int res1 = 0 ;
5196 PyObject *swig_obj[1] ;
5197
5198 if (!args) SWIG_fail;
5199 swig_obj[0] = args;
5200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5201 if (!SWIG_IsOK(res1)) {
5202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5203 }
5204 arg1 = reinterpret_cast< wxSize * >(argp1);
5205 {
5206 PyThreadState* __tstate = wxPyBeginAllowThreads();
5207 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5208 wxPyEndAllowThreads(__tstate);
5209 if (PyErr_Occurred()) SWIG_fail;
5210 }
5211 {
5212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5213 }
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = 0;
5222 wxSize *arg1 = (wxSize *) 0 ;
5223 wxSize *arg2 = 0 ;
5224 void *argp1 = 0 ;
5225 int res1 = 0 ;
5226 wxSize temp2 ;
5227 PyObject * obj0 = 0 ;
5228 PyObject * obj1 = 0 ;
5229 char * kwnames[] = {
5230 (char *) "self",(char *) "size", NULL
5231 };
5232
5233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5235 if (!SWIG_IsOK(res1)) {
5236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5237 }
5238 arg1 = reinterpret_cast< wxSize * >(argp1);
5239 {
5240 arg2 = &temp2;
5241 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5242 }
5243 {
5244 PyThreadState* __tstate = wxPyBeginAllowThreads();
5245 (arg1)->SetDefaults((wxSize const &)*arg2);
5246 wxPyEndAllowThreads(__tstate);
5247 if (PyErr_Occurred()) SWIG_fail;
5248 }
5249 resultobj = SWIG_Py_Void();
5250 return resultobj;
5251 fail:
5252 return NULL;
5253 }
5254
5255
5256 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5257 PyObject *resultobj = 0;
5258 wxSize *arg1 = (wxSize *) 0 ;
5259 PyObject *result = 0 ;
5260 void *argp1 = 0 ;
5261 int res1 = 0 ;
5262 PyObject *swig_obj[1] ;
5263
5264 if (!args) SWIG_fail;
5265 swig_obj[0] = args;
5266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5267 if (!SWIG_IsOK(res1)) {
5268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5269 }
5270 arg1 = reinterpret_cast< wxSize * >(argp1);
5271 {
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 result = (PyObject *)wxSize_Get(arg1);
5274 wxPyEndAllowThreads(__tstate);
5275 if (PyErr_Occurred()) SWIG_fail;
5276 }
5277 resultobj = result;
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285 PyObject *obj;
5286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5287 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5288 return SWIG_Py_Void();
5289 }
5290
5291 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5292 return SWIG_Python_InitShadowInstance(args);
5293 }
5294
5295 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5296 PyObject *resultobj = 0;
5297 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5298 double arg2 ;
5299 void *argp1 = 0 ;
5300 int res1 = 0 ;
5301 double val2 ;
5302 int ecode2 = 0 ;
5303 PyObject *swig_obj[2] ;
5304
5305 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5307 if (!SWIG_IsOK(res1)) {
5308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5309 }
5310 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5311 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5312 if (!SWIG_IsOK(ecode2)) {
5313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5314 }
5315 arg2 = static_cast< double >(val2);
5316 if (arg1) (arg1)->x = arg2;
5317
5318 resultobj = SWIG_Py_Void();
5319 return resultobj;
5320 fail:
5321 return NULL;
5322 }
5323
5324
5325 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5326 PyObject *resultobj = 0;
5327 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5328 double result;
5329 void *argp1 = 0 ;
5330 int res1 = 0 ;
5331 PyObject *swig_obj[1] ;
5332
5333 if (!args) SWIG_fail;
5334 swig_obj[0] = args;
5335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5336 if (!SWIG_IsOK(res1)) {
5337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5338 }
5339 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5340 result = (double) ((arg1)->x);
5341 resultobj = SWIG_From_double(static_cast< double >(result));
5342 return resultobj;
5343 fail:
5344 return NULL;
5345 }
5346
5347
5348 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5349 PyObject *resultobj = 0;
5350 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5351 double arg2 ;
5352 void *argp1 = 0 ;
5353 int res1 = 0 ;
5354 double val2 ;
5355 int ecode2 = 0 ;
5356 PyObject *swig_obj[2] ;
5357
5358 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5360 if (!SWIG_IsOK(res1)) {
5361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5362 }
5363 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5364 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5365 if (!SWIG_IsOK(ecode2)) {
5366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5367 }
5368 arg2 = static_cast< double >(val2);
5369 if (arg1) (arg1)->y = arg2;
5370
5371 resultobj = SWIG_Py_Void();
5372 return resultobj;
5373 fail:
5374 return NULL;
5375 }
5376
5377
5378 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5379 PyObject *resultobj = 0;
5380 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5381 double result;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 PyObject *swig_obj[1] ;
5385
5386 if (!args) SWIG_fail;
5387 swig_obj[0] = args;
5388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5389 if (!SWIG_IsOK(res1)) {
5390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5391 }
5392 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5393 result = (double) ((arg1)->y);
5394 resultobj = SWIG_From_double(static_cast< double >(result));
5395 return resultobj;
5396 fail:
5397 return NULL;
5398 }
5399
5400
5401 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5402 PyObject *resultobj = 0;
5403 double arg1 = (double) 0.0 ;
5404 double arg2 = (double) 0.0 ;
5405 wxRealPoint *result = 0 ;
5406 double val1 ;
5407 int ecode1 = 0 ;
5408 double val2 ;
5409 int ecode2 = 0 ;
5410 PyObject * obj0 = 0 ;
5411 PyObject * obj1 = 0 ;
5412 char * kwnames[] = {
5413 (char *) "x",(char *) "y", NULL
5414 };
5415
5416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5417 if (obj0) {
5418 ecode1 = SWIG_AsVal_double(obj0, &val1);
5419 if (!SWIG_IsOK(ecode1)) {
5420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5421 }
5422 arg1 = static_cast< double >(val1);
5423 }
5424 if (obj1) {
5425 ecode2 = SWIG_AsVal_double(obj1, &val2);
5426 if (!SWIG_IsOK(ecode2)) {
5427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5428 }
5429 arg2 = static_cast< double >(val2);
5430 }
5431 {
5432 PyThreadState* __tstate = wxPyBeginAllowThreads();
5433 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5434 wxPyEndAllowThreads(__tstate);
5435 if (PyErr_Occurred()) SWIG_fail;
5436 }
5437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5445 PyObject *resultobj = 0;
5446 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5447 void *argp1 = 0 ;
5448 int res1 = 0 ;
5449 PyObject *swig_obj[1] ;
5450
5451 if (!args) SWIG_fail;
5452 swig_obj[0] = args;
5453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5454 if (!SWIG_IsOK(res1)) {
5455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5456 }
5457 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5458 {
5459 PyThreadState* __tstate = wxPyBeginAllowThreads();
5460 delete arg1;
5461
5462 wxPyEndAllowThreads(__tstate);
5463 if (PyErr_Occurred()) SWIG_fail;
5464 }
5465 resultobj = SWIG_Py_Void();
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5473 PyObject *resultobj = 0;
5474 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5475 PyObject *arg2 = (PyObject *) 0 ;
5476 bool result;
5477 void *argp1 = 0 ;
5478 int res1 = 0 ;
5479 PyObject * obj0 = 0 ;
5480 PyObject * obj1 = 0 ;
5481 char * kwnames[] = {
5482 (char *) "self",(char *) "other", NULL
5483 };
5484
5485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5487 if (!SWIG_IsOK(res1)) {
5488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5489 }
5490 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5491 arg2 = obj1;
5492 {
5493 result = (bool)wxRealPoint___eq__(arg1,arg2);
5494 if (PyErr_Occurred()) SWIG_fail;
5495 }
5496 {
5497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5498 }
5499 return resultobj;
5500 fail:
5501 return NULL;
5502 }
5503
5504
5505 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5506 PyObject *resultobj = 0;
5507 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5508 PyObject *arg2 = (PyObject *) 0 ;
5509 bool result;
5510 void *argp1 = 0 ;
5511 int res1 = 0 ;
5512 PyObject * obj0 = 0 ;
5513 PyObject * obj1 = 0 ;
5514 char * kwnames[] = {
5515 (char *) "self",(char *) "other", NULL
5516 };
5517
5518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5520 if (!SWIG_IsOK(res1)) {
5521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5522 }
5523 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5524 arg2 = obj1;
5525 {
5526 result = (bool)wxRealPoint___ne__(arg1,arg2);
5527 if (PyErr_Occurred()) SWIG_fail;
5528 }
5529 {
5530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5531 }
5532 return resultobj;
5533 fail:
5534 return NULL;
5535 }
5536
5537
5538 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5539 PyObject *resultobj = 0;
5540 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5541 wxRealPoint *arg2 = 0 ;
5542 wxRealPoint result;
5543 void *argp1 = 0 ;
5544 int res1 = 0 ;
5545 wxRealPoint temp2 ;
5546 PyObject * obj0 = 0 ;
5547 PyObject * obj1 = 0 ;
5548 char * kwnames[] = {
5549 (char *) "self",(char *) "pt", NULL
5550 };
5551
5552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5554 if (!SWIG_IsOK(res1)) {
5555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5556 }
5557 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5558 {
5559 arg2 = &temp2;
5560 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5561 }
5562 {
5563 PyThreadState* __tstate = wxPyBeginAllowThreads();
5564 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5565 wxPyEndAllowThreads(__tstate);
5566 if (PyErr_Occurred()) SWIG_fail;
5567 }
5568 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5569 return resultobj;
5570 fail:
5571 return NULL;
5572 }
5573
5574
5575 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5576 PyObject *resultobj = 0;
5577 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5578 wxRealPoint *arg2 = 0 ;
5579 wxRealPoint result;
5580 void *argp1 = 0 ;
5581 int res1 = 0 ;
5582 wxRealPoint temp2 ;
5583 PyObject * obj0 = 0 ;
5584 PyObject * obj1 = 0 ;
5585 char * kwnames[] = {
5586 (char *) "self",(char *) "pt", NULL
5587 };
5588
5589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5591 if (!SWIG_IsOK(res1)) {
5592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5593 }
5594 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5595 {
5596 arg2 = &temp2;
5597 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5598 }
5599 {
5600 PyThreadState* __tstate = wxPyBeginAllowThreads();
5601 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5602 wxPyEndAllowThreads(__tstate);
5603 if (PyErr_Occurred()) SWIG_fail;
5604 }
5605 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5606 return resultobj;
5607 fail:
5608 return NULL;
5609 }
5610
5611
5612 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5613 PyObject *resultobj = 0;
5614 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5615 double arg2 ;
5616 double arg3 ;
5617 void *argp1 = 0 ;
5618 int res1 = 0 ;
5619 double val2 ;
5620 int ecode2 = 0 ;
5621 double val3 ;
5622 int ecode3 = 0 ;
5623 PyObject * obj0 = 0 ;
5624 PyObject * obj1 = 0 ;
5625 PyObject * obj2 = 0 ;
5626 char * kwnames[] = {
5627 (char *) "self",(char *) "x",(char *) "y", NULL
5628 };
5629
5630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5632 if (!SWIG_IsOK(res1)) {
5633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5634 }
5635 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5636 ecode2 = SWIG_AsVal_double(obj1, &val2);
5637 if (!SWIG_IsOK(ecode2)) {
5638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5639 }
5640 arg2 = static_cast< double >(val2);
5641 ecode3 = SWIG_AsVal_double(obj2, &val3);
5642 if (!SWIG_IsOK(ecode3)) {
5643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5644 }
5645 arg3 = static_cast< double >(val3);
5646 {
5647 PyThreadState* __tstate = wxPyBeginAllowThreads();
5648 wxRealPoint_Set(arg1,arg2,arg3);
5649 wxPyEndAllowThreads(__tstate);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 resultobj = SWIG_Py_Void();
5653 return resultobj;
5654 fail:
5655 return NULL;
5656 }
5657
5658
5659 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5660 PyObject *resultobj = 0;
5661 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5662 PyObject *result = 0 ;
5663 void *argp1 = 0 ;
5664 int res1 = 0 ;
5665 PyObject *swig_obj[1] ;
5666
5667 if (!args) SWIG_fail;
5668 swig_obj[0] = args;
5669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5670 if (!SWIG_IsOK(res1)) {
5671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5672 }
5673 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5674 {
5675 PyThreadState* __tstate = wxPyBeginAllowThreads();
5676 result = (PyObject *)wxRealPoint_Get(arg1);
5677 wxPyEndAllowThreads(__tstate);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 resultobj = result;
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *obj;
5689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5690 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5691 return SWIG_Py_Void();
5692 }
5693
5694 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5695 return SWIG_Python_InitShadowInstance(args);
5696 }
5697
5698 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5699 PyObject *resultobj = 0;
5700 wxPoint *arg1 = (wxPoint *) 0 ;
5701 int arg2 ;
5702 void *argp1 = 0 ;
5703 int res1 = 0 ;
5704 int val2 ;
5705 int ecode2 = 0 ;
5706 PyObject *swig_obj[2] ;
5707
5708 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5710 if (!SWIG_IsOK(res1)) {
5711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5712 }
5713 arg1 = reinterpret_cast< wxPoint * >(argp1);
5714 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5715 if (!SWIG_IsOK(ecode2)) {
5716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5717 }
5718 arg2 = static_cast< int >(val2);
5719 if (arg1) (arg1)->x = arg2;
5720
5721 resultobj = SWIG_Py_Void();
5722 return resultobj;
5723 fail:
5724 return NULL;
5725 }
5726
5727
5728 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5729 PyObject *resultobj = 0;
5730 wxPoint *arg1 = (wxPoint *) 0 ;
5731 int result;
5732 void *argp1 = 0 ;
5733 int res1 = 0 ;
5734 PyObject *swig_obj[1] ;
5735
5736 if (!args) SWIG_fail;
5737 swig_obj[0] = args;
5738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5739 if (!SWIG_IsOK(res1)) {
5740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5741 }
5742 arg1 = reinterpret_cast< wxPoint * >(argp1);
5743 result = (int) ((arg1)->x);
5744 resultobj = SWIG_From_int(static_cast< int >(result));
5745 return resultobj;
5746 fail:
5747 return NULL;
5748 }
5749
5750
5751 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5752 PyObject *resultobj = 0;
5753 wxPoint *arg1 = (wxPoint *) 0 ;
5754 int arg2 ;
5755 void *argp1 = 0 ;
5756 int res1 = 0 ;
5757 int val2 ;
5758 int ecode2 = 0 ;
5759 PyObject *swig_obj[2] ;
5760
5761 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5763 if (!SWIG_IsOK(res1)) {
5764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5765 }
5766 arg1 = reinterpret_cast< wxPoint * >(argp1);
5767 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5768 if (!SWIG_IsOK(ecode2)) {
5769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5770 }
5771 arg2 = static_cast< int >(val2);
5772 if (arg1) (arg1)->y = arg2;
5773
5774 resultobj = SWIG_Py_Void();
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5782 PyObject *resultobj = 0;
5783 wxPoint *arg1 = (wxPoint *) 0 ;
5784 int result;
5785 void *argp1 = 0 ;
5786 int res1 = 0 ;
5787 PyObject *swig_obj[1] ;
5788
5789 if (!args) SWIG_fail;
5790 swig_obj[0] = args;
5791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5792 if (!SWIG_IsOK(res1)) {
5793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5794 }
5795 arg1 = reinterpret_cast< wxPoint * >(argp1);
5796 result = (int) ((arg1)->y);
5797 resultobj = SWIG_From_int(static_cast< int >(result));
5798 return resultobj;
5799 fail:
5800 return NULL;
5801 }
5802
5803
5804 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5805 PyObject *resultobj = 0;
5806 int arg1 = (int) 0 ;
5807 int arg2 = (int) 0 ;
5808 wxPoint *result = 0 ;
5809 int val1 ;
5810 int ecode1 = 0 ;
5811 int val2 ;
5812 int ecode2 = 0 ;
5813 PyObject * obj0 = 0 ;
5814 PyObject * obj1 = 0 ;
5815 char * kwnames[] = {
5816 (char *) "x",(char *) "y", NULL
5817 };
5818
5819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5820 if (obj0) {
5821 ecode1 = SWIG_AsVal_int(obj0, &val1);
5822 if (!SWIG_IsOK(ecode1)) {
5823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5824 }
5825 arg1 = static_cast< int >(val1);
5826 }
5827 if (obj1) {
5828 ecode2 = SWIG_AsVal_int(obj1, &val2);
5829 if (!SWIG_IsOK(ecode2)) {
5830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5831 }
5832 arg2 = static_cast< int >(val2);
5833 }
5834 {
5835 PyThreadState* __tstate = wxPyBeginAllowThreads();
5836 result = (wxPoint *)new wxPoint(arg1,arg2);
5837 wxPyEndAllowThreads(__tstate);
5838 if (PyErr_Occurred()) SWIG_fail;
5839 }
5840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5841 return resultobj;
5842 fail:
5843 return NULL;
5844 }
5845
5846
5847 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5848 PyObject *resultobj = 0;
5849 wxPoint *arg1 = (wxPoint *) 0 ;
5850 void *argp1 = 0 ;
5851 int res1 = 0 ;
5852 PyObject *swig_obj[1] ;
5853
5854 if (!args) SWIG_fail;
5855 swig_obj[0] = args;
5856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5857 if (!SWIG_IsOK(res1)) {
5858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5859 }
5860 arg1 = reinterpret_cast< wxPoint * >(argp1);
5861 {
5862 PyThreadState* __tstate = wxPyBeginAllowThreads();
5863 delete arg1;
5864
5865 wxPyEndAllowThreads(__tstate);
5866 if (PyErr_Occurred()) SWIG_fail;
5867 }
5868 resultobj = SWIG_Py_Void();
5869 return resultobj;
5870 fail:
5871 return NULL;
5872 }
5873
5874
5875 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5876 PyObject *resultobj = 0;
5877 wxPoint *arg1 = (wxPoint *) 0 ;
5878 PyObject *arg2 = (PyObject *) 0 ;
5879 bool result;
5880 void *argp1 = 0 ;
5881 int res1 = 0 ;
5882 PyObject * obj0 = 0 ;
5883 PyObject * obj1 = 0 ;
5884 char * kwnames[] = {
5885 (char *) "self",(char *) "other", NULL
5886 };
5887
5888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5890 if (!SWIG_IsOK(res1)) {
5891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5892 }
5893 arg1 = reinterpret_cast< wxPoint * >(argp1);
5894 arg2 = obj1;
5895 {
5896 result = (bool)wxPoint___eq__(arg1,arg2);
5897 if (PyErr_Occurred()) SWIG_fail;
5898 }
5899 {
5900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5901 }
5902 return resultobj;
5903 fail:
5904 return NULL;
5905 }
5906
5907
5908 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5909 PyObject *resultobj = 0;
5910 wxPoint *arg1 = (wxPoint *) 0 ;
5911 PyObject *arg2 = (PyObject *) 0 ;
5912 bool result;
5913 void *argp1 = 0 ;
5914 int res1 = 0 ;
5915 PyObject * obj0 = 0 ;
5916 PyObject * obj1 = 0 ;
5917 char * kwnames[] = {
5918 (char *) "self",(char *) "other", NULL
5919 };
5920
5921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5923 if (!SWIG_IsOK(res1)) {
5924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5925 }
5926 arg1 = reinterpret_cast< wxPoint * >(argp1);
5927 arg2 = obj1;
5928 {
5929 result = (bool)wxPoint___ne__(arg1,arg2);
5930 if (PyErr_Occurred()) SWIG_fail;
5931 }
5932 {
5933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5934 }
5935 return resultobj;
5936 fail:
5937 return NULL;
5938 }
5939
5940
5941 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5942 PyObject *resultobj = 0;
5943 wxPoint *arg1 = (wxPoint *) 0 ;
5944 wxPoint *arg2 = 0 ;
5945 wxPoint result;
5946 void *argp1 = 0 ;
5947 int res1 = 0 ;
5948 wxPoint temp2 ;
5949 PyObject * obj0 = 0 ;
5950 PyObject * obj1 = 0 ;
5951 char * kwnames[] = {
5952 (char *) "self",(char *) "pt", NULL
5953 };
5954
5955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5957 if (!SWIG_IsOK(res1)) {
5958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5959 }
5960 arg1 = reinterpret_cast< wxPoint * >(argp1);
5961 {
5962 arg2 = &temp2;
5963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5964 }
5965 {
5966 PyThreadState* __tstate = wxPyBeginAllowThreads();
5967 result = (arg1)->operator +((wxPoint const &)*arg2);
5968 wxPyEndAllowThreads(__tstate);
5969 if (PyErr_Occurred()) SWIG_fail;
5970 }
5971 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5972 return resultobj;
5973 fail:
5974 return NULL;
5975 }
5976
5977
5978 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5979 PyObject *resultobj = 0;
5980 wxPoint *arg1 = (wxPoint *) 0 ;
5981 wxPoint *arg2 = 0 ;
5982 wxPoint result;
5983 void *argp1 = 0 ;
5984 int res1 = 0 ;
5985 wxPoint temp2 ;
5986 PyObject * obj0 = 0 ;
5987 PyObject * obj1 = 0 ;
5988 char * kwnames[] = {
5989 (char *) "self",(char *) "pt", NULL
5990 };
5991
5992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5994 if (!SWIG_IsOK(res1)) {
5995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5996 }
5997 arg1 = reinterpret_cast< wxPoint * >(argp1);
5998 {
5999 arg2 = &temp2;
6000 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6001 }
6002 {
6003 PyThreadState* __tstate = wxPyBeginAllowThreads();
6004 result = (arg1)->operator -((wxPoint const &)*arg2);
6005 wxPyEndAllowThreads(__tstate);
6006 if (PyErr_Occurred()) SWIG_fail;
6007 }
6008 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6009 return resultobj;
6010 fail:
6011 return NULL;
6012 }
6013
6014
6015 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6016 PyObject *resultobj = 0;
6017 wxPoint *arg1 = (wxPoint *) 0 ;
6018 wxPoint *arg2 = 0 ;
6019 wxPoint *result = 0 ;
6020 void *argp1 = 0 ;
6021 int res1 = 0 ;
6022 wxPoint temp2 ;
6023 PyObject * obj0 = 0 ;
6024 PyObject * obj1 = 0 ;
6025 char * kwnames[] = {
6026 (char *) "self",(char *) "pt", NULL
6027 };
6028
6029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6031 if (!SWIG_IsOK(res1)) {
6032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6033 }
6034 arg1 = reinterpret_cast< wxPoint * >(argp1);
6035 {
6036 arg2 = &temp2;
6037 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6038 }
6039 {
6040 PyThreadState* __tstate = wxPyBeginAllowThreads();
6041 {
6042 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6043 result = (wxPoint *) &_result_ref;
6044 }
6045 wxPyEndAllowThreads(__tstate);
6046 if (PyErr_Occurred()) SWIG_fail;
6047 }
6048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6049 return resultobj;
6050 fail:
6051 return NULL;
6052 }
6053
6054
6055 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6056 PyObject *resultobj = 0;
6057 wxPoint *arg1 = (wxPoint *) 0 ;
6058 wxPoint *arg2 = 0 ;
6059 wxPoint *result = 0 ;
6060 void *argp1 = 0 ;
6061 int res1 = 0 ;
6062 wxPoint temp2 ;
6063 PyObject * obj0 = 0 ;
6064 PyObject * obj1 = 0 ;
6065 char * kwnames[] = {
6066 (char *) "self",(char *) "pt", NULL
6067 };
6068
6069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6071 if (!SWIG_IsOK(res1)) {
6072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6073 }
6074 arg1 = reinterpret_cast< wxPoint * >(argp1);
6075 {
6076 arg2 = &temp2;
6077 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6078 }
6079 {
6080 PyThreadState* __tstate = wxPyBeginAllowThreads();
6081 {
6082 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6083 result = (wxPoint *) &_result_ref;
6084 }
6085 wxPyEndAllowThreads(__tstate);
6086 if (PyErr_Occurred()) SWIG_fail;
6087 }
6088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6089 return resultobj;
6090 fail:
6091 return NULL;
6092 }
6093
6094
6095 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6096 PyObject *resultobj = 0;
6097 wxPoint *arg1 = (wxPoint *) 0 ;
6098 long arg2 ;
6099 long arg3 ;
6100 void *argp1 = 0 ;
6101 int res1 = 0 ;
6102 long val2 ;
6103 int ecode2 = 0 ;
6104 long val3 ;
6105 int ecode3 = 0 ;
6106 PyObject * obj0 = 0 ;
6107 PyObject * obj1 = 0 ;
6108 PyObject * obj2 = 0 ;
6109 char * kwnames[] = {
6110 (char *) "self",(char *) "x",(char *) "y", NULL
6111 };
6112
6113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6115 if (!SWIG_IsOK(res1)) {
6116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6117 }
6118 arg1 = reinterpret_cast< wxPoint * >(argp1);
6119 ecode2 = SWIG_AsVal_long(obj1, &val2);
6120 if (!SWIG_IsOK(ecode2)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6122 }
6123 arg2 = static_cast< long >(val2);
6124 ecode3 = SWIG_AsVal_long(obj2, &val3);
6125 if (!SWIG_IsOK(ecode3)) {
6126 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6127 }
6128 arg3 = static_cast< long >(val3);
6129 {
6130 PyThreadState* __tstate = wxPyBeginAllowThreads();
6131 wxPoint_Set(arg1,arg2,arg3);
6132 wxPyEndAllowThreads(__tstate);
6133 if (PyErr_Occurred()) SWIG_fail;
6134 }
6135 resultobj = SWIG_Py_Void();
6136 return resultobj;
6137 fail:
6138 return NULL;
6139 }
6140
6141
6142 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6143 PyObject *resultobj = 0;
6144 wxPoint *arg1 = (wxPoint *) 0 ;
6145 PyObject *result = 0 ;
6146 void *argp1 = 0 ;
6147 int res1 = 0 ;
6148 PyObject *swig_obj[1] ;
6149
6150 if (!args) SWIG_fail;
6151 swig_obj[0] = args;
6152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6153 if (!SWIG_IsOK(res1)) {
6154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6155 }
6156 arg1 = reinterpret_cast< wxPoint * >(argp1);
6157 {
6158 PyThreadState* __tstate = wxPyBeginAllowThreads();
6159 result = (PyObject *)wxPoint_Get(arg1);
6160 wxPyEndAllowThreads(__tstate);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 resultobj = result;
6164 return resultobj;
6165 fail:
6166 return NULL;
6167 }
6168
6169
6170 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6171 PyObject *obj;
6172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6173 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6174 return SWIG_Py_Void();
6175 }
6176
6177 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6178 return SWIG_Python_InitShadowInstance(args);
6179 }
6180
6181 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6182 PyObject *resultobj = 0;
6183 int arg1 = (int) 0 ;
6184 int arg2 = (int) 0 ;
6185 int arg3 = (int) 0 ;
6186 int arg4 = (int) 0 ;
6187 wxRect *result = 0 ;
6188 int val1 ;
6189 int ecode1 = 0 ;
6190 int val2 ;
6191 int ecode2 = 0 ;
6192 int val3 ;
6193 int ecode3 = 0 ;
6194 int val4 ;
6195 int ecode4 = 0 ;
6196 PyObject * obj0 = 0 ;
6197 PyObject * obj1 = 0 ;
6198 PyObject * obj2 = 0 ;
6199 PyObject * obj3 = 0 ;
6200 char * kwnames[] = {
6201 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6202 };
6203
6204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6205 if (obj0) {
6206 ecode1 = SWIG_AsVal_int(obj0, &val1);
6207 if (!SWIG_IsOK(ecode1)) {
6208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6209 }
6210 arg1 = static_cast< int >(val1);
6211 }
6212 if (obj1) {
6213 ecode2 = SWIG_AsVal_int(obj1, &val2);
6214 if (!SWIG_IsOK(ecode2)) {
6215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6216 }
6217 arg2 = static_cast< int >(val2);
6218 }
6219 if (obj2) {
6220 ecode3 = SWIG_AsVal_int(obj2, &val3);
6221 if (!SWIG_IsOK(ecode3)) {
6222 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6223 }
6224 arg3 = static_cast< int >(val3);
6225 }
6226 if (obj3) {
6227 ecode4 = SWIG_AsVal_int(obj3, &val4);
6228 if (!SWIG_IsOK(ecode4)) {
6229 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6230 }
6231 arg4 = static_cast< int >(val4);
6232 }
6233 {
6234 PyThreadState* __tstate = wxPyBeginAllowThreads();
6235 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6236 wxPyEndAllowThreads(__tstate);
6237 if (PyErr_Occurred()) SWIG_fail;
6238 }
6239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6240 return resultobj;
6241 fail:
6242 return NULL;
6243 }
6244
6245
6246 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6247 PyObject *resultobj = 0;
6248 wxPoint *arg1 = 0 ;
6249 wxPoint *arg2 = 0 ;
6250 wxRect *result = 0 ;
6251 wxPoint temp1 ;
6252 wxPoint temp2 ;
6253 PyObject * obj0 = 0 ;
6254 PyObject * obj1 = 0 ;
6255 char * kwnames[] = {
6256 (char *) "topLeft",(char *) "bottomRight", NULL
6257 };
6258
6259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6260 {
6261 arg1 = &temp1;
6262 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6263 }
6264 {
6265 arg2 = &temp2;
6266 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6267 }
6268 {
6269 PyThreadState* __tstate = wxPyBeginAllowThreads();
6270 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6271 wxPyEndAllowThreads(__tstate);
6272 if (PyErr_Occurred()) SWIG_fail;
6273 }
6274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6275 return resultobj;
6276 fail:
6277 return NULL;
6278 }
6279
6280
6281 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj = 0;
6283 wxPoint *arg1 = 0 ;
6284 wxSize *arg2 = 0 ;
6285 wxRect *result = 0 ;
6286 wxPoint temp1 ;
6287 wxSize temp2 ;
6288 PyObject * obj0 = 0 ;
6289 PyObject * obj1 = 0 ;
6290 char * kwnames[] = {
6291 (char *) "pos",(char *) "size", NULL
6292 };
6293
6294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6295 {
6296 arg1 = &temp1;
6297 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6298 }
6299 {
6300 arg2 = &temp2;
6301 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6302 }
6303 {
6304 PyThreadState* __tstate = wxPyBeginAllowThreads();
6305 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6306 wxPyEndAllowThreads(__tstate);
6307 if (PyErr_Occurred()) SWIG_fail;
6308 }
6309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6310 return resultobj;
6311 fail:
6312 return NULL;
6313 }
6314
6315
6316 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6317 PyObject *resultobj = 0;
6318 wxSize *arg1 = 0 ;
6319 wxRect *result = 0 ;
6320 wxSize temp1 ;
6321 PyObject * obj0 = 0 ;
6322 char * kwnames[] = {
6323 (char *) "size", NULL
6324 };
6325
6326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6327 {
6328 arg1 = &temp1;
6329 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6330 }
6331 {
6332 PyThreadState* __tstate = wxPyBeginAllowThreads();
6333 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6345 PyObject *resultobj = 0;
6346 wxRect *arg1 = (wxRect *) 0 ;
6347 void *argp1 = 0 ;
6348 int res1 = 0 ;
6349 PyObject *swig_obj[1] ;
6350
6351 if (!args) SWIG_fail;
6352 swig_obj[0] = args;
6353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6354 if (!SWIG_IsOK(res1)) {
6355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6356 }
6357 arg1 = reinterpret_cast< wxRect * >(argp1);
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 delete arg1;
6361
6362 wxPyEndAllowThreads(__tstate);
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_Py_Void();
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int result;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 PyObject *swig_obj[1] ;
6379
6380 if (!args) SWIG_fail;
6381 swig_obj[0] = args;
6382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6383 if (!SWIG_IsOK(res1)) {
6384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6385 }
6386 arg1 = reinterpret_cast< wxRect * >(argp1);
6387 {
6388 PyThreadState* __tstate = wxPyBeginAllowThreads();
6389 result = (int)((wxRect const *)arg1)->GetX();
6390 wxPyEndAllowThreads(__tstate);
6391 if (PyErr_Occurred()) SWIG_fail;
6392 }
6393 resultobj = SWIG_From_int(static_cast< int >(result));
6394 return resultobj;
6395 fail:
6396 return NULL;
6397 }
6398
6399
6400 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6401 PyObject *resultobj = 0;
6402 wxRect *arg1 = (wxRect *) 0 ;
6403 int arg2 ;
6404 void *argp1 = 0 ;
6405 int res1 = 0 ;
6406 int val2 ;
6407 int ecode2 = 0 ;
6408 PyObject * obj0 = 0 ;
6409 PyObject * obj1 = 0 ;
6410 char * kwnames[] = {
6411 (char *) "self",(char *) "x", NULL
6412 };
6413
6414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6416 if (!SWIG_IsOK(res1)) {
6417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6418 }
6419 arg1 = reinterpret_cast< wxRect * >(argp1);
6420 ecode2 = SWIG_AsVal_int(obj1, &val2);
6421 if (!SWIG_IsOK(ecode2)) {
6422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6423 }
6424 arg2 = static_cast< int >(val2);
6425 {
6426 PyThreadState* __tstate = wxPyBeginAllowThreads();
6427 (arg1)->SetX(arg2);
6428 wxPyEndAllowThreads(__tstate);
6429 if (PyErr_Occurred()) SWIG_fail;
6430 }
6431 resultobj = SWIG_Py_Void();
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6439 PyObject *resultobj = 0;
6440 wxRect *arg1 = (wxRect *) 0 ;
6441 int result;
6442 void *argp1 = 0 ;
6443 int res1 = 0 ;
6444 PyObject *swig_obj[1] ;
6445
6446 if (!args) SWIG_fail;
6447 swig_obj[0] = args;
6448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6449 if (!SWIG_IsOK(res1)) {
6450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6451 }
6452 arg1 = reinterpret_cast< wxRect * >(argp1);
6453 {
6454 PyThreadState* __tstate = wxPyBeginAllowThreads();
6455 result = (int)(arg1)->GetY();
6456 wxPyEndAllowThreads(__tstate);
6457 if (PyErr_Occurred()) SWIG_fail;
6458 }
6459 resultobj = SWIG_From_int(static_cast< int >(result));
6460 return resultobj;
6461 fail:
6462 return NULL;
6463 }
6464
6465
6466 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj = 0;
6468 wxRect *arg1 = (wxRect *) 0 ;
6469 int arg2 ;
6470 void *argp1 = 0 ;
6471 int res1 = 0 ;
6472 int val2 ;
6473 int ecode2 = 0 ;
6474 PyObject * obj0 = 0 ;
6475 PyObject * obj1 = 0 ;
6476 char * kwnames[] = {
6477 (char *) "self",(char *) "y", NULL
6478 };
6479
6480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6482 if (!SWIG_IsOK(res1)) {
6483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6484 }
6485 arg1 = reinterpret_cast< wxRect * >(argp1);
6486 ecode2 = SWIG_AsVal_int(obj1, &val2);
6487 if (!SWIG_IsOK(ecode2)) {
6488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6489 }
6490 arg2 = static_cast< int >(val2);
6491 {
6492 PyThreadState* __tstate = wxPyBeginAllowThreads();
6493 (arg1)->SetY(arg2);
6494 wxPyEndAllowThreads(__tstate);
6495 if (PyErr_Occurred()) SWIG_fail;
6496 }
6497 resultobj = SWIG_Py_Void();
6498 return resultobj;
6499 fail:
6500 return NULL;
6501 }
6502
6503
6504 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6505 PyObject *resultobj = 0;
6506 wxRect *arg1 = (wxRect *) 0 ;
6507 int result;
6508 void *argp1 = 0 ;
6509 int res1 = 0 ;
6510 PyObject *swig_obj[1] ;
6511
6512 if (!args) SWIG_fail;
6513 swig_obj[0] = args;
6514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6515 if (!SWIG_IsOK(res1)) {
6516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6517 }
6518 arg1 = reinterpret_cast< wxRect * >(argp1);
6519 {
6520 PyThreadState* __tstate = wxPyBeginAllowThreads();
6521 result = (int)((wxRect const *)arg1)->GetWidth();
6522 wxPyEndAllowThreads(__tstate);
6523 if (PyErr_Occurred()) SWIG_fail;
6524 }
6525 resultobj = SWIG_From_int(static_cast< int >(result));
6526 return resultobj;
6527 fail:
6528 return NULL;
6529 }
6530
6531
6532 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6533 PyObject *resultobj = 0;
6534 wxRect *arg1 = (wxRect *) 0 ;
6535 int arg2 ;
6536 void *argp1 = 0 ;
6537 int res1 = 0 ;
6538 int val2 ;
6539 int ecode2 = 0 ;
6540 PyObject * obj0 = 0 ;
6541 PyObject * obj1 = 0 ;
6542 char * kwnames[] = {
6543 (char *) "self",(char *) "w", NULL
6544 };
6545
6546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6548 if (!SWIG_IsOK(res1)) {
6549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6550 }
6551 arg1 = reinterpret_cast< wxRect * >(argp1);
6552 ecode2 = SWIG_AsVal_int(obj1, &val2);
6553 if (!SWIG_IsOK(ecode2)) {
6554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6555 }
6556 arg2 = static_cast< int >(val2);
6557 {
6558 PyThreadState* __tstate = wxPyBeginAllowThreads();
6559 (arg1)->SetWidth(arg2);
6560 wxPyEndAllowThreads(__tstate);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_Py_Void();
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 int result;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 PyObject *swig_obj[1] ;
6577
6578 if (!args) SWIG_fail;
6579 swig_obj[0] = args;
6580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6581 if (!SWIG_IsOK(res1)) {
6582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6583 }
6584 arg1 = reinterpret_cast< wxRect * >(argp1);
6585 {
6586 PyThreadState* __tstate = wxPyBeginAllowThreads();
6587 result = (int)((wxRect const *)arg1)->GetHeight();
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 resultobj = SWIG_From_int(static_cast< int >(result));
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6599 PyObject *resultobj = 0;
6600 wxRect *arg1 = (wxRect *) 0 ;
6601 int arg2 ;
6602 void *argp1 = 0 ;
6603 int res1 = 0 ;
6604 int val2 ;
6605 int ecode2 = 0 ;
6606 PyObject * obj0 = 0 ;
6607 PyObject * obj1 = 0 ;
6608 char * kwnames[] = {
6609 (char *) "self",(char *) "h", NULL
6610 };
6611
6612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6614 if (!SWIG_IsOK(res1)) {
6615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6616 }
6617 arg1 = reinterpret_cast< wxRect * >(argp1);
6618 ecode2 = SWIG_AsVal_int(obj1, &val2);
6619 if (!SWIG_IsOK(ecode2)) {
6620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6621 }
6622 arg2 = static_cast< int >(val2);
6623 {
6624 PyThreadState* __tstate = wxPyBeginAllowThreads();
6625 (arg1)->SetHeight(arg2);
6626 wxPyEndAllowThreads(__tstate);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 resultobj = SWIG_Py_Void();
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6637 PyObject *resultobj = 0;
6638 wxRect *arg1 = (wxRect *) 0 ;
6639 wxPoint result;
6640 void *argp1 = 0 ;
6641 int res1 = 0 ;
6642 PyObject *swig_obj[1] ;
6643
6644 if (!args) SWIG_fail;
6645 swig_obj[0] = args;
6646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6647 if (!SWIG_IsOK(res1)) {
6648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6649 }
6650 arg1 = reinterpret_cast< wxRect * >(argp1);
6651 {
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 result = ((wxRect const *)arg1)->GetPosition();
6654 wxPyEndAllowThreads(__tstate);
6655 if (PyErr_Occurred()) SWIG_fail;
6656 }
6657 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6658 return resultobj;
6659 fail:
6660 return NULL;
6661 }
6662
6663
6664 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6665 PyObject *resultobj = 0;
6666 wxRect *arg1 = (wxRect *) 0 ;
6667 wxPoint *arg2 = 0 ;
6668 void *argp1 = 0 ;
6669 int res1 = 0 ;
6670 wxPoint temp2 ;
6671 PyObject * obj0 = 0 ;
6672 PyObject * obj1 = 0 ;
6673 char * kwnames[] = {
6674 (char *) "self",(char *) "p", NULL
6675 };
6676
6677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6679 if (!SWIG_IsOK(res1)) {
6680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6681 }
6682 arg1 = reinterpret_cast< wxRect * >(argp1);
6683 {
6684 arg2 = &temp2;
6685 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6686 }
6687 {
6688 PyThreadState* __tstate = wxPyBeginAllowThreads();
6689 (arg1)->SetPosition((wxPoint const &)*arg2);
6690 wxPyEndAllowThreads(__tstate);
6691 if (PyErr_Occurred()) SWIG_fail;
6692 }
6693 resultobj = SWIG_Py_Void();
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 wxRect *arg1 = (wxRect *) 0 ;
6703 wxSize result;
6704 void *argp1 = 0 ;
6705 int res1 = 0 ;
6706 PyObject *swig_obj[1] ;
6707
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6711 if (!SWIG_IsOK(res1)) {
6712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6713 }
6714 arg1 = reinterpret_cast< wxRect * >(argp1);
6715 {
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = ((wxRect const *)arg1)->GetSize();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6729 PyObject *resultobj = 0;
6730 wxRect *arg1 = (wxRect *) 0 ;
6731 wxSize *arg2 = 0 ;
6732 void *argp1 = 0 ;
6733 int res1 = 0 ;
6734 wxSize temp2 ;
6735 PyObject * obj0 = 0 ;
6736 PyObject * obj1 = 0 ;
6737 char * kwnames[] = {
6738 (char *) "self",(char *) "s", NULL
6739 };
6740
6741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 arg2 = &temp2;
6749 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6750 }
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 (arg1)->SetSize((wxSize const &)*arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 wxRect *arg1 = (wxRect *) 0 ;
6767 bool result;
6768 void *argp1 = 0 ;
6769 int res1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 if (!args) SWIG_fail;
6773 swig_obj[0] = args;
6774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6775 if (!SWIG_IsOK(res1)) {
6776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6777 }
6778 arg1 = reinterpret_cast< wxRect * >(argp1);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 result = (bool)((wxRect const *)arg1)->IsEmpty();
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 {
6786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6787 }
6788 return resultobj;
6789 fail:
6790 return NULL;
6791 }
6792
6793
6794 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6795 PyObject *resultobj = 0;
6796 wxRect *arg1 = (wxRect *) 0 ;
6797 wxPoint result;
6798 void *argp1 = 0 ;
6799 int res1 = 0 ;
6800 PyObject *swig_obj[1] ;
6801
6802 if (!args) SWIG_fail;
6803 swig_obj[0] = args;
6804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6805 if (!SWIG_IsOK(res1)) {
6806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6807 }
6808 arg1 = reinterpret_cast< wxRect * >(argp1);
6809 {
6810 PyThreadState* __tstate = wxPyBeginAllowThreads();
6811 result = ((wxRect const *)arg1)->GetTopLeft();
6812 wxPyEndAllowThreads(__tstate);
6813 if (PyErr_Occurred()) SWIG_fail;
6814 }
6815 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6816 return resultobj;
6817 fail:
6818 return NULL;
6819 }
6820
6821
6822 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6823 PyObject *resultobj = 0;
6824 wxRect *arg1 = (wxRect *) 0 ;
6825 wxPoint *arg2 = 0 ;
6826 void *argp1 = 0 ;
6827 int res1 = 0 ;
6828 wxPoint temp2 ;
6829 PyObject * obj0 = 0 ;
6830 PyObject * obj1 = 0 ;
6831 char * kwnames[] = {
6832 (char *) "self",(char *) "p", NULL
6833 };
6834
6835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6837 if (!SWIG_IsOK(res1)) {
6838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6839 }
6840 arg1 = reinterpret_cast< wxRect * >(argp1);
6841 {
6842 arg2 = &temp2;
6843 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6844 }
6845 {
6846 PyThreadState* __tstate = wxPyBeginAllowThreads();
6847 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6848 wxPyEndAllowThreads(__tstate);
6849 if (PyErr_Occurred()) SWIG_fail;
6850 }
6851 resultobj = SWIG_Py_Void();
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6859 PyObject *resultobj = 0;
6860 wxRect *arg1 = (wxRect *) 0 ;
6861 wxPoint result;
6862 void *argp1 = 0 ;
6863 int res1 = 0 ;
6864 PyObject *swig_obj[1] ;
6865
6866 if (!args) SWIG_fail;
6867 swig_obj[0] = args;
6868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6869 if (!SWIG_IsOK(res1)) {
6870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6871 }
6872 arg1 = reinterpret_cast< wxRect * >(argp1);
6873 {
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 result = ((wxRect const *)arg1)->GetBottomRight();
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6880 return resultobj;
6881 fail:
6882 return NULL;
6883 }
6884
6885
6886 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6887 PyObject *resultobj = 0;
6888 wxRect *arg1 = (wxRect *) 0 ;
6889 wxPoint *arg2 = 0 ;
6890 void *argp1 = 0 ;
6891 int res1 = 0 ;
6892 wxPoint temp2 ;
6893 PyObject * obj0 = 0 ;
6894 PyObject * obj1 = 0 ;
6895 char * kwnames[] = {
6896 (char *) "self",(char *) "p", NULL
6897 };
6898
6899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6901 if (!SWIG_IsOK(res1)) {
6902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6903 }
6904 arg1 = reinterpret_cast< wxRect * >(argp1);
6905 {
6906 arg2 = &temp2;
6907 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6908 }
6909 {
6910 PyThreadState* __tstate = wxPyBeginAllowThreads();
6911 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6912 wxPyEndAllowThreads(__tstate);
6913 if (PyErr_Occurred()) SWIG_fail;
6914 }
6915 resultobj = SWIG_Py_Void();
6916 return resultobj;
6917 fail:
6918 return NULL;
6919 }
6920
6921
6922 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6923 PyObject *resultobj = 0;
6924 wxRect *arg1 = (wxRect *) 0 ;
6925 wxPoint result;
6926 void *argp1 = 0 ;
6927 int res1 = 0 ;
6928 PyObject *swig_obj[1] ;
6929
6930 if (!args) SWIG_fail;
6931 swig_obj[0] = args;
6932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6933 if (!SWIG_IsOK(res1)) {
6934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6935 }
6936 arg1 = reinterpret_cast< wxRect * >(argp1);
6937 {
6938 PyThreadState* __tstate = wxPyBeginAllowThreads();
6939 result = ((wxRect const *)arg1)->GetTopRight();
6940 wxPyEndAllowThreads(__tstate);
6941 if (PyErr_Occurred()) SWIG_fail;
6942 }
6943 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6944 return resultobj;
6945 fail:
6946 return NULL;
6947 }
6948
6949
6950 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6951 PyObject *resultobj = 0;
6952 wxRect *arg1 = (wxRect *) 0 ;
6953 wxPoint *arg2 = 0 ;
6954 void *argp1 = 0 ;
6955 int res1 = 0 ;
6956 wxPoint temp2 ;
6957 PyObject * obj0 = 0 ;
6958 PyObject * obj1 = 0 ;
6959 char * kwnames[] = {
6960 (char *) "self",(char *) "p", NULL
6961 };
6962
6963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6965 if (!SWIG_IsOK(res1)) {
6966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6967 }
6968 arg1 = reinterpret_cast< wxRect * >(argp1);
6969 {
6970 arg2 = &temp2;
6971 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6972 }
6973 {
6974 PyThreadState* __tstate = wxPyBeginAllowThreads();
6975 (arg1)->SetTopRight((wxPoint const &)*arg2);
6976 wxPyEndAllowThreads(__tstate);
6977 if (PyErr_Occurred()) SWIG_fail;
6978 }
6979 resultobj = SWIG_Py_Void();
6980 return resultobj;
6981 fail:
6982 return NULL;
6983 }
6984
6985
6986 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6987 PyObject *resultobj = 0;
6988 wxRect *arg1 = (wxRect *) 0 ;
6989 wxPoint result;
6990 void *argp1 = 0 ;
6991 int res1 = 0 ;
6992 PyObject *swig_obj[1] ;
6993
6994 if (!args) SWIG_fail;
6995 swig_obj[0] = args;
6996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6997 if (!SWIG_IsOK(res1)) {
6998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6999 }
7000 arg1 = reinterpret_cast< wxRect * >(argp1);
7001 {
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 result = ((wxRect const *)arg1)->GetBottomLeft();
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7008 return resultobj;
7009 fail:
7010 return NULL;
7011 }
7012
7013
7014 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7015 PyObject *resultobj = 0;
7016 wxRect *arg1 = (wxRect *) 0 ;
7017 wxPoint *arg2 = 0 ;
7018 void *argp1 = 0 ;
7019 int res1 = 0 ;
7020 wxPoint temp2 ;
7021 PyObject * obj0 = 0 ;
7022 PyObject * obj1 = 0 ;
7023 char * kwnames[] = {
7024 (char *) "self",(char *) "p", NULL
7025 };
7026
7027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7029 if (!SWIG_IsOK(res1)) {
7030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7031 }
7032 arg1 = reinterpret_cast< wxRect * >(argp1);
7033 {
7034 arg2 = &temp2;
7035 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7036 }
7037 {
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7040 wxPyEndAllowThreads(__tstate);
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 resultobj = SWIG_Py_Void();
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7051 PyObject *resultobj = 0;
7052 wxRect *arg1 = (wxRect *) 0 ;
7053 int result;
7054 void *argp1 = 0 ;
7055 int res1 = 0 ;
7056 PyObject *swig_obj[1] ;
7057
7058 if (!args) SWIG_fail;
7059 swig_obj[0] = args;
7060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7061 if (!SWIG_IsOK(res1)) {
7062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7063 }
7064 arg1 = reinterpret_cast< wxRect * >(argp1);
7065 {
7066 PyThreadState* __tstate = wxPyBeginAllowThreads();
7067 result = (int)((wxRect const *)arg1)->GetLeft();
7068 wxPyEndAllowThreads(__tstate);
7069 if (PyErr_Occurred()) SWIG_fail;
7070 }
7071 resultobj = SWIG_From_int(static_cast< int >(result));
7072 return resultobj;
7073 fail:
7074 return NULL;
7075 }
7076
7077
7078 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7079 PyObject *resultobj = 0;
7080 wxRect *arg1 = (wxRect *) 0 ;
7081 int result;
7082 void *argp1 = 0 ;
7083 int res1 = 0 ;
7084 PyObject *swig_obj[1] ;
7085
7086 if (!args) SWIG_fail;
7087 swig_obj[0] = args;
7088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7089 if (!SWIG_IsOK(res1)) {
7090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7091 }
7092 arg1 = reinterpret_cast< wxRect * >(argp1);
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 result = (int)((wxRect const *)arg1)->GetTop();
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 resultobj = SWIG_From_int(static_cast< int >(result));
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7107 PyObject *resultobj = 0;
7108 wxRect *arg1 = (wxRect *) 0 ;
7109 int result;
7110 void *argp1 = 0 ;
7111 int res1 = 0 ;
7112 PyObject *swig_obj[1] ;
7113
7114 if (!args) SWIG_fail;
7115 swig_obj[0] = args;
7116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7117 if (!SWIG_IsOK(res1)) {
7118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7119 }
7120 arg1 = reinterpret_cast< wxRect * >(argp1);
7121 {
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (int)((wxRect const *)arg1)->GetBottom();
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 resultobj = SWIG_From_int(static_cast< int >(result));
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7135 PyObject *resultobj = 0;
7136 wxRect *arg1 = (wxRect *) 0 ;
7137 int result;
7138 void *argp1 = 0 ;
7139 int res1 = 0 ;
7140 PyObject *swig_obj[1] ;
7141
7142 if (!args) SWIG_fail;
7143 swig_obj[0] = args;
7144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7145 if (!SWIG_IsOK(res1)) {
7146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7147 }
7148 arg1 = reinterpret_cast< wxRect * >(argp1);
7149 {
7150 PyThreadState* __tstate = wxPyBeginAllowThreads();
7151 result = (int)((wxRect const *)arg1)->GetRight();
7152 wxPyEndAllowThreads(__tstate);
7153 if (PyErr_Occurred()) SWIG_fail;
7154 }
7155 resultobj = SWIG_From_int(static_cast< int >(result));
7156 return resultobj;
7157 fail:
7158 return NULL;
7159 }
7160
7161
7162 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7163 PyObject *resultobj = 0;
7164 wxRect *arg1 = (wxRect *) 0 ;
7165 int arg2 ;
7166 void *argp1 = 0 ;
7167 int res1 = 0 ;
7168 int val2 ;
7169 int ecode2 = 0 ;
7170 PyObject * obj0 = 0 ;
7171 PyObject * obj1 = 0 ;
7172 char * kwnames[] = {
7173 (char *) "self",(char *) "left", NULL
7174 };
7175
7176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7178 if (!SWIG_IsOK(res1)) {
7179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7180 }
7181 arg1 = reinterpret_cast< wxRect * >(argp1);
7182 ecode2 = SWIG_AsVal_int(obj1, &val2);
7183 if (!SWIG_IsOK(ecode2)) {
7184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7185 }
7186 arg2 = static_cast< int >(val2);
7187 {
7188 PyThreadState* __tstate = wxPyBeginAllowThreads();
7189 (arg1)->SetLeft(arg2);
7190 wxPyEndAllowThreads(__tstate);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 resultobj = SWIG_Py_Void();
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj = 0;
7202 wxRect *arg1 = (wxRect *) 0 ;
7203 int arg2 ;
7204 void *argp1 = 0 ;
7205 int res1 = 0 ;
7206 int val2 ;
7207 int ecode2 = 0 ;
7208 PyObject * obj0 = 0 ;
7209 PyObject * obj1 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "self",(char *) "right", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7216 if (!SWIG_IsOK(res1)) {
7217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7218 }
7219 arg1 = reinterpret_cast< wxRect * >(argp1);
7220 ecode2 = SWIG_AsVal_int(obj1, &val2);
7221 if (!SWIG_IsOK(ecode2)) {
7222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7223 }
7224 arg2 = static_cast< int >(val2);
7225 {
7226 PyThreadState* __tstate = wxPyBeginAllowThreads();
7227 (arg1)->SetRight(arg2);
7228 wxPyEndAllowThreads(__tstate);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 resultobj = SWIG_Py_Void();
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7239 PyObject *resultobj = 0;
7240 wxRect *arg1 = (wxRect *) 0 ;
7241 int arg2 ;
7242 void *argp1 = 0 ;
7243 int res1 = 0 ;
7244 int val2 ;
7245 int ecode2 = 0 ;
7246 PyObject * obj0 = 0 ;
7247 PyObject * obj1 = 0 ;
7248 char * kwnames[] = {
7249 (char *) "self",(char *) "top", NULL
7250 };
7251
7252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7254 if (!SWIG_IsOK(res1)) {
7255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7256 }
7257 arg1 = reinterpret_cast< wxRect * >(argp1);
7258 ecode2 = SWIG_AsVal_int(obj1, &val2);
7259 if (!SWIG_IsOK(ecode2)) {
7260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7261 }
7262 arg2 = static_cast< int >(val2);
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 (arg1)->SetTop(arg2);
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 resultobj = SWIG_Py_Void();
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj = 0;
7278 wxRect *arg1 = (wxRect *) 0 ;
7279 int arg2 ;
7280 void *argp1 = 0 ;
7281 int res1 = 0 ;
7282 int val2 ;
7283 int ecode2 = 0 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "self",(char *) "bottom", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7292 if (!SWIG_IsOK(res1)) {
7293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7294 }
7295 arg1 = reinterpret_cast< wxRect * >(argp1);
7296 ecode2 = SWIG_AsVal_int(obj1, &val2);
7297 if (!SWIG_IsOK(ecode2)) {
7298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7299 }
7300 arg2 = static_cast< int >(val2);
7301 {
7302 PyThreadState* __tstate = wxPyBeginAllowThreads();
7303 (arg1)->SetBottom(arg2);
7304 wxPyEndAllowThreads(__tstate);
7305 if (PyErr_Occurred()) SWIG_fail;
7306 }
7307 resultobj = SWIG_Py_Void();
7308 return resultobj;
7309 fail:
7310 return NULL;
7311 }
7312
7313
7314 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7315 PyObject *resultobj = 0;
7316 wxRect *arg1 = (wxRect *) 0 ;
7317 int arg2 ;
7318 int arg3 ;
7319 wxRect *result = 0 ;
7320 void *argp1 = 0 ;
7321 int res1 = 0 ;
7322 int val2 ;
7323 int ecode2 = 0 ;
7324 int val3 ;
7325 int ecode3 = 0 ;
7326 PyObject * obj0 = 0 ;
7327 PyObject * obj1 = 0 ;
7328 PyObject * obj2 = 0 ;
7329 char * kwnames[] = {
7330 (char *) "self",(char *) "dx",(char *) "dy", NULL
7331 };
7332
7333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7335 if (!SWIG_IsOK(res1)) {
7336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7337 }
7338 arg1 = reinterpret_cast< wxRect * >(argp1);
7339 ecode2 = SWIG_AsVal_int(obj1, &val2);
7340 if (!SWIG_IsOK(ecode2)) {
7341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7342 }
7343 arg2 = static_cast< int >(val2);
7344 ecode3 = SWIG_AsVal_int(obj2, &val3);
7345 if (!SWIG_IsOK(ecode3)) {
7346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7347 }
7348 arg3 = static_cast< int >(val3);
7349 {
7350 PyThreadState* __tstate = wxPyBeginAllowThreads();
7351 {
7352 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7353 result = (wxRect *) &_result_ref;
7354 }
7355 wxPyEndAllowThreads(__tstate);
7356 if (PyErr_Occurred()) SWIG_fail;
7357 }
7358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7359 return resultobj;
7360 fail:
7361 return NULL;
7362 }
7363
7364
7365 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7366 PyObject *resultobj = 0;
7367 wxRect *arg1 = (wxRect *) 0 ;
7368 int arg2 ;
7369 int arg3 ;
7370 wxRect *result = 0 ;
7371 void *argp1 = 0 ;
7372 int res1 = 0 ;
7373 int val2 ;
7374 int ecode2 = 0 ;
7375 int val3 ;
7376 int ecode3 = 0 ;
7377 PyObject * obj0 = 0 ;
7378 PyObject * obj1 = 0 ;
7379 PyObject * obj2 = 0 ;
7380 char * kwnames[] = {
7381 (char *) "self",(char *) "dx",(char *) "dy", NULL
7382 };
7383
7384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7386 if (!SWIG_IsOK(res1)) {
7387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7388 }
7389 arg1 = reinterpret_cast< wxRect * >(argp1);
7390 ecode2 = SWIG_AsVal_int(obj1, &val2);
7391 if (!SWIG_IsOK(ecode2)) {
7392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7393 }
7394 arg2 = static_cast< int >(val2);
7395 ecode3 = SWIG_AsVal_int(obj2, &val3);
7396 if (!SWIG_IsOK(ecode3)) {
7397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7398 }
7399 arg3 = static_cast< int >(val3);
7400 {
7401 PyThreadState* __tstate = wxPyBeginAllowThreads();
7402 {
7403 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7404 result = (wxRect *) &_result_ref;
7405 }
7406 wxPyEndAllowThreads(__tstate);
7407 if (PyErr_Occurred()) SWIG_fail;
7408 }
7409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7410 return resultobj;
7411 fail:
7412 return NULL;
7413 }
7414
7415
7416 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7417 PyObject *resultobj = 0;
7418 wxRect *arg1 = (wxRect *) 0 ;
7419 int arg2 ;
7420 int arg3 ;
7421 void *argp1 = 0 ;
7422 int res1 = 0 ;
7423 int val2 ;
7424 int ecode2 = 0 ;
7425 int val3 ;
7426 int ecode3 = 0 ;
7427 PyObject * obj0 = 0 ;
7428 PyObject * obj1 = 0 ;
7429 PyObject * obj2 = 0 ;
7430 char * kwnames[] = {
7431 (char *) "self",(char *) "dx",(char *) "dy", NULL
7432 };
7433
7434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7436 if (!SWIG_IsOK(res1)) {
7437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7438 }
7439 arg1 = reinterpret_cast< wxRect * >(argp1);
7440 ecode2 = SWIG_AsVal_int(obj1, &val2);
7441 if (!SWIG_IsOK(ecode2)) {
7442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7443 }
7444 arg2 = static_cast< int >(val2);
7445 ecode3 = SWIG_AsVal_int(obj2, &val3);
7446 if (!SWIG_IsOK(ecode3)) {
7447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7448 }
7449 arg3 = static_cast< int >(val3);
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 (arg1)->Offset(arg2,arg3);
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 resultobj = SWIG_Py_Void();
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj = 0;
7465 wxRect *arg1 = (wxRect *) 0 ;
7466 wxPoint *arg2 = 0 ;
7467 void *argp1 = 0 ;
7468 int res1 = 0 ;
7469 wxPoint temp2 ;
7470 PyObject * obj0 = 0 ;
7471 PyObject * obj1 = 0 ;
7472 char * kwnames[] = {
7473 (char *) "self",(char *) "pt", NULL
7474 };
7475
7476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7478 if (!SWIG_IsOK(res1)) {
7479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7480 }
7481 arg1 = reinterpret_cast< wxRect * >(argp1);
7482 {
7483 arg2 = &temp2;
7484 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7485 }
7486 {
7487 PyThreadState* __tstate = wxPyBeginAllowThreads();
7488 (arg1)->Offset((wxPoint const &)*arg2);
7489 wxPyEndAllowThreads(__tstate);
7490 if (PyErr_Occurred()) SWIG_fail;
7491 }
7492 resultobj = SWIG_Py_Void();
7493 return resultobj;
7494 fail:
7495 return NULL;
7496 }
7497
7498
7499 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7500 PyObject *resultobj = 0;
7501 wxRect *arg1 = (wxRect *) 0 ;
7502 wxRect *arg2 = 0 ;
7503 wxRect result;
7504 void *argp1 = 0 ;
7505 int res1 = 0 ;
7506 wxRect temp2 ;
7507 PyObject * obj0 = 0 ;
7508 PyObject * obj1 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "rect", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7517 }
7518 arg1 = reinterpret_cast< wxRect * >(argp1);
7519 {
7520 arg2 = &temp2;
7521 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7522 }
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 result = (arg1)->Intersect((wxRect const &)*arg2);
7526 wxPyEndAllowThreads(__tstate);
7527 if (PyErr_Occurred()) SWIG_fail;
7528 }
7529 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7530 return resultobj;
7531 fail:
7532 return NULL;
7533 }
7534
7535
7536 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7537 PyObject *resultobj = 0;
7538 wxRect *arg1 = (wxRect *) 0 ;
7539 wxRect *arg2 = 0 ;
7540 wxRect result;
7541 void *argp1 = 0 ;
7542 int res1 = 0 ;
7543 wxRect temp2 ;
7544 PyObject * obj0 = 0 ;
7545 PyObject * obj1 = 0 ;
7546 char * kwnames[] = {
7547 (char *) "self",(char *) "rect", NULL
7548 };
7549
7550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7552 if (!SWIG_IsOK(res1)) {
7553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7554 }
7555 arg1 = reinterpret_cast< wxRect * >(argp1);
7556 {
7557 arg2 = &temp2;
7558 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7559 }
7560 {
7561 PyThreadState* __tstate = wxPyBeginAllowThreads();
7562 result = (arg1)->Union((wxRect const &)*arg2);
7563 wxPyEndAllowThreads(__tstate);
7564 if (PyErr_Occurred()) SWIG_fail;
7565 }
7566 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7567 return resultobj;
7568 fail:
7569 return NULL;
7570 }
7571
7572
7573 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7574 PyObject *resultobj = 0;
7575 wxRect *arg1 = (wxRect *) 0 ;
7576 wxRect *arg2 = 0 ;
7577 wxRect result;
7578 void *argp1 = 0 ;
7579 int res1 = 0 ;
7580 wxRect temp2 ;
7581 PyObject * obj0 = 0 ;
7582 PyObject * obj1 = 0 ;
7583 char * kwnames[] = {
7584 (char *) "self",(char *) "rect", NULL
7585 };
7586
7587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7589 if (!SWIG_IsOK(res1)) {
7590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7591 }
7592 arg1 = reinterpret_cast< wxRect * >(argp1);
7593 {
7594 arg2 = &temp2;
7595 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7596 }
7597 {
7598 PyThreadState* __tstate = wxPyBeginAllowThreads();
7599 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7600 wxPyEndAllowThreads(__tstate);
7601 if (PyErr_Occurred()) SWIG_fail;
7602 }
7603 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
7610 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7611 PyObject *resultobj = 0;
7612 wxRect *arg1 = (wxRect *) 0 ;
7613 wxRect *arg2 = 0 ;
7614 wxRect *result = 0 ;
7615 void *argp1 = 0 ;
7616 int res1 = 0 ;
7617 wxRect temp2 ;
7618 PyObject * obj0 = 0 ;
7619 PyObject * obj1 = 0 ;
7620 char * kwnames[] = {
7621 (char *) "self",(char *) "rect", NULL
7622 };
7623
7624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7626 if (!SWIG_IsOK(res1)) {
7627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7628 }
7629 arg1 = reinterpret_cast< wxRect * >(argp1);
7630 {
7631 arg2 = &temp2;
7632 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7633 }
7634 {
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 {
7637 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7638 result = (wxRect *) &_result_ref;
7639 }
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7651 PyObject *resultobj = 0;
7652 wxRect *arg1 = (wxRect *) 0 ;
7653 PyObject *arg2 = (PyObject *) 0 ;
7654 bool result;
7655 void *argp1 = 0 ;
7656 int res1 = 0 ;
7657 PyObject * obj0 = 0 ;
7658 PyObject * obj1 = 0 ;
7659 char * kwnames[] = {
7660 (char *) "self",(char *) "other", NULL
7661 };
7662
7663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7665 if (!SWIG_IsOK(res1)) {
7666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7667 }
7668 arg1 = reinterpret_cast< wxRect * >(argp1);
7669 arg2 = obj1;
7670 {
7671 result = (bool)wxRect___eq__(arg1,arg2);
7672 if (PyErr_Occurred()) SWIG_fail;
7673 }
7674 {
7675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7676 }
7677 return resultobj;
7678 fail:
7679 return NULL;
7680 }
7681
7682
7683 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7684 PyObject *resultobj = 0;
7685 wxRect *arg1 = (wxRect *) 0 ;
7686 PyObject *arg2 = (PyObject *) 0 ;
7687 bool result;
7688 void *argp1 = 0 ;
7689 int res1 = 0 ;
7690 PyObject * obj0 = 0 ;
7691 PyObject * obj1 = 0 ;
7692 char * kwnames[] = {
7693 (char *) "self",(char *) "other", NULL
7694 };
7695
7696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7698 if (!SWIG_IsOK(res1)) {
7699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7700 }
7701 arg1 = reinterpret_cast< wxRect * >(argp1);
7702 arg2 = obj1;
7703 {
7704 result = (bool)wxRect___ne__(arg1,arg2);
7705 if (PyErr_Occurred()) SWIG_fail;
7706 }
7707 {
7708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7709 }
7710 return resultobj;
7711 fail:
7712 return NULL;
7713 }
7714
7715
7716 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7717 PyObject *resultobj = 0;
7718 wxRect *arg1 = (wxRect *) 0 ;
7719 int arg2 ;
7720 int arg3 ;
7721 bool result;
7722 void *argp1 = 0 ;
7723 int res1 = 0 ;
7724 int val2 ;
7725 int ecode2 = 0 ;
7726 int val3 ;
7727 int ecode3 = 0 ;
7728 PyObject * obj0 = 0 ;
7729 PyObject * obj1 = 0 ;
7730 PyObject * obj2 = 0 ;
7731 char * kwnames[] = {
7732 (char *) "self",(char *) "x",(char *) "y", NULL
7733 };
7734
7735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7737 if (!SWIG_IsOK(res1)) {
7738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7739 }
7740 arg1 = reinterpret_cast< wxRect * >(argp1);
7741 ecode2 = SWIG_AsVal_int(obj1, &val2);
7742 if (!SWIG_IsOK(ecode2)) {
7743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7744 }
7745 arg2 = static_cast< int >(val2);
7746 ecode3 = SWIG_AsVal_int(obj2, &val3);
7747 if (!SWIG_IsOK(ecode3)) {
7748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7749 }
7750 arg3 = static_cast< int >(val3);
7751 {
7752 PyThreadState* __tstate = wxPyBeginAllowThreads();
7753 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7754 wxPyEndAllowThreads(__tstate);
7755 if (PyErr_Occurred()) SWIG_fail;
7756 }
7757 {
7758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7759 }
7760 return resultobj;
7761 fail:
7762 return NULL;
7763 }
7764
7765
7766 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7767 PyObject *resultobj = 0;
7768 wxRect *arg1 = (wxRect *) 0 ;
7769 wxPoint *arg2 = 0 ;
7770 bool result;
7771 void *argp1 = 0 ;
7772 int res1 = 0 ;
7773 wxPoint temp2 ;
7774 PyObject * obj0 = 0 ;
7775 PyObject * obj1 = 0 ;
7776 char * kwnames[] = {
7777 (char *) "self",(char *) "pt", NULL
7778 };
7779
7780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7782 if (!SWIG_IsOK(res1)) {
7783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7784 }
7785 arg1 = reinterpret_cast< wxRect * >(argp1);
7786 {
7787 arg2 = &temp2;
7788 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7789 }
7790 {
7791 PyThreadState* __tstate = wxPyBeginAllowThreads();
7792 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7793 wxPyEndAllowThreads(__tstate);
7794 if (PyErr_Occurred()) SWIG_fail;
7795 }
7796 {
7797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7798 }
7799 return resultobj;
7800 fail:
7801 return NULL;
7802 }
7803
7804
7805 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7806 PyObject *resultobj = 0;
7807 wxRect *arg1 = (wxRect *) 0 ;
7808 wxRect *arg2 = 0 ;
7809 bool result;
7810 void *argp1 = 0 ;
7811 int res1 = 0 ;
7812 wxRect temp2 ;
7813 PyObject * obj0 = 0 ;
7814 PyObject * obj1 = 0 ;
7815 char * kwnames[] = {
7816 (char *) "self",(char *) "rect", NULL
7817 };
7818
7819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7821 if (!SWIG_IsOK(res1)) {
7822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7823 }
7824 arg1 = reinterpret_cast< wxRect * >(argp1);
7825 {
7826 arg2 = &temp2;
7827 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7828 }
7829 {
7830 PyThreadState* __tstate = wxPyBeginAllowThreads();
7831 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7832 wxPyEndAllowThreads(__tstate);
7833 if (PyErr_Occurred()) SWIG_fail;
7834 }
7835 {
7836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7837 }
7838 return resultobj;
7839 fail:
7840 return NULL;
7841 }
7842
7843
7844 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7845 PyObject *resultobj = 0;
7846 wxRect *arg1 = (wxRect *) 0 ;
7847 wxRect *arg2 = 0 ;
7848 bool result;
7849 void *argp1 = 0 ;
7850 int res1 = 0 ;
7851 wxRect temp2 ;
7852 PyObject * obj0 = 0 ;
7853 PyObject * obj1 = 0 ;
7854 char * kwnames[] = {
7855 (char *) "self",(char *) "rect", NULL
7856 };
7857
7858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7860 if (!SWIG_IsOK(res1)) {
7861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7862 }
7863 arg1 = reinterpret_cast< wxRect * >(argp1);
7864 {
7865 arg2 = &temp2;
7866 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7867 }
7868 {
7869 PyThreadState* __tstate = wxPyBeginAllowThreads();
7870 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7871 wxPyEndAllowThreads(__tstate);
7872 if (PyErr_Occurred()) SWIG_fail;
7873 }
7874 {
7875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7876 }
7877 return resultobj;
7878 fail:
7879 return NULL;
7880 }
7881
7882
7883 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7884 PyObject *resultobj = 0;
7885 wxRect *arg1 = (wxRect *) 0 ;
7886 wxRect *arg2 = 0 ;
7887 int arg3 = (int) wxBOTH ;
7888 wxRect result;
7889 void *argp1 = 0 ;
7890 int res1 = 0 ;
7891 wxRect temp2 ;
7892 int val3 ;
7893 int ecode3 = 0 ;
7894 PyObject * obj0 = 0 ;
7895 PyObject * obj1 = 0 ;
7896 PyObject * obj2 = 0 ;
7897 char * kwnames[] = {
7898 (char *) "self",(char *) "r",(char *) "dir", NULL
7899 };
7900
7901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7903 if (!SWIG_IsOK(res1)) {
7904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7905 }
7906 arg1 = reinterpret_cast< wxRect * >(argp1);
7907 {
7908 arg2 = &temp2;
7909 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7910 }
7911 if (obj2) {
7912 ecode3 = SWIG_AsVal_int(obj2, &val3);
7913 if (!SWIG_IsOK(ecode3)) {
7914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7915 }
7916 arg3 = static_cast< int >(val3);
7917 }
7918 {
7919 PyThreadState* __tstate = wxPyBeginAllowThreads();
7920 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7921 wxPyEndAllowThreads(__tstate);
7922 if (PyErr_Occurred()) SWIG_fail;
7923 }
7924 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7925 return resultobj;
7926 fail:
7927 return NULL;
7928 }
7929
7930
7931 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7932 PyObject *resultobj = 0;
7933 wxRect *arg1 = (wxRect *) 0 ;
7934 int arg2 ;
7935 void *argp1 = 0 ;
7936 int res1 = 0 ;
7937 int val2 ;
7938 int ecode2 = 0 ;
7939 PyObject *swig_obj[2] ;
7940
7941 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7943 if (!SWIG_IsOK(res1)) {
7944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7945 }
7946 arg1 = reinterpret_cast< wxRect * >(argp1);
7947 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7948 if (!SWIG_IsOK(ecode2)) {
7949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7950 }
7951 arg2 = static_cast< int >(val2);
7952 if (arg1) (arg1)->x = arg2;
7953
7954 resultobj = SWIG_Py_Void();
7955 return resultobj;
7956 fail:
7957 return NULL;
7958 }
7959
7960
7961 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7962 PyObject *resultobj = 0;
7963 wxRect *arg1 = (wxRect *) 0 ;
7964 int result;
7965 void *argp1 = 0 ;
7966 int res1 = 0 ;
7967 PyObject *swig_obj[1] ;
7968
7969 if (!args) SWIG_fail;
7970 swig_obj[0] = args;
7971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7972 if (!SWIG_IsOK(res1)) {
7973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7974 }
7975 arg1 = reinterpret_cast< wxRect * >(argp1);
7976 result = (int) ((arg1)->x);
7977 resultobj = SWIG_From_int(static_cast< int >(result));
7978 return resultobj;
7979 fail:
7980 return NULL;
7981 }
7982
7983
7984 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7985 PyObject *resultobj = 0;
7986 wxRect *arg1 = (wxRect *) 0 ;
7987 int arg2 ;
7988 void *argp1 = 0 ;
7989 int res1 = 0 ;
7990 int val2 ;
7991 int ecode2 = 0 ;
7992 PyObject *swig_obj[2] ;
7993
7994 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7996 if (!SWIG_IsOK(res1)) {
7997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7998 }
7999 arg1 = reinterpret_cast< wxRect * >(argp1);
8000 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8001 if (!SWIG_IsOK(ecode2)) {
8002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8003 }
8004 arg2 = static_cast< int >(val2);
8005 if (arg1) (arg1)->y = arg2;
8006
8007 resultobj = SWIG_Py_Void();
8008 return resultobj;
8009 fail:
8010 return NULL;
8011 }
8012
8013
8014 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8015 PyObject *resultobj = 0;
8016 wxRect *arg1 = (wxRect *) 0 ;
8017 int result;
8018 void *argp1 = 0 ;
8019 int res1 = 0 ;
8020 PyObject *swig_obj[1] ;
8021
8022 if (!args) SWIG_fail;
8023 swig_obj[0] = args;
8024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8025 if (!SWIG_IsOK(res1)) {
8026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8027 }
8028 arg1 = reinterpret_cast< wxRect * >(argp1);
8029 result = (int) ((arg1)->y);
8030 resultobj = SWIG_From_int(static_cast< int >(result));
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8038 PyObject *resultobj = 0;
8039 wxRect *arg1 = (wxRect *) 0 ;
8040 int arg2 ;
8041 void *argp1 = 0 ;
8042 int res1 = 0 ;
8043 int val2 ;
8044 int ecode2 = 0 ;
8045 PyObject *swig_obj[2] ;
8046
8047 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8049 if (!SWIG_IsOK(res1)) {
8050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8051 }
8052 arg1 = reinterpret_cast< wxRect * >(argp1);
8053 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8054 if (!SWIG_IsOK(ecode2)) {
8055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8056 }
8057 arg2 = static_cast< int >(val2);
8058 if (arg1) (arg1)->width = arg2;
8059
8060 resultobj = SWIG_Py_Void();
8061 return resultobj;
8062 fail:
8063 return NULL;
8064 }
8065
8066
8067 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8068 PyObject *resultobj = 0;
8069 wxRect *arg1 = (wxRect *) 0 ;
8070 int result;
8071 void *argp1 = 0 ;
8072 int res1 = 0 ;
8073 PyObject *swig_obj[1] ;
8074
8075 if (!args) SWIG_fail;
8076 swig_obj[0] = args;
8077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8078 if (!SWIG_IsOK(res1)) {
8079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8080 }
8081 arg1 = reinterpret_cast< wxRect * >(argp1);
8082 result = (int) ((arg1)->width);
8083 resultobj = SWIG_From_int(static_cast< int >(result));
8084 return resultobj;
8085 fail:
8086 return NULL;
8087 }
8088
8089
8090 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8091 PyObject *resultobj = 0;
8092 wxRect *arg1 = (wxRect *) 0 ;
8093 int arg2 ;
8094 void *argp1 = 0 ;
8095 int res1 = 0 ;
8096 int val2 ;
8097 int ecode2 = 0 ;
8098 PyObject *swig_obj[2] ;
8099
8100 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8102 if (!SWIG_IsOK(res1)) {
8103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8104 }
8105 arg1 = reinterpret_cast< wxRect * >(argp1);
8106 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8107 if (!SWIG_IsOK(ecode2)) {
8108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8109 }
8110 arg2 = static_cast< int >(val2);
8111 if (arg1) (arg1)->height = arg2;
8112
8113 resultobj = SWIG_Py_Void();
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8121 PyObject *resultobj = 0;
8122 wxRect *arg1 = (wxRect *) 0 ;
8123 int result;
8124 void *argp1 = 0 ;
8125 int res1 = 0 ;
8126 PyObject *swig_obj[1] ;
8127
8128 if (!args) SWIG_fail;
8129 swig_obj[0] = args;
8130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8131 if (!SWIG_IsOK(res1)) {
8132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8133 }
8134 arg1 = reinterpret_cast< wxRect * >(argp1);
8135 result = (int) ((arg1)->height);
8136 resultobj = SWIG_From_int(static_cast< int >(result));
8137 return resultobj;
8138 fail:
8139 return NULL;
8140 }
8141
8142
8143 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8144 PyObject *resultobj = 0;
8145 wxRect *arg1 = (wxRect *) 0 ;
8146 int arg2 = (int) 0 ;
8147 int arg3 = (int) 0 ;
8148 int arg4 = (int) 0 ;
8149 int arg5 = (int) 0 ;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 int val2 ;
8153 int ecode2 = 0 ;
8154 int val3 ;
8155 int ecode3 = 0 ;
8156 int val4 ;
8157 int ecode4 = 0 ;
8158 int val5 ;
8159 int ecode5 = 0 ;
8160 PyObject * obj0 = 0 ;
8161 PyObject * obj1 = 0 ;
8162 PyObject * obj2 = 0 ;
8163 PyObject * obj3 = 0 ;
8164 PyObject * obj4 = 0 ;
8165 char * kwnames[] = {
8166 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8167 };
8168
8169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8171 if (!SWIG_IsOK(res1)) {
8172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8173 }
8174 arg1 = reinterpret_cast< wxRect * >(argp1);
8175 if (obj1) {
8176 ecode2 = SWIG_AsVal_int(obj1, &val2);
8177 if (!SWIG_IsOK(ecode2)) {
8178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8179 }
8180 arg2 = static_cast< int >(val2);
8181 }
8182 if (obj2) {
8183 ecode3 = SWIG_AsVal_int(obj2, &val3);
8184 if (!SWIG_IsOK(ecode3)) {
8185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8186 }
8187 arg3 = static_cast< int >(val3);
8188 }
8189 if (obj3) {
8190 ecode4 = SWIG_AsVal_int(obj3, &val4);
8191 if (!SWIG_IsOK(ecode4)) {
8192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8193 }
8194 arg4 = static_cast< int >(val4);
8195 }
8196 if (obj4) {
8197 ecode5 = SWIG_AsVal_int(obj4, &val5);
8198 if (!SWIG_IsOK(ecode5)) {
8199 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8200 }
8201 arg5 = static_cast< int >(val5);
8202 }
8203 {
8204 PyThreadState* __tstate = wxPyBeginAllowThreads();
8205 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8206 wxPyEndAllowThreads(__tstate);
8207 if (PyErr_Occurred()) SWIG_fail;
8208 }
8209 resultobj = SWIG_Py_Void();
8210 return resultobj;
8211 fail:
8212 return NULL;
8213 }
8214
8215
8216 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8217 PyObject *resultobj = 0;
8218 wxRect *arg1 = (wxRect *) 0 ;
8219 PyObject *result = 0 ;
8220 void *argp1 = 0 ;
8221 int res1 = 0 ;
8222 PyObject *swig_obj[1] ;
8223
8224 if (!args) SWIG_fail;
8225 swig_obj[0] = args;
8226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8227 if (!SWIG_IsOK(res1)) {
8228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8229 }
8230 arg1 = reinterpret_cast< wxRect * >(argp1);
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 result = (PyObject *)wxRect_Get(arg1);
8234 wxPyEndAllowThreads(__tstate);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 resultobj = result;
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8245 PyObject *obj;
8246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8247 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8248 return SWIG_Py_Void();
8249 }
8250
8251 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8252 return SWIG_Python_InitShadowInstance(args);
8253 }
8254
8255 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8256 PyObject *resultobj = 0;
8257 wxRect *arg1 = (wxRect *) 0 ;
8258 wxRect *arg2 = (wxRect *) 0 ;
8259 PyObject *result = 0 ;
8260 void *argp1 = 0 ;
8261 int res1 = 0 ;
8262 void *argp2 = 0 ;
8263 int res2 = 0 ;
8264 PyObject * obj0 = 0 ;
8265 PyObject * obj1 = 0 ;
8266 char * kwnames[] = {
8267 (char *) "r1",(char *) "r2", NULL
8268 };
8269
8270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8272 if (!SWIG_IsOK(res1)) {
8273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8274 }
8275 arg1 = reinterpret_cast< wxRect * >(argp1);
8276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8277 if (!SWIG_IsOK(res2)) {
8278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8279 }
8280 arg2 = reinterpret_cast< wxRect * >(argp2);
8281 {
8282 if (!wxPyCheckForApp()) SWIG_fail;
8283 PyThreadState* __tstate = wxPyBeginAllowThreads();
8284 result = (PyObject *)wxIntersectRect(arg1,arg2);
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 resultobj = result;
8289 return resultobj;
8290 fail:
8291 return NULL;
8292 }
8293
8294
8295 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8296 PyObject *resultobj = 0;
8297 double arg1 = (double) 0.0 ;
8298 double arg2 = (double) 0.0 ;
8299 wxPoint2D *result = 0 ;
8300 double val1 ;
8301 int ecode1 = 0 ;
8302 double val2 ;
8303 int ecode2 = 0 ;
8304 PyObject * obj0 = 0 ;
8305 PyObject * obj1 = 0 ;
8306 char * kwnames[] = {
8307 (char *) "x",(char *) "y", NULL
8308 };
8309
8310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8311 if (obj0) {
8312 ecode1 = SWIG_AsVal_double(obj0, &val1);
8313 if (!SWIG_IsOK(ecode1)) {
8314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8315 }
8316 arg1 = static_cast< double >(val1);
8317 }
8318 if (obj1) {
8319 ecode2 = SWIG_AsVal_double(obj1, &val2);
8320 if (!SWIG_IsOK(ecode2)) {
8321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8322 }
8323 arg2 = static_cast< double >(val2);
8324 }
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8332 return resultobj;
8333 fail:
8334 return NULL;
8335 }
8336
8337
8338 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8339 PyObject *resultobj = 0;
8340 wxPoint2D *arg1 = 0 ;
8341 wxPoint2D *result = 0 ;
8342 wxPoint2D temp1 ;
8343 PyObject * obj0 = 0 ;
8344 char * kwnames[] = {
8345 (char *) "pt", NULL
8346 };
8347
8348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8349 {
8350 arg1 = &temp1;
8351 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8352 }
8353 {
8354 PyThreadState* __tstate = wxPyBeginAllowThreads();
8355 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8356 wxPyEndAllowThreads(__tstate);
8357 if (PyErr_Occurred()) SWIG_fail;
8358 }
8359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8360 return resultobj;
8361 fail:
8362 return NULL;
8363 }
8364
8365
8366 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8367 PyObject *resultobj = 0;
8368 wxPoint *arg1 = 0 ;
8369 wxPoint2D *result = 0 ;
8370 wxPoint temp1 ;
8371 PyObject * obj0 = 0 ;
8372 char * kwnames[] = {
8373 (char *) "pt", NULL
8374 };
8375
8376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8377 {
8378 arg1 = &temp1;
8379 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8380 }
8381 {
8382 PyThreadState* __tstate = wxPyBeginAllowThreads();
8383 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8384 wxPyEndAllowThreads(__tstate);
8385 if (PyErr_Occurred()) SWIG_fail;
8386 }
8387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8388 return resultobj;
8389 fail:
8390 return NULL;
8391 }
8392
8393
8394 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8395 PyObject *resultobj = 0;
8396 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8397 int *arg2 = (int *) 0 ;
8398 int *arg3 = (int *) 0 ;
8399 void *argp1 = 0 ;
8400 int res1 = 0 ;
8401 int temp2 ;
8402 int res2 = SWIG_TMPOBJ ;
8403 int temp3 ;
8404 int res3 = SWIG_TMPOBJ ;
8405 PyObject *swig_obj[1] ;
8406
8407 arg2 = &temp2;
8408 arg3 = &temp3;
8409 if (!args) SWIG_fail;
8410 swig_obj[0] = args;
8411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8412 if (!SWIG_IsOK(res1)) {
8413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8414 }
8415 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8416 {
8417 PyThreadState* __tstate = wxPyBeginAllowThreads();
8418 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8419 wxPyEndAllowThreads(__tstate);
8420 if (PyErr_Occurred()) SWIG_fail;
8421 }
8422 resultobj = SWIG_Py_Void();
8423 if (SWIG_IsTmpObj(res2)) {
8424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8425 } else {
8426 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8428 }
8429 if (SWIG_IsTmpObj(res3)) {
8430 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8431 } else {
8432 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8433 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8434 }
8435 return resultobj;
8436 fail:
8437 return NULL;
8438 }
8439
8440
8441 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8442 PyObject *resultobj = 0;
8443 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8444 int *arg2 = (int *) 0 ;
8445 int *arg3 = (int *) 0 ;
8446 void *argp1 = 0 ;
8447 int res1 = 0 ;
8448 int temp2 ;
8449 int res2 = SWIG_TMPOBJ ;
8450 int temp3 ;
8451 int res3 = SWIG_TMPOBJ ;
8452 PyObject *swig_obj[1] ;
8453
8454 arg2 = &temp2;
8455 arg3 = &temp3;
8456 if (!args) SWIG_fail;
8457 swig_obj[0] = args;
8458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8459 if (!SWIG_IsOK(res1)) {
8460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8461 }
8462 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8463 {
8464 PyThreadState* __tstate = wxPyBeginAllowThreads();
8465 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8466 wxPyEndAllowThreads(__tstate);
8467 if (PyErr_Occurred()) SWIG_fail;
8468 }
8469 resultobj = SWIG_Py_Void();
8470 if (SWIG_IsTmpObj(res2)) {
8471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8472 } else {
8473 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8475 }
8476 if (SWIG_IsTmpObj(res3)) {
8477 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8478 } else {
8479 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8481 }
8482 return resultobj;
8483 fail:
8484 return NULL;
8485 }
8486
8487
8488 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8489 PyObject *resultobj = 0;
8490 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8491 double 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_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8501 }
8502 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8503 {
8504 PyThreadState* __tstate = wxPyBeginAllowThreads();
8505 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 resultobj = SWIG_From_double(static_cast< double >(result));
8510 return resultobj;
8511 fail:
8512 return NULL;
8513 }
8514
8515
8516 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8517 PyObject *resultobj = 0;
8518 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8519 double result;
8520 void *argp1 = 0 ;
8521 int res1 = 0 ;
8522 PyObject *swig_obj[1] ;
8523
8524 if (!args) SWIG_fail;
8525 swig_obj[0] = args;
8526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8527 if (!SWIG_IsOK(res1)) {
8528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8529 }
8530 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8531 {
8532 PyThreadState* __tstate = wxPyBeginAllowThreads();
8533 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8534 wxPyEndAllowThreads(__tstate);
8535 if (PyErr_Occurred()) SWIG_fail;
8536 }
8537 resultobj = SWIG_From_double(static_cast< double >(result));
8538 return resultobj;
8539 fail:
8540 return NULL;
8541 }
8542
8543
8544 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8545 PyObject *resultobj = 0;
8546 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8547 double arg2 ;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 double val2 ;
8551 int ecode2 = 0 ;
8552 PyObject * obj0 = 0 ;
8553 PyObject * obj1 = 0 ;
8554 char * kwnames[] = {
8555 (char *) "self",(char *) "length", NULL
8556 };
8557
8558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8560 if (!SWIG_IsOK(res1)) {
8561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8562 }
8563 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8564 ecode2 = SWIG_AsVal_double(obj1, &val2);
8565 if (!SWIG_IsOK(ecode2)) {
8566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8567 }
8568 arg2 = static_cast< double >(val2);
8569 {
8570 PyThreadState* __tstate = wxPyBeginAllowThreads();
8571 (arg1)->SetVectorLength(arg2);
8572 wxPyEndAllowThreads(__tstate);
8573 if (PyErr_Occurred()) SWIG_fail;
8574 }
8575 resultobj = SWIG_Py_Void();
8576 return resultobj;
8577 fail:
8578 return NULL;
8579 }
8580
8581
8582 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8583 PyObject *resultobj = 0;
8584 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8585 double arg2 ;
8586 void *argp1 = 0 ;
8587 int res1 = 0 ;
8588 double val2 ;
8589 int ecode2 = 0 ;
8590 PyObject * obj0 = 0 ;
8591 PyObject * obj1 = 0 ;
8592 char * kwnames[] = {
8593 (char *) "self",(char *) "degrees", NULL
8594 };
8595
8596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8598 if (!SWIG_IsOK(res1)) {
8599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8600 }
8601 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8602 ecode2 = SWIG_AsVal_double(obj1, &val2);
8603 if (!SWIG_IsOK(ecode2)) {
8604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8605 }
8606 arg2 = static_cast< double >(val2);
8607 {
8608 PyThreadState* __tstate = wxPyBeginAllowThreads();
8609 (arg1)->SetVectorAngle(arg2);
8610 wxPyEndAllowThreads(__tstate);
8611 if (PyErr_Occurred()) SWIG_fail;
8612 }
8613 resultobj = SWIG_Py_Void();
8614 return resultobj;
8615 fail:
8616 return NULL;
8617 }
8618
8619
8620 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8621 PyObject *resultobj = 0;
8622 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8623 wxPoint2D *arg2 = 0 ;
8624 double result;
8625 void *argp1 = 0 ;
8626 int res1 = 0 ;
8627 wxPoint2D temp2 ;
8628 PyObject * obj0 = 0 ;
8629 PyObject * obj1 = 0 ;
8630 char * kwnames[] = {
8631 (char *) "self",(char *) "pt", NULL
8632 };
8633
8634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8636 if (!SWIG_IsOK(res1)) {
8637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8638 }
8639 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8640 {
8641 arg2 = &temp2;
8642 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8643 }
8644 {
8645 PyThreadState* __tstate = wxPyBeginAllowThreads();
8646 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8647 wxPyEndAllowThreads(__tstate);
8648 if (PyErr_Occurred()) SWIG_fail;
8649 }
8650 resultobj = SWIG_From_double(static_cast< double >(result));
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8658 PyObject *resultobj = 0;
8659 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8660 wxPoint2D *arg2 = 0 ;
8661 double result;
8662 void *argp1 = 0 ;
8663 int res1 = 0 ;
8664 wxPoint2D temp2 ;
8665 PyObject * obj0 = 0 ;
8666 PyObject * obj1 = 0 ;
8667 char * kwnames[] = {
8668 (char *) "self",(char *) "pt", NULL
8669 };
8670
8671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8673 if (!SWIG_IsOK(res1)) {
8674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8675 }
8676 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8677 {
8678 arg2 = &temp2;
8679 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8680 }
8681 {
8682 PyThreadState* __tstate = wxPyBeginAllowThreads();
8683 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8684 wxPyEndAllowThreads(__tstate);
8685 if (PyErr_Occurred()) SWIG_fail;
8686 }
8687 resultobj = SWIG_From_double(static_cast< double >(result));
8688 return resultobj;
8689 fail:
8690 return NULL;
8691 }
8692
8693
8694 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8695 PyObject *resultobj = 0;
8696 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8697 wxPoint2D *arg2 = 0 ;
8698 double result;
8699 void *argp1 = 0 ;
8700 int res1 = 0 ;
8701 wxPoint2D temp2 ;
8702 PyObject * obj0 = 0 ;
8703 PyObject * obj1 = 0 ;
8704 char * kwnames[] = {
8705 (char *) "self",(char *) "vec", NULL
8706 };
8707
8708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 {
8715 arg2 = &temp2;
8716 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8717 }
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8721 wxPyEndAllowThreads(__tstate);
8722 if (PyErr_Occurred()) SWIG_fail;
8723 }
8724 resultobj = SWIG_From_double(static_cast< double >(result));
8725 return resultobj;
8726 fail:
8727 return NULL;
8728 }
8729
8730
8731 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8732 PyObject *resultobj = 0;
8733 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8734 wxPoint2D *arg2 = 0 ;
8735 double result;
8736 void *argp1 = 0 ;
8737 int res1 = 0 ;
8738 wxPoint2D temp2 ;
8739 PyObject * obj0 = 0 ;
8740 PyObject * obj1 = 0 ;
8741 char * kwnames[] = {
8742 (char *) "self",(char *) "vec", NULL
8743 };
8744
8745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8747 if (!SWIG_IsOK(res1)) {
8748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8749 }
8750 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8751 {
8752 arg2 = &temp2;
8753 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8754 }
8755 {
8756 PyThreadState* __tstate = wxPyBeginAllowThreads();
8757 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8758 wxPyEndAllowThreads(__tstate);
8759 if (PyErr_Occurred()) SWIG_fail;
8760 }
8761 resultobj = SWIG_From_double(static_cast< double >(result));
8762 return resultobj;
8763 fail:
8764 return NULL;
8765 }
8766
8767
8768 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8769 PyObject *resultobj = 0;
8770 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8771 wxPoint2D result;
8772 void *argp1 = 0 ;
8773 int res1 = 0 ;
8774 PyObject *swig_obj[1] ;
8775
8776 if (!args) SWIG_fail;
8777 swig_obj[0] = args;
8778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8779 if (!SWIG_IsOK(res1)) {
8780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8781 }
8782 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8783 {
8784 PyThreadState* __tstate = wxPyBeginAllowThreads();
8785 result = (arg1)->operator -();
8786 wxPyEndAllowThreads(__tstate);
8787 if (PyErr_Occurred()) SWIG_fail;
8788 }
8789 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8790 return resultobj;
8791 fail:
8792 return NULL;
8793 }
8794
8795
8796 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8797 PyObject *resultobj = 0;
8798 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8799 wxPoint2D *arg2 = 0 ;
8800 wxPoint2D *result = 0 ;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 wxPoint2D temp2 ;
8804 PyObject * obj0 = 0 ;
8805 PyObject * obj1 = 0 ;
8806 char * kwnames[] = {
8807 (char *) "self",(char *) "pt", NULL
8808 };
8809
8810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8814 }
8815 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8816 {
8817 arg2 = &temp2;
8818 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8819 }
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 {
8823 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8824 result = (wxPoint2D *) &_result_ref;
8825 }
8826 wxPyEndAllowThreads(__tstate);
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj = 0;
8838 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8839 wxPoint2D *arg2 = 0 ;
8840 wxPoint2D *result = 0 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 wxPoint2D temp2 ;
8844 PyObject * obj0 = 0 ;
8845 PyObject * obj1 = 0 ;
8846 char * kwnames[] = {
8847 (char *) "self",(char *) "pt", NULL
8848 };
8849
8850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8852 if (!SWIG_IsOK(res1)) {
8853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8854 }
8855 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8856 {
8857 arg2 = &temp2;
8858 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8859 }
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 {
8863 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8864 result = (wxPoint2D *) &_result_ref;
8865 }
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj = 0;
8878 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8879 wxPoint2D *arg2 = 0 ;
8880 wxPoint2D *result = 0 ;
8881 void *argp1 = 0 ;
8882 int res1 = 0 ;
8883 wxPoint2D temp2 ;
8884 PyObject * obj0 = 0 ;
8885 PyObject * obj1 = 0 ;
8886 char * kwnames[] = {
8887 (char *) "self",(char *) "pt", NULL
8888 };
8889
8890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8892 if (!SWIG_IsOK(res1)) {
8893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8894 }
8895 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8896 {
8897 arg2 = &temp2;
8898 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8899 }
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 {
8903 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8904 result = (wxPoint2D *) &_result_ref;
8905 }
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj = 0;
8918 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8919 wxPoint2D *arg2 = 0 ;
8920 wxPoint2D *result = 0 ;
8921 void *argp1 = 0 ;
8922 int res1 = 0 ;
8923 wxPoint2D temp2 ;
8924 PyObject * obj0 = 0 ;
8925 PyObject * obj1 = 0 ;
8926 char * kwnames[] = {
8927 (char *) "self",(char *) "pt", NULL
8928 };
8929
8930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8932 if (!SWIG_IsOK(res1)) {
8933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8934 }
8935 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8936 {
8937 arg2 = &temp2;
8938 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8939 }
8940 {
8941 PyThreadState* __tstate = wxPyBeginAllowThreads();
8942 {
8943 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8944 result = (wxPoint2D *) &_result_ref;
8945 }
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8957 PyObject *resultobj = 0;
8958 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8959 PyObject *arg2 = (PyObject *) 0 ;
8960 bool result;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject * obj0 = 0 ;
8964 PyObject * obj1 = 0 ;
8965 char * kwnames[] = {
8966 (char *) "self",(char *) "other", NULL
8967 };
8968
8969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8971 if (!SWIG_IsOK(res1)) {
8972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8973 }
8974 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8975 arg2 = obj1;
8976 {
8977 result = (bool)wxPoint2D___eq__(arg1,arg2);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 {
8981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8982 }
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8990 PyObject *resultobj = 0;
8991 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8992 PyObject *arg2 = (PyObject *) 0 ;
8993 bool result;
8994 void *argp1 = 0 ;
8995 int res1 = 0 ;
8996 PyObject * obj0 = 0 ;
8997 PyObject * obj1 = 0 ;
8998 char * kwnames[] = {
8999 (char *) "self",(char *) "other", NULL
9000 };
9001
9002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9004 if (!SWIG_IsOK(res1)) {
9005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9006 }
9007 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9008 arg2 = obj1;
9009 {
9010 result = (bool)wxPoint2D___ne__(arg1,arg2);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 {
9014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9015 }
9016 return resultobj;
9017 fail:
9018 return NULL;
9019 }
9020
9021
9022 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 PyObject *resultobj = 0;
9024 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9025 double arg2 ;
9026 void *argp1 = 0 ;
9027 int res1 = 0 ;
9028 double val2 ;
9029 int ecode2 = 0 ;
9030 PyObject *swig_obj[2] ;
9031
9032 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9038 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9039 if (!SWIG_IsOK(ecode2)) {
9040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9041 }
9042 arg2 = static_cast< double >(val2);
9043 if (arg1) (arg1)->m_x = arg2;
9044
9045 resultobj = SWIG_Py_Void();
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9053 PyObject *resultobj = 0;
9054 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9055 double result;
9056 void *argp1 = 0 ;
9057 int res1 = 0 ;
9058 PyObject *swig_obj[1] ;
9059
9060 if (!args) SWIG_fail;
9061 swig_obj[0] = args;
9062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9063 if (!SWIG_IsOK(res1)) {
9064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9065 }
9066 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9067 result = (double) ((arg1)->m_x);
9068 resultobj = SWIG_From_double(static_cast< double >(result));
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9076 PyObject *resultobj = 0;
9077 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9078 double arg2 ;
9079 void *argp1 = 0 ;
9080 int res1 = 0 ;
9081 double val2 ;
9082 int ecode2 = 0 ;
9083 PyObject *swig_obj[2] ;
9084
9085 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9087 if (!SWIG_IsOK(res1)) {
9088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9089 }
9090 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9091 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9092 if (!SWIG_IsOK(ecode2)) {
9093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9094 }
9095 arg2 = static_cast< double >(val2);
9096 if (arg1) (arg1)->m_y = arg2;
9097
9098 resultobj = SWIG_Py_Void();
9099 return resultobj;
9100 fail:
9101 return NULL;
9102 }
9103
9104
9105 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 PyObject *resultobj = 0;
9107 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9108 double result;
9109 void *argp1 = 0 ;
9110 int res1 = 0 ;
9111 PyObject *swig_obj[1] ;
9112
9113 if (!args) SWIG_fail;
9114 swig_obj[0] = args;
9115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9116 if (!SWIG_IsOK(res1)) {
9117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9118 }
9119 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9120 result = (double) ((arg1)->m_y);
9121 resultobj = SWIG_From_double(static_cast< double >(result));
9122 return resultobj;
9123 fail:
9124 return NULL;
9125 }
9126
9127
9128 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9129 PyObject *resultobj = 0;
9130 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9131 double arg2 = (double) 0 ;
9132 double arg3 = (double) 0 ;
9133 void *argp1 = 0 ;
9134 int res1 = 0 ;
9135 double val2 ;
9136 int ecode2 = 0 ;
9137 double val3 ;
9138 int ecode3 = 0 ;
9139 PyObject * obj0 = 0 ;
9140 PyObject * obj1 = 0 ;
9141 PyObject * obj2 = 0 ;
9142 char * kwnames[] = {
9143 (char *) "self",(char *) "x",(char *) "y", NULL
9144 };
9145
9146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9148 if (!SWIG_IsOK(res1)) {
9149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9150 }
9151 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9152 if (obj1) {
9153 ecode2 = SWIG_AsVal_double(obj1, &val2);
9154 if (!SWIG_IsOK(ecode2)) {
9155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9156 }
9157 arg2 = static_cast< double >(val2);
9158 }
9159 if (obj2) {
9160 ecode3 = SWIG_AsVal_double(obj2, &val3);
9161 if (!SWIG_IsOK(ecode3)) {
9162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9163 }
9164 arg3 = static_cast< double >(val3);
9165 }
9166 {
9167 PyThreadState* __tstate = wxPyBeginAllowThreads();
9168 wxPoint2D_Set(arg1,arg2,arg3);
9169 wxPyEndAllowThreads(__tstate);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 resultobj = SWIG_Py_Void();
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9180 PyObject *resultobj = 0;
9181 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9182 PyObject *result = 0 ;
9183 void *argp1 = 0 ;
9184 int res1 = 0 ;
9185 PyObject *swig_obj[1] ;
9186
9187 if (!args) SWIG_fail;
9188 swig_obj[0] = args;
9189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9190 if (!SWIG_IsOK(res1)) {
9191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9192 }
9193 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9194 {
9195 PyThreadState* __tstate = wxPyBeginAllowThreads();
9196 result = (PyObject *)wxPoint2D_Get(arg1);
9197 wxPyEndAllowThreads(__tstate);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 resultobj = result;
9201 return resultobj;
9202 fail:
9203 return NULL;
9204 }
9205
9206
9207 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9208 PyObject *obj;
9209 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9210 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9211 return SWIG_Py_Void();
9212 }
9213
9214 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9215 return SWIG_Python_InitShadowInstance(args);
9216 }
9217
9218 SWIGINTERN int DefaultPosition_set(PyObject *) {
9219 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9220 return 1;
9221 }
9222
9223
9224 SWIGINTERN PyObject *DefaultPosition_get(void) {
9225 PyObject *pyobj = 0;
9226
9227 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9228 return pyobj;
9229 }
9230
9231
9232 SWIGINTERN int DefaultSize_set(PyObject *) {
9233 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9234 return 1;
9235 }
9236
9237
9238 SWIGINTERN PyObject *DefaultSize_get(void) {
9239 PyObject *pyobj = 0;
9240
9241 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9242 return pyobj;
9243 }
9244
9245
9246 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9247 PyObject *resultobj = 0;
9248 PyObject *arg1 = (PyObject *) 0 ;
9249 wxPyInputStream *result = 0 ;
9250 PyObject * obj0 = 0 ;
9251 char * kwnames[] = {
9252 (char *) "p", NULL
9253 };
9254
9255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9256 arg1 = obj0;
9257 {
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9264 return resultobj;
9265 fail:
9266 return NULL;
9267 }
9268
9269
9270 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9271 PyObject *resultobj = 0;
9272 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9273 void *argp1 = 0 ;
9274 int res1 = 0 ;
9275 PyObject *swig_obj[1] ;
9276
9277 if (!args) SWIG_fail;
9278 swig_obj[0] = args;
9279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9280 if (!SWIG_IsOK(res1)) {
9281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9282 }
9283 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9284 {
9285 PyThreadState* __tstate = wxPyBeginAllowThreads();
9286 delete arg1;
9287
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 resultobj = SWIG_Py_Void();
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9299 PyObject *resultobj = 0;
9300 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9301 void *argp1 = 0 ;
9302 int res1 = 0 ;
9303 PyObject *swig_obj[1] ;
9304
9305 if (!args) SWIG_fail;
9306 swig_obj[0] = args;
9307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9308 if (!SWIG_IsOK(res1)) {
9309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9310 }
9311 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9312 {
9313 PyThreadState* __tstate = wxPyBeginAllowThreads();
9314 (arg1)->close();
9315 wxPyEndAllowThreads(__tstate);
9316 if (PyErr_Occurred()) SWIG_fail;
9317 }
9318 resultobj = SWIG_Py_Void();
9319 return resultobj;
9320 fail:
9321 return NULL;
9322 }
9323
9324
9325 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9326 PyObject *resultobj = 0;
9327 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9328 void *argp1 = 0 ;
9329 int res1 = 0 ;
9330 PyObject *swig_obj[1] ;
9331
9332 if (!args) SWIG_fail;
9333 swig_obj[0] = args;
9334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9337 }
9338 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9339 {
9340 PyThreadState* __tstate = wxPyBeginAllowThreads();
9341 (arg1)->flush();
9342 wxPyEndAllowThreads(__tstate);
9343 if (PyErr_Occurred()) SWIG_fail;
9344 }
9345 resultobj = SWIG_Py_Void();
9346 return resultobj;
9347 fail:
9348 return NULL;
9349 }
9350
9351
9352 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9353 PyObject *resultobj = 0;
9354 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9355 bool result;
9356 void *argp1 = 0 ;
9357 int res1 = 0 ;
9358 PyObject *swig_obj[1] ;
9359
9360 if (!args) SWIG_fail;
9361 swig_obj[0] = args;
9362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9363 if (!SWIG_IsOK(res1)) {
9364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9365 }
9366 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9367 {
9368 PyThreadState* __tstate = wxPyBeginAllowThreads();
9369 result = (bool)(arg1)->eof();
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 {
9374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9375 }
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9383 PyObject *resultobj = 0;
9384 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9385 int arg2 = (int) -1 ;
9386 PyObject *result = 0 ;
9387 void *argp1 = 0 ;
9388 int res1 = 0 ;
9389 int val2 ;
9390 int ecode2 = 0 ;
9391 PyObject * obj0 = 0 ;
9392 PyObject * obj1 = 0 ;
9393 char * kwnames[] = {
9394 (char *) "self",(char *) "size", NULL
9395 };
9396
9397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9399 if (!SWIG_IsOK(res1)) {
9400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9401 }
9402 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9403 if (obj1) {
9404 ecode2 = SWIG_AsVal_int(obj1, &val2);
9405 if (!SWIG_IsOK(ecode2)) {
9406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9407 }
9408 arg2 = static_cast< int >(val2);
9409 }
9410 {
9411 PyThreadState* __tstate = wxPyBeginAllowThreads();
9412 result = (PyObject *)(arg1)->read(arg2);
9413 wxPyEndAllowThreads(__tstate);
9414 if (PyErr_Occurred()) SWIG_fail;
9415 }
9416 resultobj = result;
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9424 PyObject *resultobj = 0;
9425 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9426 int arg2 = (int) -1 ;
9427 PyObject *result = 0 ;
9428 void *argp1 = 0 ;
9429 int res1 = 0 ;
9430 int val2 ;
9431 int ecode2 = 0 ;
9432 PyObject * obj0 = 0 ;
9433 PyObject * obj1 = 0 ;
9434 char * kwnames[] = {
9435 (char *) "self",(char *) "size", NULL
9436 };
9437
9438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9440 if (!SWIG_IsOK(res1)) {
9441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9442 }
9443 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9444 if (obj1) {
9445 ecode2 = SWIG_AsVal_int(obj1, &val2);
9446 if (!SWIG_IsOK(ecode2)) {
9447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9448 }
9449 arg2 = static_cast< int >(val2);
9450 }
9451 {
9452 PyThreadState* __tstate = wxPyBeginAllowThreads();
9453 result = (PyObject *)(arg1)->readline(arg2);
9454 wxPyEndAllowThreads(__tstate);
9455 if (PyErr_Occurred()) SWIG_fail;
9456 }
9457 resultobj = result;
9458 return resultobj;
9459 fail:
9460 return NULL;
9461 }
9462
9463
9464 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9465 PyObject *resultobj = 0;
9466 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9467 int arg2 = (int) -1 ;
9468 PyObject *result = 0 ;
9469 void *argp1 = 0 ;
9470 int res1 = 0 ;
9471 int val2 ;
9472 int ecode2 = 0 ;
9473 PyObject * obj0 = 0 ;
9474 PyObject * obj1 = 0 ;
9475 char * kwnames[] = {
9476 (char *) "self",(char *) "sizehint", NULL
9477 };
9478
9479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9481 if (!SWIG_IsOK(res1)) {
9482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9483 }
9484 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9485 if (obj1) {
9486 ecode2 = SWIG_AsVal_int(obj1, &val2);
9487 if (!SWIG_IsOK(ecode2)) {
9488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9489 }
9490 arg2 = static_cast< int >(val2);
9491 }
9492 {
9493 PyThreadState* __tstate = wxPyBeginAllowThreads();
9494 result = (PyObject *)(arg1)->readlines(arg2);
9495 wxPyEndAllowThreads(__tstate);
9496 if (PyErr_Occurred()) SWIG_fail;
9497 }
9498 resultobj = result;
9499 return resultobj;
9500 fail:
9501 return NULL;
9502 }
9503
9504
9505 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9506 PyObject *resultobj = 0;
9507 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9508 int arg2 ;
9509 int arg3 = (int) 0 ;
9510 void *argp1 = 0 ;
9511 int res1 = 0 ;
9512 int val2 ;
9513 int ecode2 = 0 ;
9514 int val3 ;
9515 int ecode3 = 0 ;
9516 PyObject * obj0 = 0 ;
9517 PyObject * obj1 = 0 ;
9518 PyObject * obj2 = 0 ;
9519 char * kwnames[] = {
9520 (char *) "self",(char *) "offset",(char *) "whence", NULL
9521 };
9522
9523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9525 if (!SWIG_IsOK(res1)) {
9526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9527 }
9528 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9529 ecode2 = SWIG_AsVal_int(obj1, &val2);
9530 if (!SWIG_IsOK(ecode2)) {
9531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9532 }
9533 arg2 = static_cast< int >(val2);
9534 if (obj2) {
9535 ecode3 = SWIG_AsVal_int(obj2, &val3);
9536 if (!SWIG_IsOK(ecode3)) {
9537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9538 }
9539 arg3 = static_cast< int >(val3);
9540 }
9541 {
9542 PyThreadState* __tstate = wxPyBeginAllowThreads();
9543 (arg1)->seek(arg2,arg3);
9544 wxPyEndAllowThreads(__tstate);
9545 if (PyErr_Occurred()) SWIG_fail;
9546 }
9547 resultobj = SWIG_Py_Void();
9548 return resultobj;
9549 fail:
9550 return NULL;
9551 }
9552
9553
9554 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9555 PyObject *resultobj = 0;
9556 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9557 int result;
9558 void *argp1 = 0 ;
9559 int res1 = 0 ;
9560 PyObject *swig_obj[1] ;
9561
9562 if (!args) SWIG_fail;
9563 swig_obj[0] = args;
9564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9565 if (!SWIG_IsOK(res1)) {
9566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9567 }
9568 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9569 {
9570 PyThreadState* __tstate = wxPyBeginAllowThreads();
9571 result = (int)(arg1)->tell();
9572 wxPyEndAllowThreads(__tstate);
9573 if (PyErr_Occurred()) SWIG_fail;
9574 }
9575 resultobj = SWIG_From_int(static_cast< int >(result));
9576 return resultobj;
9577 fail:
9578 return NULL;
9579 }
9580
9581
9582 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9583 PyObject *resultobj = 0;
9584 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9585 char result;
9586 void *argp1 = 0 ;
9587 int res1 = 0 ;
9588 PyObject *swig_obj[1] ;
9589
9590 if (!args) SWIG_fail;
9591 swig_obj[0] = args;
9592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9593 if (!SWIG_IsOK(res1)) {
9594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9595 }
9596 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 result = (char)(arg1)->Peek();
9600 wxPyEndAllowThreads(__tstate);
9601 if (PyErr_Occurred()) SWIG_fail;
9602 }
9603 resultobj = SWIG_From_char(static_cast< char >(result));
9604 return resultobj;
9605 fail:
9606 return NULL;
9607 }
9608
9609
9610 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9611 PyObject *resultobj = 0;
9612 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9613 char result;
9614 void *argp1 = 0 ;
9615 int res1 = 0 ;
9616 PyObject *swig_obj[1] ;
9617
9618 if (!args) SWIG_fail;
9619 swig_obj[0] = args;
9620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9621 if (!SWIG_IsOK(res1)) {
9622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9623 }
9624 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9625 {
9626 PyThreadState* __tstate = wxPyBeginAllowThreads();
9627 result = (char)(arg1)->GetC();
9628 wxPyEndAllowThreads(__tstate);
9629 if (PyErr_Occurred()) SWIG_fail;
9630 }
9631 resultobj = SWIG_From_char(static_cast< char >(result));
9632 return resultobj;
9633 fail:
9634 return NULL;
9635 }
9636
9637
9638 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9639 PyObject *resultobj = 0;
9640 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9641 size_t result;
9642 void *argp1 = 0 ;
9643 int res1 = 0 ;
9644 PyObject *swig_obj[1] ;
9645
9646 if (!args) SWIG_fail;
9647 swig_obj[0] = args;
9648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9649 if (!SWIG_IsOK(res1)) {
9650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9651 }
9652 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 result = (size_t)(arg1)->LastRead();
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9669 bool result;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9679 }
9680 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 result = (bool)(arg1)->CanRead();
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 {
9688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9689 }
9690 return resultobj;
9691 fail:
9692 return NULL;
9693 }
9694
9695
9696 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9697 PyObject *resultobj = 0;
9698 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9699 bool result;
9700 void *argp1 = 0 ;
9701 int res1 = 0 ;
9702 PyObject *swig_obj[1] ;
9703
9704 if (!args) SWIG_fail;
9705 swig_obj[0] = args;
9706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9707 if (!SWIG_IsOK(res1)) {
9708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9709 }
9710 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9711 {
9712 PyThreadState* __tstate = wxPyBeginAllowThreads();
9713 result = (bool)(arg1)->Eof();
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 {
9718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9719 }
9720 return resultobj;
9721 fail:
9722 return NULL;
9723 }
9724
9725
9726 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9727 PyObject *resultobj = 0;
9728 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9729 char arg2 ;
9730 bool result;
9731 void *argp1 = 0 ;
9732 int res1 = 0 ;
9733 char val2 ;
9734 int ecode2 = 0 ;
9735 PyObject * obj0 = 0 ;
9736 PyObject * obj1 = 0 ;
9737 char * kwnames[] = {
9738 (char *) "self",(char *) "c", NULL
9739 };
9740
9741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9743 if (!SWIG_IsOK(res1)) {
9744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9745 }
9746 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9747 ecode2 = SWIG_AsVal_char(obj1, &val2);
9748 if (!SWIG_IsOK(ecode2)) {
9749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9750 }
9751 arg2 = static_cast< char >(val2);
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 result = (bool)(arg1)->Ungetch(arg2);
9755 wxPyEndAllowThreads(__tstate);
9756 if (PyErr_Occurred()) SWIG_fail;
9757 }
9758 {
9759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9760 }
9761 return resultobj;
9762 fail:
9763 return NULL;
9764 }
9765
9766
9767 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9768 PyObject *resultobj = 0;
9769 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9770 long arg2 ;
9771 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9772 long result;
9773 void *argp1 = 0 ;
9774 int res1 = 0 ;
9775 long val2 ;
9776 int ecode2 = 0 ;
9777 int val3 ;
9778 int ecode3 = 0 ;
9779 PyObject * obj0 = 0 ;
9780 PyObject * obj1 = 0 ;
9781 PyObject * obj2 = 0 ;
9782 char * kwnames[] = {
9783 (char *) "self",(char *) "pos",(char *) "mode", NULL
9784 };
9785
9786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9790 }
9791 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9792 ecode2 = SWIG_AsVal_long(obj1, &val2);
9793 if (!SWIG_IsOK(ecode2)) {
9794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9795 }
9796 arg2 = static_cast< long >(val2);
9797 if (obj2) {
9798 ecode3 = SWIG_AsVal_int(obj2, &val3);
9799 if (!SWIG_IsOK(ecode3)) {
9800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9801 }
9802 arg3 = static_cast< wxSeekMode >(val3);
9803 }
9804 {
9805 PyThreadState* __tstate = wxPyBeginAllowThreads();
9806 result = (long)(arg1)->SeekI(arg2,arg3);
9807 wxPyEndAllowThreads(__tstate);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 resultobj = SWIG_From_long(static_cast< long >(result));
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9818 PyObject *resultobj = 0;
9819 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9820 long result;
9821 void *argp1 = 0 ;
9822 int res1 = 0 ;
9823 PyObject *swig_obj[1] ;
9824
9825 if (!args) SWIG_fail;
9826 swig_obj[0] = args;
9827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9828 if (!SWIG_IsOK(res1)) {
9829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9830 }
9831 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9832 {
9833 PyThreadState* __tstate = wxPyBeginAllowThreads();
9834 result = (long)(arg1)->TellI();
9835 wxPyEndAllowThreads(__tstate);
9836 if (PyErr_Occurred()) SWIG_fail;
9837 }
9838 resultobj = SWIG_From_long(static_cast< long >(result));
9839 return resultobj;
9840 fail:
9841 return NULL;
9842 }
9843
9844
9845 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9846 PyObject *obj;
9847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9848 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9849 return SWIG_Py_Void();
9850 }
9851
9852 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9853 return SWIG_Python_InitShadowInstance(args);
9854 }
9855
9856 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9857 PyObject *resultobj = 0;
9858 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9859 PyObject *arg2 = (PyObject *) 0 ;
9860 void *argp1 = 0 ;
9861 int res1 = 0 ;
9862 PyObject * obj0 = 0 ;
9863 PyObject * obj1 = 0 ;
9864 char * kwnames[] = {
9865 (char *) "self",(char *) "obj", NULL
9866 };
9867
9868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9870 if (!SWIG_IsOK(res1)) {
9871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9872 }
9873 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9874 arg2 = obj1;
9875 {
9876 PyThreadState* __tstate = wxPyBeginAllowThreads();
9877 wxOutputStream_write(arg1,arg2);
9878 wxPyEndAllowThreads(__tstate);
9879 if (PyErr_Occurred()) SWIG_fail;
9880 }
9881 resultobj = SWIG_Py_Void();
9882 return resultobj;
9883 fail:
9884 return NULL;
9885 }
9886
9887
9888 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9889 PyObject *resultobj = 0;
9890 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9891 size_t result;
9892 void *argp1 = 0 ;
9893 int res1 = 0 ;
9894 PyObject *swig_obj[1] ;
9895
9896 if (!args) SWIG_fail;
9897 swig_obj[0] = args;
9898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9899 if (!SWIG_IsOK(res1)) {
9900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9901 }
9902 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9906 wxPyEndAllowThreads(__tstate);
9907 if (PyErr_Occurred()) SWIG_fail;
9908 }
9909 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9910 return resultobj;
9911 fail:
9912 return NULL;
9913 }
9914
9915
9916 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9917 PyObject *obj;
9918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9919 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9920 return SWIG_Py_Void();
9921 }
9922
9923 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9924 PyObject *resultobj = 0;
9925 wxInputStream *arg1 = (wxInputStream *) 0 ;
9926 wxString *arg2 = 0 ;
9927 wxString *arg3 = 0 ;
9928 wxString *arg4 = 0 ;
9929 wxDateTime arg5 ;
9930 wxFSFile *result = 0 ;
9931 wxPyInputStream *temp1 ;
9932 bool temp2 = false ;
9933 bool temp3 = false ;
9934 bool temp4 = false ;
9935 void *argp5 ;
9936 int res5 = 0 ;
9937 PyObject * obj0 = 0 ;
9938 PyObject * obj1 = 0 ;
9939 PyObject * obj2 = 0 ;
9940 PyObject * obj3 = 0 ;
9941 PyObject * obj4 = 0 ;
9942 char * kwnames[] = {
9943 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9944 };
9945
9946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9947 {
9948 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9949 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9950 } else {
9951 PyErr_Clear(); // clear the failure of the wxPyConvert above
9952 arg1 = wxPyCBInputStream_create(obj0, true);
9953 if (arg1 == NULL) {
9954 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9955 SWIG_fail;
9956 }
9957 }
9958 }
9959 {
9960 arg2 = wxString_in_helper(obj1);
9961 if (arg2 == NULL) SWIG_fail;
9962 temp2 = true;
9963 }
9964 {
9965 arg3 = wxString_in_helper(obj2);
9966 if (arg3 == NULL) SWIG_fail;
9967 temp3 = true;
9968 }
9969 {
9970 arg4 = wxString_in_helper(obj3);
9971 if (arg4 == NULL) SWIG_fail;
9972 temp4 = true;
9973 }
9974 {
9975 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9976 if (!SWIG_IsOK(res5)) {
9977 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9978 }
9979 if (!argp5) {
9980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9981 } else {
9982 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9983 arg5 = *temp;
9984 if (SWIG_IsNewObj(res5)) delete temp;
9985 }
9986 }
9987 {
9988 PyThreadState* __tstate = wxPyBeginAllowThreads();
9989 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9990 wxPyEndAllowThreads(__tstate);
9991 if (PyErr_Occurred()) SWIG_fail;
9992 }
9993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9994 {
9995 if (temp2)
9996 delete arg2;
9997 }
9998 {
9999 if (temp3)
10000 delete arg3;
10001 }
10002 {
10003 if (temp4)
10004 delete arg4;
10005 }
10006 return resultobj;
10007 fail:
10008 {
10009 if (temp2)
10010 delete arg2;
10011 }
10012 {
10013 if (temp3)
10014 delete arg3;
10015 }
10016 {
10017 if (temp4)
10018 delete arg4;
10019 }
10020 return NULL;
10021 }
10022
10023
10024 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10025 PyObject *resultobj = 0;
10026 wxFSFile *arg1 = (wxFSFile *) 0 ;
10027 void *argp1 = 0 ;
10028 int res1 = 0 ;
10029 PyObject *swig_obj[1] ;
10030
10031 if (!args) SWIG_fail;
10032 swig_obj[0] = args;
10033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10034 if (!SWIG_IsOK(res1)) {
10035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10036 }
10037 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10038 {
10039 PyThreadState* __tstate = wxPyBeginAllowThreads();
10040 delete arg1;
10041
10042 wxPyEndAllowThreads(__tstate);
10043 if (PyErr_Occurred()) SWIG_fail;
10044 }
10045 resultobj = SWIG_Py_Void();
10046 return resultobj;
10047 fail:
10048 return NULL;
10049 }
10050
10051
10052 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10053 PyObject *resultobj = 0;
10054 wxFSFile *arg1 = (wxFSFile *) 0 ;
10055 wxInputStream *result = 0 ;
10056 void *argp1 = 0 ;
10057 int res1 = 0 ;
10058 PyObject *swig_obj[1] ;
10059
10060 if (!args) SWIG_fail;
10061 swig_obj[0] = args;
10062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10063 if (!SWIG_IsOK(res1)) {
10064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10065 }
10066 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10067 {
10068 PyThreadState* __tstate = wxPyBeginAllowThreads();
10069 result = (wxInputStream *)(arg1)->GetStream();
10070 wxPyEndAllowThreads(__tstate);
10071 if (PyErr_Occurred()) SWIG_fail;
10072 }
10073 {
10074 wxPyInputStream * _ptr = NULL;
10075
10076 if (result) {
10077 _ptr = new wxPyInputStream(result);
10078 }
10079 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10080 }
10081 return resultobj;
10082 fail:
10083 return NULL;
10084 }
10085
10086
10087 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10088 PyObject *resultobj = 0;
10089 wxFSFile *arg1 = (wxFSFile *) 0 ;
10090 void *argp1 = 0 ;
10091 int res1 = 0 ;
10092 PyObject *swig_obj[1] ;
10093
10094 if (!args) SWIG_fail;
10095 swig_obj[0] = args;
10096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10097 if (!SWIG_IsOK(res1)) {
10098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10099 }
10100 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10101 {
10102 PyThreadState* __tstate = wxPyBeginAllowThreads();
10103 (arg1)->DetachStream();
10104 wxPyEndAllowThreads(__tstate);
10105 if (PyErr_Occurred()) SWIG_fail;
10106 }
10107 resultobj = SWIG_Py_Void();
10108 return resultobj;
10109 fail:
10110 return NULL;
10111 }
10112
10113
10114 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10115 PyObject *resultobj = 0;
10116 wxFSFile *arg1 = (wxFSFile *) 0 ;
10117 wxString *result = 0 ;
10118 void *argp1 = 0 ;
10119 int res1 = 0 ;
10120 PyObject *swig_obj[1] ;
10121
10122 if (!args) SWIG_fail;
10123 swig_obj[0] = args;
10124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10125 if (!SWIG_IsOK(res1)) {
10126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10127 }
10128 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 {
10132 wxString const &_result_ref = (arg1)->GetMimeType();
10133 result = (wxString *) &_result_ref;
10134 }
10135 wxPyEndAllowThreads(__tstate);
10136 if (PyErr_Occurred()) SWIG_fail;
10137 }
10138 {
10139 #if wxUSE_UNICODE
10140 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10141 #else
10142 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10143 #endif
10144 }
10145 return resultobj;
10146 fail:
10147 return NULL;
10148 }
10149
10150
10151 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10152 PyObject *resultobj = 0;
10153 wxFSFile *arg1 = (wxFSFile *) 0 ;
10154 wxString *result = 0 ;
10155 void *argp1 = 0 ;
10156 int res1 = 0 ;
10157 PyObject *swig_obj[1] ;
10158
10159 if (!args) SWIG_fail;
10160 swig_obj[0] = args;
10161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10162 if (!SWIG_IsOK(res1)) {
10163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10164 }
10165 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10166 {
10167 PyThreadState* __tstate = wxPyBeginAllowThreads();
10168 {
10169 wxString const &_result_ref = (arg1)->GetLocation();
10170 result = (wxString *) &_result_ref;
10171 }
10172 wxPyEndAllowThreads(__tstate);
10173 if (PyErr_Occurred()) SWIG_fail;
10174 }
10175 {
10176 #if wxUSE_UNICODE
10177 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10178 #else
10179 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10180 #endif
10181 }
10182 return resultobj;
10183 fail:
10184 return NULL;
10185 }
10186
10187
10188 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10189 PyObject *resultobj = 0;
10190 wxFSFile *arg1 = (wxFSFile *) 0 ;
10191 wxString *result = 0 ;
10192 void *argp1 = 0 ;
10193 int res1 = 0 ;
10194 PyObject *swig_obj[1] ;
10195
10196 if (!args) SWIG_fail;
10197 swig_obj[0] = args;
10198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10199 if (!SWIG_IsOK(res1)) {
10200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10201 }
10202 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 {
10206 wxString const &_result_ref = (arg1)->GetAnchor();
10207 result = (wxString *) &_result_ref;
10208 }
10209 wxPyEndAllowThreads(__tstate);
10210 if (PyErr_Occurred()) SWIG_fail;
10211 }
10212 {
10213 #if wxUSE_UNICODE
10214 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10215 #else
10216 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10217 #endif
10218 }
10219 return resultobj;
10220 fail:
10221 return NULL;
10222 }
10223
10224
10225 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10226 PyObject *resultobj = 0;
10227 wxFSFile *arg1 = (wxFSFile *) 0 ;
10228 wxDateTime result;
10229 void *argp1 = 0 ;
10230 int res1 = 0 ;
10231 PyObject *swig_obj[1] ;
10232
10233 if (!args) SWIG_fail;
10234 swig_obj[0] = args;
10235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10236 if (!SWIG_IsOK(res1)) {
10237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10238 }
10239 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10240 {
10241 PyThreadState* __tstate = wxPyBeginAllowThreads();
10242 result = (arg1)->GetModificationTime();
10243 wxPyEndAllowThreads(__tstate);
10244 if (PyErr_Occurred()) SWIG_fail;
10245 }
10246 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10247 return resultobj;
10248 fail:
10249 return NULL;
10250 }
10251
10252
10253 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10254 PyObject *obj;
10255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10256 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10257 return SWIG_Py_Void();
10258 }
10259
10260 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10261 return SWIG_Python_InitShadowInstance(args);
10262 }
10263
10264 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10265 PyObject *resultobj = 0;
10266 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10267 void *argp1 = 0 ;
10268 int res1 = 0 ;
10269 PyObject *swig_obj[1] ;
10270
10271 if (!args) SWIG_fail;
10272 swig_obj[0] = args;
10273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10274 if (!SWIG_IsOK(res1)) {
10275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10276 }
10277 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10278 {
10279 PyThreadState* __tstate = wxPyBeginAllowThreads();
10280 delete arg1;
10281
10282 wxPyEndAllowThreads(__tstate);
10283 if (PyErr_Occurred()) SWIG_fail;
10284 }
10285 resultobj = SWIG_Py_Void();
10286 return resultobj;
10287 fail:
10288 return NULL;
10289 }
10290
10291
10292 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10293 PyObject *obj;
10294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10295 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10296 return SWIG_Py_Void();
10297 }
10298
10299 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10300 PyObject *resultobj = 0;
10301 wxPyFileSystemHandler *result = 0 ;
10302
10303 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10304 {
10305 PyThreadState* __tstate = wxPyBeginAllowThreads();
10306 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10307 wxPyEndAllowThreads(__tstate);
10308 if (PyErr_Occurred()) SWIG_fail;
10309 }
10310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10311 return resultobj;
10312 fail:
10313 return NULL;
10314 }
10315
10316
10317 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10318 PyObject *resultobj = 0;
10319 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10320 PyObject *arg2 = (PyObject *) 0 ;
10321 PyObject *arg3 = (PyObject *) 0 ;
10322 void *argp1 = 0 ;
10323 int res1 = 0 ;
10324 PyObject * obj0 = 0 ;
10325 PyObject * obj1 = 0 ;
10326 PyObject * obj2 = 0 ;
10327 char * kwnames[] = {
10328 (char *) "self",(char *) "self",(char *) "_class", NULL
10329 };
10330
10331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10333 if (!SWIG_IsOK(res1)) {
10334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10335 }
10336 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10337 arg2 = obj1;
10338 arg3 = obj2;
10339 {
10340 PyThreadState* __tstate = wxPyBeginAllowThreads();
10341 (arg1)->_setCallbackInfo(arg2,arg3);
10342 wxPyEndAllowThreads(__tstate);
10343 if (PyErr_Occurred()) SWIG_fail;
10344 }
10345 resultobj = SWIG_Py_Void();
10346 return resultobj;
10347 fail:
10348 return NULL;
10349 }
10350
10351
10352 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10353 PyObject *resultobj = 0;
10354 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10355 wxString *arg2 = 0 ;
10356 bool result;
10357 void *argp1 = 0 ;
10358 int res1 = 0 ;
10359 bool temp2 = false ;
10360 PyObject * obj0 = 0 ;
10361 PyObject * obj1 = 0 ;
10362 char * kwnames[] = {
10363 (char *) "self",(char *) "location", NULL
10364 };
10365
10366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10368 if (!SWIG_IsOK(res1)) {
10369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10370 }
10371 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10372 {
10373 arg2 = wxString_in_helper(obj1);
10374 if (arg2 == NULL) SWIG_fail;
10375 temp2 = true;
10376 }
10377 {
10378 PyThreadState* __tstate = wxPyBeginAllowThreads();
10379 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10380 wxPyEndAllowThreads(__tstate);
10381 if (PyErr_Occurred()) SWIG_fail;
10382 }
10383 {
10384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10385 }
10386 {
10387 if (temp2)
10388 delete arg2;
10389 }
10390 return resultobj;
10391 fail:
10392 {
10393 if (temp2)
10394 delete arg2;
10395 }
10396 return NULL;
10397 }
10398
10399
10400 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10401 PyObject *resultobj = 0;
10402 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10403 wxFileSystem *arg2 = 0 ;
10404 wxString *arg3 = 0 ;
10405 wxFSFile *result = 0 ;
10406 void *argp1 = 0 ;
10407 int res1 = 0 ;
10408 void *argp2 = 0 ;
10409 int res2 = 0 ;
10410 bool temp3 = false ;
10411 PyObject * obj0 = 0 ;
10412 PyObject * obj1 = 0 ;
10413 PyObject * obj2 = 0 ;
10414 char * kwnames[] = {
10415 (char *) "self",(char *) "fs",(char *) "location", NULL
10416 };
10417
10418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10420 if (!SWIG_IsOK(res1)) {
10421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10422 }
10423 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10424 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10425 if (!SWIG_IsOK(res2)) {
10426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10427 }
10428 if (!argp2) {
10429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10430 }
10431 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10432 {
10433 arg3 = wxString_in_helper(obj2);
10434 if (arg3 == NULL) SWIG_fail;
10435 temp3 = true;
10436 }
10437 {
10438 PyThreadState* __tstate = wxPyBeginAllowThreads();
10439 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10440 wxPyEndAllowThreads(__tstate);
10441 if (PyErr_Occurred()) SWIG_fail;
10442 }
10443 {
10444 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10445 }
10446 {
10447 if (temp3)
10448 delete arg3;
10449 }
10450 return resultobj;
10451 fail:
10452 {
10453 if (temp3)
10454 delete arg3;
10455 }
10456 return NULL;
10457 }
10458
10459
10460 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10461 PyObject *resultobj = 0;
10462 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10463 wxString *arg2 = 0 ;
10464 int arg3 = (int) 0 ;
10465 wxString result;
10466 void *argp1 = 0 ;
10467 int res1 = 0 ;
10468 bool temp2 = false ;
10469 int val3 ;
10470 int ecode3 = 0 ;
10471 PyObject * obj0 = 0 ;
10472 PyObject * obj1 = 0 ;
10473 PyObject * obj2 = 0 ;
10474 char * kwnames[] = {
10475 (char *) "self",(char *) "spec",(char *) "flags", NULL
10476 };
10477
10478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10480 if (!SWIG_IsOK(res1)) {
10481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10482 }
10483 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10484 {
10485 arg2 = wxString_in_helper(obj1);
10486 if (arg2 == NULL) SWIG_fail;
10487 temp2 = true;
10488 }
10489 if (obj2) {
10490 ecode3 = SWIG_AsVal_int(obj2, &val3);
10491 if (!SWIG_IsOK(ecode3)) {
10492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10493 }
10494 arg3 = static_cast< int >(val3);
10495 }
10496 {
10497 PyThreadState* __tstate = wxPyBeginAllowThreads();
10498 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10499 wxPyEndAllowThreads(__tstate);
10500 if (PyErr_Occurred()) SWIG_fail;
10501 }
10502 {
10503 #if wxUSE_UNICODE
10504 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10505 #else
10506 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10507 #endif
10508 }
10509 {
10510 if (temp2)
10511 delete arg2;
10512 }
10513 return resultobj;
10514 fail:
10515 {
10516 if (temp2)
10517 delete arg2;
10518 }
10519 return NULL;
10520 }
10521
10522
10523 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10524 PyObject *resultobj = 0;
10525 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10526 wxString result;
10527 void *argp1 = 0 ;
10528 int res1 = 0 ;
10529 PyObject *swig_obj[1] ;
10530
10531 if (!args) SWIG_fail;
10532 swig_obj[0] = args;
10533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10534 if (!SWIG_IsOK(res1)) {
10535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10536 }
10537 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10538 {
10539 PyThreadState* __tstate = wxPyBeginAllowThreads();
10540 result = (arg1)->FindNext();
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 {
10545 #if wxUSE_UNICODE
10546 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10547 #else
10548 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10549 #endif
10550 }
10551 return resultobj;
10552 fail:
10553 return NULL;
10554 }
10555
10556
10557 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10558 PyObject *resultobj = 0;
10559 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10560 wxString *arg2 = 0 ;
10561 wxString result;
10562 void *argp1 = 0 ;
10563 int res1 = 0 ;
10564 bool temp2 = false ;
10565 PyObject * obj0 = 0 ;
10566 PyObject * obj1 = 0 ;
10567 char * kwnames[] = {
10568 (char *) "self",(char *) "location", NULL
10569 };
10570
10571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10573 if (!SWIG_IsOK(res1)) {
10574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10575 }
10576 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10577 {
10578 arg2 = wxString_in_helper(obj1);
10579 if (arg2 == NULL) SWIG_fail;
10580 temp2 = true;
10581 }
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 result = (arg1)->GetProtocol((wxString const &)*arg2);
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 {
10589 #if wxUSE_UNICODE
10590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10591 #else
10592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10593 #endif
10594 }
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return resultobj;
10600 fail:
10601 {
10602 if (temp2)
10603 delete arg2;
10604 }
10605 return NULL;
10606 }
10607
10608
10609 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10610 PyObject *resultobj = 0;
10611 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10612 wxString *arg2 = 0 ;
10613 wxString result;
10614 void *argp1 = 0 ;
10615 int res1 = 0 ;
10616 bool temp2 = false ;
10617 PyObject * obj0 = 0 ;
10618 PyObject * obj1 = 0 ;
10619 char * kwnames[] = {
10620 (char *) "self",(char *) "location", NULL
10621 };
10622
10623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10625 if (!SWIG_IsOK(res1)) {
10626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10627 }
10628 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10629 {
10630 arg2 = wxString_in_helper(obj1);
10631 if (arg2 == NULL) SWIG_fail;
10632 temp2 = true;
10633 }
10634 {
10635 PyThreadState* __tstate = wxPyBeginAllowThreads();
10636 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10637 wxPyEndAllowThreads(__tstate);
10638 if (PyErr_Occurred()) SWIG_fail;
10639 }
10640 {
10641 #if wxUSE_UNICODE
10642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10643 #else
10644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10645 #endif
10646 }
10647 {
10648 if (temp2)
10649 delete arg2;
10650 }
10651 return resultobj;
10652 fail:
10653 {
10654 if (temp2)
10655 delete arg2;
10656 }
10657 return NULL;
10658 }
10659
10660
10661 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10662 PyObject *resultobj = 0;
10663 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10664 wxString *arg2 = 0 ;
10665 wxString result;
10666 void *argp1 = 0 ;
10667 int res1 = 0 ;
10668 bool temp2 = false ;
10669 PyObject * obj0 = 0 ;
10670 PyObject * obj1 = 0 ;
10671 char * kwnames[] = {
10672 (char *) "self",(char *) "location", NULL
10673 };
10674
10675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10677 if (!SWIG_IsOK(res1)) {
10678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10679 }
10680 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10681 {
10682 arg2 = wxString_in_helper(obj1);
10683 if (arg2 == NULL) SWIG_fail;
10684 temp2 = true;
10685 }
10686 {
10687 PyThreadState* __tstate = wxPyBeginAllowThreads();
10688 result = (arg1)->GetAnchor((wxString const &)*arg2);
10689 wxPyEndAllowThreads(__tstate);
10690 if (PyErr_Occurred()) SWIG_fail;
10691 }
10692 {
10693 #if wxUSE_UNICODE
10694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10695 #else
10696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10697 #endif
10698 }
10699 {
10700 if (temp2)
10701 delete arg2;
10702 }
10703 return resultobj;
10704 fail:
10705 {
10706 if (temp2)
10707 delete arg2;
10708 }
10709 return NULL;
10710 }
10711
10712
10713 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10714 PyObject *resultobj = 0;
10715 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10716 wxString *arg2 = 0 ;
10717 wxString result;
10718 void *argp1 = 0 ;
10719 int res1 = 0 ;
10720 bool temp2 = false ;
10721 PyObject * obj0 = 0 ;
10722 PyObject * obj1 = 0 ;
10723 char * kwnames[] = {
10724 (char *) "self",(char *) "location", NULL
10725 };
10726
10727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10729 if (!SWIG_IsOK(res1)) {
10730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10731 }
10732 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10733 {
10734 arg2 = wxString_in_helper(obj1);
10735 if (arg2 == NULL) SWIG_fail;
10736 temp2 = true;
10737 }
10738 {
10739 PyThreadState* __tstate = wxPyBeginAllowThreads();
10740 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10741 wxPyEndAllowThreads(__tstate);
10742 if (PyErr_Occurred()) SWIG_fail;
10743 }
10744 {
10745 #if wxUSE_UNICODE
10746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10747 #else
10748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10749 #endif
10750 }
10751 {
10752 if (temp2)
10753 delete arg2;
10754 }
10755 return resultobj;
10756 fail:
10757 {
10758 if (temp2)
10759 delete arg2;
10760 }
10761 return NULL;
10762 }
10763
10764
10765 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10766 PyObject *resultobj = 0;
10767 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10768 wxString *arg2 = 0 ;
10769 wxString result;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 bool temp2 = false ;
10773 PyObject * obj0 = 0 ;
10774 PyObject * obj1 = 0 ;
10775 char * kwnames[] = {
10776 (char *) "self",(char *) "location", NULL
10777 };
10778
10779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10781 if (!SWIG_IsOK(res1)) {
10782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10783 }
10784 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10785 {
10786 arg2 = wxString_in_helper(obj1);
10787 if (arg2 == NULL) SWIG_fail;
10788 temp2 = true;
10789 }
10790 {
10791 PyThreadState* __tstate = wxPyBeginAllowThreads();
10792 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10793 wxPyEndAllowThreads(__tstate);
10794 if (PyErr_Occurred()) SWIG_fail;
10795 }
10796 {
10797 #if wxUSE_UNICODE
10798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10799 #else
10800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10801 #endif
10802 }
10803 {
10804 if (temp2)
10805 delete arg2;
10806 }
10807 return resultobj;
10808 fail:
10809 {
10810 if (temp2)
10811 delete arg2;
10812 }
10813 return NULL;
10814 }
10815
10816
10817 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10818 PyObject *obj;
10819 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10820 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10821 return SWIG_Py_Void();
10822 }
10823
10824 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10825 return SWIG_Python_InitShadowInstance(args);
10826 }
10827
10828 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10829 PyObject *resultobj = 0;
10830 wxFileSystem *result = 0 ;
10831
10832 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10833 {
10834 PyThreadState* __tstate = wxPyBeginAllowThreads();
10835 result = (wxFileSystem *)new wxFileSystem();
10836 wxPyEndAllowThreads(__tstate);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 {
10840 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10841 }
10842 return resultobj;
10843 fail:
10844 return NULL;
10845 }
10846
10847
10848 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10849 PyObject *resultobj = 0;
10850 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10851 void *argp1 = 0 ;
10852 int res1 = 0 ;
10853 PyObject *swig_obj[1] ;
10854
10855 if (!args) SWIG_fail;
10856 swig_obj[0] = args;
10857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10858 if (!SWIG_IsOK(res1)) {
10859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10860 }
10861 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 delete arg1;
10865
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 resultobj = SWIG_Py_Void();
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10877 PyObject *resultobj = 0;
10878 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10879 wxString *arg2 = 0 ;
10880 bool arg3 = (bool) false ;
10881 void *argp1 = 0 ;
10882 int res1 = 0 ;
10883 bool temp2 = false ;
10884 bool val3 ;
10885 int ecode3 = 0 ;
10886 PyObject * obj0 = 0 ;
10887 PyObject * obj1 = 0 ;
10888 PyObject * obj2 = 0 ;
10889 char * kwnames[] = {
10890 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10891 };
10892
10893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10895 if (!SWIG_IsOK(res1)) {
10896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10897 }
10898 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10899 {
10900 arg2 = wxString_in_helper(obj1);
10901 if (arg2 == NULL) SWIG_fail;
10902 temp2 = true;
10903 }
10904 if (obj2) {
10905 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10906 if (!SWIG_IsOK(ecode3)) {
10907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10908 }
10909 arg3 = static_cast< bool >(val3);
10910 }
10911 {
10912 PyThreadState* __tstate = wxPyBeginAllowThreads();
10913 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10914 wxPyEndAllowThreads(__tstate);
10915 if (PyErr_Occurred()) SWIG_fail;
10916 }
10917 resultobj = SWIG_Py_Void();
10918 {
10919 if (temp2)
10920 delete arg2;
10921 }
10922 return resultobj;
10923 fail:
10924 {
10925 if (temp2)
10926 delete arg2;
10927 }
10928 return NULL;
10929 }
10930
10931
10932 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10933 PyObject *resultobj = 0;
10934 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10935 wxString result;
10936 void *argp1 = 0 ;
10937 int res1 = 0 ;
10938 PyObject *swig_obj[1] ;
10939
10940 if (!args) SWIG_fail;
10941 swig_obj[0] = args;
10942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10943 if (!SWIG_IsOK(res1)) {
10944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10945 }
10946 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 result = (arg1)->GetPath();
10950 wxPyEndAllowThreads(__tstate);
10951 if (PyErr_Occurred()) SWIG_fail;
10952 }
10953 {
10954 #if wxUSE_UNICODE
10955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10956 #else
10957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10958 #endif
10959 }
10960 return resultobj;
10961 fail:
10962 return NULL;
10963 }
10964
10965
10966 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10967 PyObject *resultobj = 0;
10968 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10969 wxString *arg2 = 0 ;
10970 wxFSFile *result = 0 ;
10971 void *argp1 = 0 ;
10972 int res1 = 0 ;
10973 bool temp2 = false ;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 char * kwnames[] = {
10977 (char *) "self",(char *) "location", NULL
10978 };
10979
10980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10982 if (!SWIG_IsOK(res1)) {
10983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10984 }
10985 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10986 {
10987 arg2 = wxString_in_helper(obj1);
10988 if (arg2 == NULL) SWIG_fail;
10989 temp2 = true;
10990 }
10991 {
10992 PyThreadState* __tstate = wxPyBeginAllowThreads();
10993 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10994 wxPyEndAllowThreads(__tstate);
10995 if (PyErr_Occurred()) SWIG_fail;
10996 }
10997 {
10998 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10999 }
11000 {
11001 if (temp2)
11002 delete arg2;
11003 }
11004 return resultobj;
11005 fail:
11006 {
11007 if (temp2)
11008 delete arg2;
11009 }
11010 return NULL;
11011 }
11012
11013
11014 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj = 0;
11016 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11017 wxString *arg2 = 0 ;
11018 int arg3 = (int) 0 ;
11019 wxString result;
11020 void *argp1 = 0 ;
11021 int res1 = 0 ;
11022 bool temp2 = false ;
11023 int val3 ;
11024 int ecode3 = 0 ;
11025 PyObject * obj0 = 0 ;
11026 PyObject * obj1 = 0 ;
11027 PyObject * obj2 = 0 ;
11028 char * kwnames[] = {
11029 (char *) "self",(char *) "spec",(char *) "flags", NULL
11030 };
11031
11032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11034 if (!SWIG_IsOK(res1)) {
11035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11036 }
11037 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11038 {
11039 arg2 = wxString_in_helper(obj1);
11040 if (arg2 == NULL) SWIG_fail;
11041 temp2 = true;
11042 }
11043 if (obj2) {
11044 ecode3 = SWIG_AsVal_int(obj2, &val3);
11045 if (!SWIG_IsOK(ecode3)) {
11046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11047 }
11048 arg3 = static_cast< int >(val3);
11049 }
11050 {
11051 PyThreadState* __tstate = wxPyBeginAllowThreads();
11052 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11053 wxPyEndAllowThreads(__tstate);
11054 if (PyErr_Occurred()) SWIG_fail;
11055 }
11056 {
11057 #if wxUSE_UNICODE
11058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11059 #else
11060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11061 #endif
11062 }
11063 {
11064 if (temp2)
11065 delete arg2;
11066 }
11067 return resultobj;
11068 fail:
11069 {
11070 if (temp2)
11071 delete arg2;
11072 }
11073 return NULL;
11074 }
11075
11076
11077 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11078 PyObject *resultobj = 0;
11079 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11080 wxString result;
11081 void *argp1 = 0 ;
11082 int res1 = 0 ;
11083 PyObject *swig_obj[1] ;
11084
11085 if (!args) SWIG_fail;
11086 swig_obj[0] = args;
11087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11088 if (!SWIG_IsOK(res1)) {
11089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11090 }
11091 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11092 {
11093 PyThreadState* __tstate = wxPyBeginAllowThreads();
11094 result = (arg1)->FindNext();
11095 wxPyEndAllowThreads(__tstate);
11096 if (PyErr_Occurred()) SWIG_fail;
11097 }
11098 {
11099 #if wxUSE_UNICODE
11100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11101 #else
11102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11103 #endif
11104 }
11105 return resultobj;
11106 fail:
11107 return NULL;
11108 }
11109
11110
11111 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11112 PyObject *resultobj = 0;
11113 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11114 int res1 = 0 ;
11115 PyObject * obj0 = 0 ;
11116 char * kwnames[] = {
11117 (char *) "handler", NULL
11118 };
11119
11120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11121 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11122 if (!SWIG_IsOK(res1)) {
11123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11124 }
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 wxFileSystem::AddHandler(arg1);
11128 wxPyEndAllowThreads(__tstate);
11129 if (PyErr_Occurred()) SWIG_fail;
11130 }
11131 resultobj = SWIG_Py_Void();
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11139 PyObject *resultobj = 0;
11140 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11141 wxFileSystemHandler *result = 0 ;
11142 void *argp1 = 0 ;
11143 int res1 = 0 ;
11144 PyObject * obj0 = 0 ;
11145 char * kwnames[] = {
11146 (char *) "handler", NULL
11147 };
11148
11149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11151 if (!SWIG_IsOK(res1)) {
11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11153 }
11154 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11155 {
11156 PyThreadState* __tstate = wxPyBeginAllowThreads();
11157 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11158 wxPyEndAllowThreads(__tstate);
11159 if (PyErr_Occurred()) SWIG_fail;
11160 }
11161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11162 return resultobj;
11163 fail:
11164 return NULL;
11165 }
11166
11167
11168 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11169 PyObject *resultobj = 0;
11170
11171 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11172 {
11173 PyThreadState* __tstate = wxPyBeginAllowThreads();
11174 wxFileSystem::CleanUpHandlers();
11175 wxPyEndAllowThreads(__tstate);
11176 if (PyErr_Occurred()) SWIG_fail;
11177 }
11178 resultobj = SWIG_Py_Void();
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11186 PyObject *resultobj = 0;
11187 wxString *arg1 = 0 ;
11188 wxString result;
11189 bool temp1 = false ;
11190 PyObject * obj0 = 0 ;
11191 char * kwnames[] = {
11192 (char *) "filename", NULL
11193 };
11194
11195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11196 {
11197 arg1 = wxString_in_helper(obj0);
11198 if (arg1 == NULL) SWIG_fail;
11199 temp1 = true;
11200 }
11201 {
11202 PyThreadState* __tstate = wxPyBeginAllowThreads();
11203 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11204 wxPyEndAllowThreads(__tstate);
11205 if (PyErr_Occurred()) SWIG_fail;
11206 }
11207 {
11208 #if wxUSE_UNICODE
11209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11210 #else
11211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11212 #endif
11213 }
11214 {
11215 if (temp1)
11216 delete arg1;
11217 }
11218 return resultobj;
11219 fail:
11220 {
11221 if (temp1)
11222 delete arg1;
11223 }
11224 return NULL;
11225 }
11226
11227
11228 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11229 PyObject *resultobj = 0;
11230 wxString *arg1 = 0 ;
11231 wxString result;
11232 bool temp1 = false ;
11233 PyObject * obj0 = 0 ;
11234 char * kwnames[] = {
11235 (char *) "url", NULL
11236 };
11237
11238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11239 {
11240 arg1 = wxString_in_helper(obj0);
11241 if (arg1 == NULL) SWIG_fail;
11242 temp1 = true;
11243 }
11244 {
11245 PyThreadState* __tstate = wxPyBeginAllowThreads();
11246 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
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 (temp1)
11259 delete arg1;
11260 }
11261 return resultobj;
11262 fail:
11263 {
11264 if (temp1)
11265 delete arg1;
11266 }
11267 return NULL;
11268 }
11269
11270
11271 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11272 PyObject *obj;
11273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11274 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11275 return SWIG_Py_Void();
11276 }
11277
11278 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11279 return SWIG_Python_InitShadowInstance(args);
11280 }
11281
11282 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11283 PyObject *resultobj = 0;
11284 wxInternetFSHandler *result = 0 ;
11285
11286 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11287 {
11288 PyThreadState* __tstate = wxPyBeginAllowThreads();
11289 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11290 wxPyEndAllowThreads(__tstate);
11291 if (PyErr_Occurred()) SWIG_fail;
11292 }
11293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11294 return resultobj;
11295 fail:
11296 return NULL;
11297 }
11298
11299
11300 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11301 PyObject *resultobj = 0;
11302 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11303 wxString *arg2 = 0 ;
11304 bool result;
11305 void *argp1 = 0 ;
11306 int res1 = 0 ;
11307 bool temp2 = false ;
11308 PyObject * obj0 = 0 ;
11309 PyObject * obj1 = 0 ;
11310 char * kwnames[] = {
11311 (char *) "self",(char *) "location", NULL
11312 };
11313
11314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11316 if (!SWIG_IsOK(res1)) {
11317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11318 }
11319 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11320 {
11321 arg2 = wxString_in_helper(obj1);
11322 if (arg2 == NULL) SWIG_fail;
11323 temp2 = true;
11324 }
11325 {
11326 PyThreadState* __tstate = wxPyBeginAllowThreads();
11327 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11328 wxPyEndAllowThreads(__tstate);
11329 if (PyErr_Occurred()) SWIG_fail;
11330 }
11331 {
11332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11333 }
11334 {
11335 if (temp2)
11336 delete arg2;
11337 }
11338 return resultobj;
11339 fail:
11340 {
11341 if (temp2)
11342 delete arg2;
11343 }
11344 return NULL;
11345 }
11346
11347
11348 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11349 PyObject *resultobj = 0;
11350 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11351 wxFileSystem *arg2 = 0 ;
11352 wxString *arg3 = 0 ;
11353 wxFSFile *result = 0 ;
11354 void *argp1 = 0 ;
11355 int res1 = 0 ;
11356 void *argp2 = 0 ;
11357 int res2 = 0 ;
11358 bool temp3 = false ;
11359 PyObject * obj0 = 0 ;
11360 PyObject * obj1 = 0 ;
11361 PyObject * obj2 = 0 ;
11362 char * kwnames[] = {
11363 (char *) "self",(char *) "fs",(char *) "location", NULL
11364 };
11365
11366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11368 if (!SWIG_IsOK(res1)) {
11369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11370 }
11371 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11373 if (!SWIG_IsOK(res2)) {
11374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11375 }
11376 if (!argp2) {
11377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11378 }
11379 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11380 {
11381 arg3 = wxString_in_helper(obj2);
11382 if (arg3 == NULL) SWIG_fail;
11383 temp3 = true;
11384 }
11385 {
11386 PyThreadState* __tstate = wxPyBeginAllowThreads();
11387 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11388 wxPyEndAllowThreads(__tstate);
11389 if (PyErr_Occurred()) SWIG_fail;
11390 }
11391 {
11392 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11393 }
11394 {
11395 if (temp3)
11396 delete arg3;
11397 }
11398 return resultobj;
11399 fail:
11400 {
11401 if (temp3)
11402 delete arg3;
11403 }
11404 return NULL;
11405 }
11406
11407
11408 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11409 PyObject *obj;
11410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11411 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11412 return SWIG_Py_Void();
11413 }
11414
11415 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11416 return SWIG_Python_InitShadowInstance(args);
11417 }
11418
11419 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11420 PyObject *resultobj = 0;
11421 wxZipFSHandler *result = 0 ;
11422
11423 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11424 {
11425 PyThreadState* __tstate = wxPyBeginAllowThreads();
11426 result = (wxZipFSHandler *)new wxZipFSHandler();
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11431 return resultobj;
11432 fail:
11433 return NULL;
11434 }
11435
11436
11437 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11438 PyObject *resultobj = 0;
11439 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11440 wxString *arg2 = 0 ;
11441 bool result;
11442 void *argp1 = 0 ;
11443 int res1 = 0 ;
11444 bool temp2 = false ;
11445 PyObject * obj0 = 0 ;
11446 PyObject * obj1 = 0 ;
11447 char * kwnames[] = {
11448 (char *) "self",(char *) "location", NULL
11449 };
11450
11451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11453 if (!SWIG_IsOK(res1)) {
11454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11455 }
11456 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11457 {
11458 arg2 = wxString_in_helper(obj1);
11459 if (arg2 == NULL) SWIG_fail;
11460 temp2 = true;
11461 }
11462 {
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11465 wxPyEndAllowThreads(__tstate);
11466 if (PyErr_Occurred()) SWIG_fail;
11467 }
11468 {
11469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11470 }
11471 {
11472 if (temp2)
11473 delete arg2;
11474 }
11475 return resultobj;
11476 fail:
11477 {
11478 if (temp2)
11479 delete arg2;
11480 }
11481 return NULL;
11482 }
11483
11484
11485 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11486 PyObject *resultobj = 0;
11487 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11488 wxFileSystem *arg2 = 0 ;
11489 wxString *arg3 = 0 ;
11490 wxFSFile *result = 0 ;
11491 void *argp1 = 0 ;
11492 int res1 = 0 ;
11493 void *argp2 = 0 ;
11494 int res2 = 0 ;
11495 bool temp3 = false ;
11496 PyObject * obj0 = 0 ;
11497 PyObject * obj1 = 0 ;
11498 PyObject * obj2 = 0 ;
11499 char * kwnames[] = {
11500 (char *) "self",(char *) "fs",(char *) "location", NULL
11501 };
11502
11503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11505 if (!SWIG_IsOK(res1)) {
11506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11507 }
11508 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11509 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11510 if (!SWIG_IsOK(res2)) {
11511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11512 }
11513 if (!argp2) {
11514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11515 }
11516 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11517 {
11518 arg3 = wxString_in_helper(obj2);
11519 if (arg3 == NULL) SWIG_fail;
11520 temp3 = true;
11521 }
11522 {
11523 PyThreadState* __tstate = wxPyBeginAllowThreads();
11524 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11525 wxPyEndAllowThreads(__tstate);
11526 if (PyErr_Occurred()) SWIG_fail;
11527 }
11528 {
11529 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11530 }
11531 {
11532 if (temp3)
11533 delete arg3;
11534 }
11535 return resultobj;
11536 fail:
11537 {
11538 if (temp3)
11539 delete arg3;
11540 }
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj = 0;
11547 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11548 wxString *arg2 = 0 ;
11549 int arg3 = (int) 0 ;
11550 wxString result;
11551 void *argp1 = 0 ;
11552 int res1 = 0 ;
11553 bool temp2 = false ;
11554 int val3 ;
11555 int ecode3 = 0 ;
11556 PyObject * obj0 = 0 ;
11557 PyObject * obj1 = 0 ;
11558 PyObject * obj2 = 0 ;
11559 char * kwnames[] = {
11560 (char *) "self",(char *) "spec",(char *) "flags", NULL
11561 };
11562
11563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11565 if (!SWIG_IsOK(res1)) {
11566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11567 }
11568 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11569 {
11570 arg2 = wxString_in_helper(obj1);
11571 if (arg2 == NULL) SWIG_fail;
11572 temp2 = true;
11573 }
11574 if (obj2) {
11575 ecode3 = SWIG_AsVal_int(obj2, &val3);
11576 if (!SWIG_IsOK(ecode3)) {
11577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11578 }
11579 arg3 = static_cast< int >(val3);
11580 }
11581 {
11582 PyThreadState* __tstate = wxPyBeginAllowThreads();
11583 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11584 wxPyEndAllowThreads(__tstate);
11585 if (PyErr_Occurred()) SWIG_fail;
11586 }
11587 {
11588 #if wxUSE_UNICODE
11589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11590 #else
11591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11592 #endif
11593 }
11594 {
11595 if (temp2)
11596 delete arg2;
11597 }
11598 return resultobj;
11599 fail:
11600 {
11601 if (temp2)
11602 delete arg2;
11603 }
11604 return NULL;
11605 }
11606
11607
11608 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11609 PyObject *resultobj = 0;
11610 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11611 wxString result;
11612 void *argp1 = 0 ;
11613 int res1 = 0 ;
11614 PyObject *swig_obj[1] ;
11615
11616 if (!args) SWIG_fail;
11617 swig_obj[0] = args;
11618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11619 if (!SWIG_IsOK(res1)) {
11620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11621 }
11622 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11623 {
11624 PyThreadState* __tstate = wxPyBeginAllowThreads();
11625 result = (arg1)->FindNext();
11626 wxPyEndAllowThreads(__tstate);
11627 if (PyErr_Occurred()) SWIG_fail;
11628 }
11629 {
11630 #if wxUSE_UNICODE
11631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11632 #else
11633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11634 #endif
11635 }
11636 return resultobj;
11637 fail:
11638 return NULL;
11639 }
11640
11641
11642 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11643 PyObject *obj;
11644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11645 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11646 return SWIG_Py_Void();
11647 }
11648
11649 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11650 return SWIG_Python_InitShadowInstance(args);
11651 }
11652
11653 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11654 PyObject *resultobj = 0;
11655 wxString *arg1 = 0 ;
11656 wxImage *arg2 = 0 ;
11657 long arg3 ;
11658 bool temp1 = false ;
11659 void *argp2 = 0 ;
11660 int res2 = 0 ;
11661 long val3 ;
11662 int ecode3 = 0 ;
11663 PyObject * obj0 = 0 ;
11664 PyObject * obj1 = 0 ;
11665 PyObject * obj2 = 0 ;
11666 char * kwnames[] = {
11667 (char *) "filename",(char *) "image",(char *) "type", NULL
11668 };
11669
11670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11671 {
11672 arg1 = wxString_in_helper(obj0);
11673 if (arg1 == NULL) SWIG_fail;
11674 temp1 = true;
11675 }
11676 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11677 if (!SWIG_IsOK(res2)) {
11678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11679 }
11680 if (!argp2) {
11681 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11682 }
11683 arg2 = reinterpret_cast< wxImage * >(argp2);
11684 ecode3 = SWIG_AsVal_long(obj2, &val3);
11685 if (!SWIG_IsOK(ecode3)) {
11686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11687 }
11688 arg3 = static_cast< long >(val3);
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11692 wxPyEndAllowThreads(__tstate);
11693 if (PyErr_Occurred()) SWIG_fail;
11694 }
11695 resultobj = SWIG_Py_Void();
11696 {
11697 if (temp1)
11698 delete arg1;
11699 }
11700 return resultobj;
11701 fail:
11702 {
11703 if (temp1)
11704 delete arg1;
11705 }
11706 return NULL;
11707 }
11708
11709
11710 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11711 PyObject *resultobj = 0;
11712 wxString *arg1 = 0 ;
11713 wxBitmap *arg2 = 0 ;
11714 long arg3 ;
11715 bool temp1 = false ;
11716 void *argp2 = 0 ;
11717 int res2 = 0 ;
11718 long val3 ;
11719 int ecode3 = 0 ;
11720 PyObject * obj0 = 0 ;
11721 PyObject * obj1 = 0 ;
11722 PyObject * obj2 = 0 ;
11723 char * kwnames[] = {
11724 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11725 };
11726
11727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11728 {
11729 arg1 = wxString_in_helper(obj0);
11730 if (arg1 == NULL) SWIG_fail;
11731 temp1 = true;
11732 }
11733 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11734 if (!SWIG_IsOK(res2)) {
11735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11736 }
11737 if (!argp2) {
11738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11739 }
11740 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11741 ecode3 = SWIG_AsVal_long(obj2, &val3);
11742 if (!SWIG_IsOK(ecode3)) {
11743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11744 }
11745 arg3 = static_cast< long >(val3);
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11749 wxPyEndAllowThreads(__tstate);
11750 if (PyErr_Occurred()) SWIG_fail;
11751 }
11752 resultobj = SWIG_Py_Void();
11753 {
11754 if (temp1)
11755 delete arg1;
11756 }
11757 return resultobj;
11758 fail:
11759 {
11760 if (temp1)
11761 delete arg1;
11762 }
11763 return NULL;
11764 }
11765
11766
11767 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11768 PyObject *resultobj = 0;
11769 wxString *arg1 = 0 ;
11770 PyObject *arg2 = (PyObject *) 0 ;
11771 bool temp1 = false ;
11772 PyObject * obj0 = 0 ;
11773 PyObject * obj1 = 0 ;
11774 char * kwnames[] = {
11775 (char *) "filename",(char *) "data", NULL
11776 };
11777
11778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11779 {
11780 arg1 = wxString_in_helper(obj0);
11781 if (arg1 == NULL) SWIG_fail;
11782 temp1 = true;
11783 }
11784 arg2 = obj1;
11785 {
11786 PyThreadState* __tstate = wxPyBeginAllowThreads();
11787 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11788 wxPyEndAllowThreads(__tstate);
11789 if (PyErr_Occurred()) SWIG_fail;
11790 }
11791 resultobj = SWIG_Py_Void();
11792 {
11793 if (temp1)
11794 delete arg1;
11795 }
11796 return resultobj;
11797 fail:
11798 {
11799 if (temp1)
11800 delete arg1;
11801 }
11802 return NULL;
11803 }
11804
11805
11806 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11807 PyObject *resultobj = 0;
11808 wxMemoryFSHandler *result = 0 ;
11809
11810 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11811 {
11812 PyThreadState* __tstate = wxPyBeginAllowThreads();
11813 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11814 wxPyEndAllowThreads(__tstate);
11815 if (PyErr_Occurred()) SWIG_fail;
11816 }
11817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11818 return resultobj;
11819 fail:
11820 return NULL;
11821 }
11822
11823
11824 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11825 PyObject *resultobj = 0;
11826 wxString *arg1 = 0 ;
11827 bool temp1 = false ;
11828 PyObject * obj0 = 0 ;
11829 char * kwnames[] = {
11830 (char *) "filename", NULL
11831 };
11832
11833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11834 {
11835 arg1 = wxString_in_helper(obj0);
11836 if (arg1 == NULL) SWIG_fail;
11837 temp1 = true;
11838 }
11839 {
11840 PyThreadState* __tstate = wxPyBeginAllowThreads();
11841 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11842 wxPyEndAllowThreads(__tstate);
11843 if (PyErr_Occurred()) SWIG_fail;
11844 }
11845 resultobj = SWIG_Py_Void();
11846 {
11847 if (temp1)
11848 delete arg1;
11849 }
11850 return resultobj;
11851 fail:
11852 {
11853 if (temp1)
11854 delete arg1;
11855 }
11856 return NULL;
11857 }
11858
11859
11860 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11861 PyObject *resultobj = 0;
11862 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11863 wxString *arg2 = 0 ;
11864 bool result;
11865 void *argp1 = 0 ;
11866 int res1 = 0 ;
11867 bool temp2 = false ;
11868 PyObject * obj0 = 0 ;
11869 PyObject * obj1 = 0 ;
11870 char * kwnames[] = {
11871 (char *) "self",(char *) "location", NULL
11872 };
11873
11874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11878 }
11879 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11880 {
11881 arg2 = wxString_in_helper(obj1);
11882 if (arg2 == NULL) SWIG_fail;
11883 temp2 = true;
11884 }
11885 {
11886 PyThreadState* __tstate = wxPyBeginAllowThreads();
11887 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11888 wxPyEndAllowThreads(__tstate);
11889 if (PyErr_Occurred()) SWIG_fail;
11890 }
11891 {
11892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11893 }
11894 {
11895 if (temp2)
11896 delete arg2;
11897 }
11898 return resultobj;
11899 fail:
11900 {
11901 if (temp2)
11902 delete arg2;
11903 }
11904 return NULL;
11905 }
11906
11907
11908 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11909 PyObject *resultobj = 0;
11910 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11911 wxFileSystem *arg2 = 0 ;
11912 wxString *arg3 = 0 ;
11913 wxFSFile *result = 0 ;
11914 void *argp1 = 0 ;
11915 int res1 = 0 ;
11916 void *argp2 = 0 ;
11917 int res2 = 0 ;
11918 bool temp3 = false ;
11919 PyObject * obj0 = 0 ;
11920 PyObject * obj1 = 0 ;
11921 PyObject * obj2 = 0 ;
11922 char * kwnames[] = {
11923 (char *) "self",(char *) "fs",(char *) "location", NULL
11924 };
11925
11926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11928 if (!SWIG_IsOK(res1)) {
11929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11930 }
11931 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11932 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11933 if (!SWIG_IsOK(res2)) {
11934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11935 }
11936 if (!argp2) {
11937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11938 }
11939 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11940 {
11941 arg3 = wxString_in_helper(obj2);
11942 if (arg3 == NULL) SWIG_fail;
11943 temp3 = true;
11944 }
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 {
11952 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11953 }
11954 {
11955 if (temp3)
11956 delete arg3;
11957 }
11958 return resultobj;
11959 fail:
11960 {
11961 if (temp3)
11962 delete arg3;
11963 }
11964 return NULL;
11965 }
11966
11967
11968 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11969 PyObject *resultobj = 0;
11970 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11971 wxString *arg2 = 0 ;
11972 int arg3 = (int) 0 ;
11973 wxString result;
11974 void *argp1 = 0 ;
11975 int res1 = 0 ;
11976 bool temp2 = false ;
11977 int val3 ;
11978 int ecode3 = 0 ;
11979 PyObject * obj0 = 0 ;
11980 PyObject * obj1 = 0 ;
11981 PyObject * obj2 = 0 ;
11982 char * kwnames[] = {
11983 (char *) "self",(char *) "spec",(char *) "flags", NULL
11984 };
11985
11986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11988 if (!SWIG_IsOK(res1)) {
11989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11990 }
11991 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11992 {
11993 arg2 = wxString_in_helper(obj1);
11994 if (arg2 == NULL) SWIG_fail;
11995 temp2 = true;
11996 }
11997 if (obj2) {
11998 ecode3 = SWIG_AsVal_int(obj2, &val3);
11999 if (!SWIG_IsOK(ecode3)) {
12000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12001 }
12002 arg3 = static_cast< int >(val3);
12003 }
12004 {
12005 PyThreadState* __tstate = wxPyBeginAllowThreads();
12006 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 #if wxUSE_UNICODE
12012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12013 #else
12014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12015 #endif
12016 }
12017 {
12018 if (temp2)
12019 delete arg2;
12020 }
12021 return resultobj;
12022 fail:
12023 {
12024 if (temp2)
12025 delete arg2;
12026 }
12027 return NULL;
12028 }
12029
12030
12031 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12032 PyObject *resultobj = 0;
12033 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12034 wxString result;
12035 void *argp1 = 0 ;
12036 int res1 = 0 ;
12037 PyObject *swig_obj[1] ;
12038
12039 if (!args) SWIG_fail;
12040 swig_obj[0] = args;
12041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12042 if (!SWIG_IsOK(res1)) {
12043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12044 }
12045 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12046 {
12047 PyThreadState* __tstate = wxPyBeginAllowThreads();
12048 result = (arg1)->FindNext();
12049 wxPyEndAllowThreads(__tstate);
12050 if (PyErr_Occurred()) SWIG_fail;
12051 }
12052 {
12053 #if wxUSE_UNICODE
12054 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12055 #else
12056 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12057 #endif
12058 }
12059 return resultobj;
12060 fail:
12061 return NULL;
12062 }
12063
12064
12065 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12066 PyObject *obj;
12067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12068 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12069 return SWIG_Py_Void();
12070 }
12071
12072 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12073 return SWIG_Python_InitShadowInstance(args);
12074 }
12075
12076 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12077 PyObject *resultobj = 0;
12078 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12079 wxString result;
12080 void *argp1 = 0 ;
12081 int res1 = 0 ;
12082 PyObject *swig_obj[1] ;
12083
12084 if (!args) SWIG_fail;
12085 swig_obj[0] = args;
12086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12087 if (!SWIG_IsOK(res1)) {
12088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12089 }
12090 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12091 {
12092 PyThreadState* __tstate = wxPyBeginAllowThreads();
12093 result = (arg1)->GetName();
12094 wxPyEndAllowThreads(__tstate);
12095 if (PyErr_Occurred()) SWIG_fail;
12096 }
12097 {
12098 #if wxUSE_UNICODE
12099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12100 #else
12101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12102 #endif
12103 }
12104 return resultobj;
12105 fail:
12106 return NULL;
12107 }
12108
12109
12110 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12111 PyObject *resultobj = 0;
12112 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12113 wxString result;
12114 void *argp1 = 0 ;
12115 int res1 = 0 ;
12116 PyObject *swig_obj[1] ;
12117
12118 if (!args) SWIG_fail;
12119 swig_obj[0] = args;
12120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12121 if (!SWIG_IsOK(res1)) {
12122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12123 }
12124 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12125 {
12126 PyThreadState* __tstate = wxPyBeginAllowThreads();
12127 result = (arg1)->GetExtension();
12128 wxPyEndAllowThreads(__tstate);
12129 if (PyErr_Occurred()) SWIG_fail;
12130 }
12131 {
12132 #if wxUSE_UNICODE
12133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12134 #else
12135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12136 #endif
12137 }
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 PyObject *resultobj = 0;
12146 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12147 long result;
12148 void *argp1 = 0 ;
12149 int res1 = 0 ;
12150 PyObject *swig_obj[1] ;
12151
12152 if (!args) SWIG_fail;
12153 swig_obj[0] = args;
12154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12155 if (!SWIG_IsOK(res1)) {
12156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12157 }
12158 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (long)(arg1)->GetType();
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 resultobj = SWIG_From_long(static_cast< long >(result));
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12173 PyObject *resultobj = 0;
12174 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12175 wxString result;
12176 void *argp1 = 0 ;
12177 int res1 = 0 ;
12178 PyObject *swig_obj[1] ;
12179
12180 if (!args) SWIG_fail;
12181 swig_obj[0] = args;
12182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12183 if (!SWIG_IsOK(res1)) {
12184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12185 }
12186 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 result = (arg1)->GetMimeType();
12190 wxPyEndAllowThreads(__tstate);
12191 if (PyErr_Occurred()) SWIG_fail;
12192 }
12193 {
12194 #if wxUSE_UNICODE
12195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12196 #else
12197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12198 #endif
12199 }
12200 return resultobj;
12201 fail:
12202 return NULL;
12203 }
12204
12205
12206 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12207 PyObject *resultobj = 0;
12208 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12209 wxString *arg2 = 0 ;
12210 bool result;
12211 void *argp1 = 0 ;
12212 int res1 = 0 ;
12213 bool temp2 = false ;
12214 PyObject * obj0 = 0 ;
12215 PyObject * obj1 = 0 ;
12216 char * kwnames[] = {
12217 (char *) "self",(char *) "name", NULL
12218 };
12219
12220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12222 if (!SWIG_IsOK(res1)) {
12223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12224 }
12225 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12226 {
12227 arg2 = wxString_in_helper(obj1);
12228 if (arg2 == NULL) SWIG_fail;
12229 temp2 = true;
12230 }
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12234 wxPyEndAllowThreads(__tstate);
12235 if (PyErr_Occurred()) SWIG_fail;
12236 }
12237 {
12238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12239 }
12240 {
12241 if (temp2)
12242 delete arg2;
12243 }
12244 return resultobj;
12245 fail:
12246 {
12247 if (temp2)
12248 delete arg2;
12249 }
12250 return NULL;
12251 }
12252
12253
12254 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12255 PyObject *resultobj = 0;
12256 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12257 wxInputStream *arg2 = 0 ;
12258 bool result;
12259 void *argp1 = 0 ;
12260 int res1 = 0 ;
12261 wxPyInputStream *temp2 ;
12262 bool created2 ;
12263 PyObject * obj0 = 0 ;
12264 PyObject * obj1 = 0 ;
12265 char * kwnames[] = {
12266 (char *) "self",(char *) "stream", NULL
12267 };
12268
12269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12271 if (!SWIG_IsOK(res1)) {
12272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12273 }
12274 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12275 {
12276 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12277 arg2 = temp2->m_wxis;
12278 created2 = false;
12279 } else {
12280 PyErr_Clear(); // clear the failure of the wxPyConvert above
12281 arg2 = wxPyCBInputStream_create(obj1, false);
12282 if (arg2 == NULL) {
12283 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12284 SWIG_fail;
12285 }
12286 created2 = true;
12287 }
12288 }
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 result = (bool)(arg1)->CanRead(*arg2);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 {
12296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12297 }
12298 {
12299 if (created2) delete arg2;
12300 }
12301 return resultobj;
12302 fail:
12303 {
12304 if (created2) delete arg2;
12305 }
12306 return NULL;
12307 }
12308
12309
12310 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12311 PyObject *resultobj = 0;
12312 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12313 wxString *arg2 = 0 ;
12314 void *argp1 = 0 ;
12315 int res1 = 0 ;
12316 bool temp2 = false ;
12317 PyObject * obj0 = 0 ;
12318 PyObject * obj1 = 0 ;
12319 char * kwnames[] = {
12320 (char *) "self",(char *) "name", NULL
12321 };
12322
12323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12325 if (!SWIG_IsOK(res1)) {
12326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12327 }
12328 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12329 {
12330 arg2 = wxString_in_helper(obj1);
12331 if (arg2 == NULL) SWIG_fail;
12332 temp2 = true;
12333 }
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 (arg1)->SetName((wxString const &)*arg2);
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 resultobj = SWIG_Py_Void();
12341 {
12342 if (temp2)
12343 delete arg2;
12344 }
12345 return resultobj;
12346 fail:
12347 {
12348 if (temp2)
12349 delete arg2;
12350 }
12351 return NULL;
12352 }
12353
12354
12355 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12356 PyObject *resultobj = 0;
12357 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12358 wxString *arg2 = 0 ;
12359 void *argp1 = 0 ;
12360 int res1 = 0 ;
12361 bool temp2 = false ;
12362 PyObject * obj0 = 0 ;
12363 PyObject * obj1 = 0 ;
12364 char * kwnames[] = {
12365 (char *) "self",(char *) "extension", NULL
12366 };
12367
12368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12370 if (!SWIG_IsOK(res1)) {
12371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12372 }
12373 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12374 {
12375 arg2 = wxString_in_helper(obj1);
12376 if (arg2 == NULL) SWIG_fail;
12377 temp2 = true;
12378 }
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 (arg1)->SetExtension((wxString const &)*arg2);
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 resultobj = SWIG_Py_Void();
12386 {
12387 if (temp2)
12388 delete arg2;
12389 }
12390 return resultobj;
12391 fail:
12392 {
12393 if (temp2)
12394 delete arg2;
12395 }
12396 return NULL;
12397 }
12398
12399
12400 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12401 PyObject *resultobj = 0;
12402 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12403 long arg2 ;
12404 void *argp1 = 0 ;
12405 int res1 = 0 ;
12406 long val2 ;
12407 int ecode2 = 0 ;
12408 PyObject * obj0 = 0 ;
12409 PyObject * obj1 = 0 ;
12410 char * kwnames[] = {
12411 (char *) "self",(char *) "type", NULL
12412 };
12413
12414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12416 if (!SWIG_IsOK(res1)) {
12417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12418 }
12419 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12420 ecode2 = SWIG_AsVal_long(obj1, &val2);
12421 if (!SWIG_IsOK(ecode2)) {
12422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12423 }
12424 arg2 = static_cast< long >(val2);
12425 {
12426 PyThreadState* __tstate = wxPyBeginAllowThreads();
12427 (arg1)->SetType(arg2);
12428 wxPyEndAllowThreads(__tstate);
12429 if (PyErr_Occurred()) SWIG_fail;
12430 }
12431 resultobj = SWIG_Py_Void();
12432 return resultobj;
12433 fail:
12434 return NULL;
12435 }
12436
12437
12438 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12439 PyObject *resultobj = 0;
12440 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12441 wxString *arg2 = 0 ;
12442 void *argp1 = 0 ;
12443 int res1 = 0 ;
12444 bool temp2 = false ;
12445 PyObject * obj0 = 0 ;
12446 PyObject * obj1 = 0 ;
12447 char * kwnames[] = {
12448 (char *) "self",(char *) "mimetype", NULL
12449 };
12450
12451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12453 if (!SWIG_IsOK(res1)) {
12454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12455 }
12456 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12457 {
12458 arg2 = wxString_in_helper(obj1);
12459 if (arg2 == NULL) SWIG_fail;
12460 temp2 = true;
12461 }
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 (arg1)->SetMimeType((wxString const &)*arg2);
12465 wxPyEndAllowThreads(__tstate);
12466 if (PyErr_Occurred()) SWIG_fail;
12467 }
12468 resultobj = SWIG_Py_Void();
12469 {
12470 if (temp2)
12471 delete arg2;
12472 }
12473 return resultobj;
12474 fail:
12475 {
12476 if (temp2)
12477 delete arg2;
12478 }
12479 return NULL;
12480 }
12481
12482
12483 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12484 PyObject *obj;
12485 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12486 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12487 return SWIG_Py_Void();
12488 }
12489
12490 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12491 PyObject *resultobj = 0;
12492 wxPyImageHandler *result = 0 ;
12493
12494 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = (wxPyImageHandler *)new wxPyImageHandler();
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12509 PyObject *resultobj = 0;
12510 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12511 PyObject *arg2 = (PyObject *) 0 ;
12512 void *argp1 = 0 ;
12513 int res1 = 0 ;
12514 PyObject * obj0 = 0 ;
12515 PyObject * obj1 = 0 ;
12516 char * kwnames[] = {
12517 (char *) "self",(char *) "self", NULL
12518 };
12519
12520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12522 if (!SWIG_IsOK(res1)) {
12523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12524 }
12525 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12526 arg2 = obj1;
12527 {
12528 PyThreadState* __tstate = wxPyBeginAllowThreads();
12529 (arg1)->_SetSelf(arg2);
12530 wxPyEndAllowThreads(__tstate);
12531 if (PyErr_Occurred()) SWIG_fail;
12532 }
12533 resultobj = SWIG_Py_Void();
12534 return resultobj;
12535 fail:
12536 return NULL;
12537 }
12538
12539
12540 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12541 PyObject *obj;
12542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12543 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12544 return SWIG_Py_Void();
12545 }
12546
12547 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12548 return SWIG_Python_InitShadowInstance(args);
12549 }
12550
12551 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12552 PyObject *resultobj = 0;
12553 wxImageHistogram *result = 0 ;
12554
12555 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12556 {
12557 PyThreadState* __tstate = wxPyBeginAllowThreads();
12558 result = (wxImageHistogram *)new wxImageHistogram();
12559 wxPyEndAllowThreads(__tstate);
12560 if (PyErr_Occurred()) SWIG_fail;
12561 }
12562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12563 return resultobj;
12564 fail:
12565 return NULL;
12566 }
12567
12568
12569 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12570 PyObject *resultobj = 0;
12571 byte arg1 ;
12572 byte arg2 ;
12573 byte arg3 ;
12574 unsigned long result;
12575 unsigned char val1 ;
12576 int ecode1 = 0 ;
12577 unsigned char val2 ;
12578 int ecode2 = 0 ;
12579 unsigned char val3 ;
12580 int ecode3 = 0 ;
12581 PyObject * obj0 = 0 ;
12582 PyObject * obj1 = 0 ;
12583 PyObject * obj2 = 0 ;
12584 char * kwnames[] = {
12585 (char *) "r",(char *) "g",(char *) "b", NULL
12586 };
12587
12588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12589 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12590 if (!SWIG_IsOK(ecode1)) {
12591 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12592 }
12593 arg1 = static_cast< byte >(val1);
12594 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12595 if (!SWIG_IsOK(ecode2)) {
12596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12597 }
12598 arg2 = static_cast< byte >(val2);
12599 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12600 if (!SWIG_IsOK(ecode3)) {
12601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12602 }
12603 arg3 = static_cast< byte >(val3);
12604 {
12605 PyThreadState* __tstate = wxPyBeginAllowThreads();
12606 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12607 wxPyEndAllowThreads(__tstate);
12608 if (PyErr_Occurred()) SWIG_fail;
12609 }
12610 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12611 return resultobj;
12612 fail:
12613 return NULL;
12614 }
12615
12616
12617 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12618 PyObject *resultobj = 0;
12619 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12620 byte *arg2 = (byte *) 0 ;
12621 byte *arg3 = (byte *) 0 ;
12622 byte *arg4 = (byte *) 0 ;
12623 byte arg5 = (byte) 1 ;
12624 byte arg6 = (byte) 0 ;
12625 byte arg7 = (byte) 0 ;
12626 bool result;
12627 void *argp1 = 0 ;
12628 int res1 = 0 ;
12629 byte temp2 ;
12630 int res2 = SWIG_TMPOBJ ;
12631 byte temp3 ;
12632 int res3 = SWIG_TMPOBJ ;
12633 byte temp4 ;
12634 int res4 = SWIG_TMPOBJ ;
12635 unsigned char val5 ;
12636 int ecode5 = 0 ;
12637 unsigned char val6 ;
12638 int ecode6 = 0 ;
12639 unsigned char val7 ;
12640 int ecode7 = 0 ;
12641 PyObject * obj0 = 0 ;
12642 PyObject * obj1 = 0 ;
12643 PyObject * obj2 = 0 ;
12644 PyObject * obj3 = 0 ;
12645 char * kwnames[] = {
12646 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12647 };
12648
12649 arg2 = &temp2;
12650 arg3 = &temp3;
12651 arg4 = &temp4;
12652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12654 if (!SWIG_IsOK(res1)) {
12655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12656 }
12657 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12658 if (obj1) {
12659 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12660 if (!SWIG_IsOK(ecode5)) {
12661 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12662 }
12663 arg5 = static_cast< byte >(val5);
12664 }
12665 if (obj2) {
12666 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12667 if (!SWIG_IsOK(ecode6)) {
12668 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12669 }
12670 arg6 = static_cast< byte >(val6);
12671 }
12672 if (obj3) {
12673 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12674 if (!SWIG_IsOK(ecode7)) {
12675 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12676 }
12677 arg7 = static_cast< byte >(val7);
12678 }
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 {
12686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12687 }
12688 if (SWIG_IsTmpObj(res2)) {
12689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12690 } else {
12691 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12693 }
12694 if (SWIG_IsTmpObj(res3)) {
12695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12696 } else {
12697 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12699 }
12700 if (SWIG_IsTmpObj(res4)) {
12701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12702 } else {
12703 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12705 }
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12713 PyObject *resultobj = 0;
12714 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12715 unsigned long arg2 ;
12716 unsigned long result;
12717 void *argp1 = 0 ;
12718 int res1 = 0 ;
12719 unsigned long val2 ;
12720 int ecode2 = 0 ;
12721 PyObject * obj0 = 0 ;
12722 PyObject * obj1 = 0 ;
12723 char * kwnames[] = {
12724 (char *) "self",(char *) "key", NULL
12725 };
12726
12727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12729 if (!SWIG_IsOK(res1)) {
12730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12731 }
12732 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12733 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12734 if (!SWIG_IsOK(ecode2)) {
12735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12736 }
12737 arg2 = static_cast< unsigned long >(val2);
12738 {
12739 PyThreadState* __tstate = wxPyBeginAllowThreads();
12740 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12741 wxPyEndAllowThreads(__tstate);
12742 if (PyErr_Occurred()) SWIG_fail;
12743 }
12744 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12752 PyObject *resultobj = 0;
12753 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12754 byte arg2 ;
12755 byte arg3 ;
12756 byte arg4 ;
12757 unsigned long result;
12758 void *argp1 = 0 ;
12759 int res1 = 0 ;
12760 unsigned char val2 ;
12761 int ecode2 = 0 ;
12762 unsigned char val3 ;
12763 int ecode3 = 0 ;
12764 unsigned char val4 ;
12765 int ecode4 = 0 ;
12766 PyObject * obj0 = 0 ;
12767 PyObject * obj1 = 0 ;
12768 PyObject * obj2 = 0 ;
12769 PyObject * obj3 = 0 ;
12770 char * kwnames[] = {
12771 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12772 };
12773
12774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12776 if (!SWIG_IsOK(res1)) {
12777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12778 }
12779 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12780 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12781 if (!SWIG_IsOK(ecode2)) {
12782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12783 }
12784 arg2 = static_cast< byte >(val2);
12785 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12786 if (!SWIG_IsOK(ecode3)) {
12787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12788 }
12789 arg3 = static_cast< byte >(val3);
12790 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12791 if (!SWIG_IsOK(ecode4)) {
12792 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12793 }
12794 arg4 = static_cast< byte >(val4);
12795 {
12796 PyThreadState* __tstate = wxPyBeginAllowThreads();
12797 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12798 wxPyEndAllowThreads(__tstate);
12799 if (PyErr_Occurred()) SWIG_fail;
12800 }
12801 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12802 return resultobj;
12803 fail:
12804 return NULL;
12805 }
12806
12807
12808 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12809 PyObject *resultobj = 0;
12810 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12811 wxColour *arg2 = 0 ;
12812 unsigned long result;
12813 void *argp1 = 0 ;
12814 int res1 = 0 ;
12815 wxColour temp2 ;
12816 PyObject * obj0 = 0 ;
12817 PyObject * obj1 = 0 ;
12818 char * kwnames[] = {
12819 (char *) "self",(char *) "colour", NULL
12820 };
12821
12822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12824 if (!SWIG_IsOK(res1)) {
12825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12826 }
12827 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12828 {
12829 arg2 = &temp2;
12830 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12831 }
12832 {
12833 PyThreadState* __tstate = wxPyBeginAllowThreads();
12834 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12835 wxPyEndAllowThreads(__tstate);
12836 if (PyErr_Occurred()) SWIG_fail;
12837 }
12838 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12839 return resultobj;
12840 fail:
12841 return NULL;
12842 }
12843
12844
12845 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12846 PyObject *obj;
12847 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12848 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12849 return SWIG_Py_Void();
12850 }
12851
12852 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12853 return SWIG_Python_InitShadowInstance(args);
12854 }
12855
12856 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12857 PyObject *resultobj = 0;
12858 byte arg1 = (byte) 0 ;
12859 byte arg2 = (byte) 0 ;
12860 byte arg3 = (byte) 0 ;
12861 wxImage_RGBValue *result = 0 ;
12862 unsigned char val1 ;
12863 int ecode1 = 0 ;
12864 unsigned char val2 ;
12865 int ecode2 = 0 ;
12866 unsigned char val3 ;
12867 int ecode3 = 0 ;
12868 PyObject * obj0 = 0 ;
12869 PyObject * obj1 = 0 ;
12870 PyObject * obj2 = 0 ;
12871 char * kwnames[] = {
12872 (char *) "r",(char *) "g",(char *) "b", NULL
12873 };
12874
12875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12876 if (obj0) {
12877 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12878 if (!SWIG_IsOK(ecode1)) {
12879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12880 }
12881 arg1 = static_cast< byte >(val1);
12882 }
12883 if (obj1) {
12884 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12885 if (!SWIG_IsOK(ecode2)) {
12886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12887 }
12888 arg2 = static_cast< byte >(val2);
12889 }
12890 if (obj2) {
12891 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12892 if (!SWIG_IsOK(ecode3)) {
12893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12894 }
12895 arg3 = static_cast< byte >(val3);
12896 }
12897 {
12898 PyThreadState* __tstate = wxPyBeginAllowThreads();
12899 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12900 wxPyEndAllowThreads(__tstate);
12901 if (PyErr_Occurred()) SWIG_fail;
12902 }
12903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12904 return resultobj;
12905 fail:
12906 return NULL;
12907 }
12908
12909
12910 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12911 PyObject *resultobj = 0;
12912 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12913 byte arg2 ;
12914 void *argp1 = 0 ;
12915 int res1 = 0 ;
12916 unsigned char val2 ;
12917 int ecode2 = 0 ;
12918 PyObject *swig_obj[2] ;
12919
12920 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12922 if (!SWIG_IsOK(res1)) {
12923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12924 }
12925 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12926 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12927 if (!SWIG_IsOK(ecode2)) {
12928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12929 }
12930 arg2 = static_cast< byte >(val2);
12931 if (arg1) (arg1)->red = arg2;
12932
12933 resultobj = SWIG_Py_Void();
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12941 PyObject *resultobj = 0;
12942 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12943 byte result;
12944 void *argp1 = 0 ;
12945 int res1 = 0 ;
12946 PyObject *swig_obj[1] ;
12947
12948 if (!args) SWIG_fail;
12949 swig_obj[0] = args;
12950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12951 if (!SWIG_IsOK(res1)) {
12952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12953 }
12954 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12955 result = (byte) ((arg1)->red);
12956 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12957 return resultobj;
12958 fail:
12959 return NULL;
12960 }
12961
12962
12963 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12964 PyObject *resultobj = 0;
12965 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12966 byte arg2 ;
12967 void *argp1 = 0 ;
12968 int res1 = 0 ;
12969 unsigned char val2 ;
12970 int ecode2 = 0 ;
12971 PyObject *swig_obj[2] ;
12972
12973 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12975 if (!SWIG_IsOK(res1)) {
12976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12977 }
12978 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12979 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12980 if (!SWIG_IsOK(ecode2)) {
12981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12982 }
12983 arg2 = static_cast< byte >(val2);
12984 if (arg1) (arg1)->green = arg2;
12985
12986 resultobj = SWIG_Py_Void();
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12994 PyObject *resultobj = 0;
12995 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12996 byte result;
12997 void *argp1 = 0 ;
12998 int res1 = 0 ;
12999 PyObject *swig_obj[1] ;
13000
13001 if (!args) SWIG_fail;
13002 swig_obj[0] = args;
13003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13004 if (!SWIG_IsOK(res1)) {
13005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13006 }
13007 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13008 result = (byte) ((arg1)->green);
13009 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13010 return resultobj;
13011 fail:
13012 return NULL;
13013 }
13014
13015
13016 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13017 PyObject *resultobj = 0;
13018 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13019 byte arg2 ;
13020 void *argp1 = 0 ;
13021 int res1 = 0 ;
13022 unsigned char val2 ;
13023 int ecode2 = 0 ;
13024 PyObject *swig_obj[2] ;
13025
13026 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13028 if (!SWIG_IsOK(res1)) {
13029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13030 }
13031 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13032 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13033 if (!SWIG_IsOK(ecode2)) {
13034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13035 }
13036 arg2 = static_cast< byte >(val2);
13037 if (arg1) (arg1)->blue = arg2;
13038
13039 resultobj = SWIG_Py_Void();
13040 return resultobj;
13041 fail:
13042 return NULL;
13043 }
13044
13045
13046 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13047 PyObject *resultobj = 0;
13048 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13049 byte result;
13050 void *argp1 = 0 ;
13051 int res1 = 0 ;
13052 PyObject *swig_obj[1] ;
13053
13054 if (!args) SWIG_fail;
13055 swig_obj[0] = args;
13056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13057 if (!SWIG_IsOK(res1)) {
13058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13059 }
13060 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13061 result = (byte) ((arg1)->blue);
13062 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13063 return resultobj;
13064 fail:
13065 return NULL;
13066 }
13067
13068
13069 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13070 PyObject *obj;
13071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13072 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13073 return SWIG_Py_Void();
13074 }
13075
13076 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13077 return SWIG_Python_InitShadowInstance(args);
13078 }
13079
13080 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13081 PyObject *resultobj = 0;
13082 double arg1 = (double) 0.0 ;
13083 double arg2 = (double) 0.0 ;
13084 double arg3 = (double) 0.0 ;
13085 wxImage_HSVValue *result = 0 ;
13086 double val1 ;
13087 int ecode1 = 0 ;
13088 double val2 ;
13089 int ecode2 = 0 ;
13090 double val3 ;
13091 int ecode3 = 0 ;
13092 PyObject * obj0 = 0 ;
13093 PyObject * obj1 = 0 ;
13094 PyObject * obj2 = 0 ;
13095 char * kwnames[] = {
13096 (char *) "h",(char *) "s",(char *) "v", NULL
13097 };
13098
13099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13100 if (obj0) {
13101 ecode1 = SWIG_AsVal_double(obj0, &val1);
13102 if (!SWIG_IsOK(ecode1)) {
13103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13104 }
13105 arg1 = static_cast< double >(val1);
13106 }
13107 if (obj1) {
13108 ecode2 = SWIG_AsVal_double(obj1, &val2);
13109 if (!SWIG_IsOK(ecode2)) {
13110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13111 }
13112 arg2 = static_cast< double >(val2);
13113 }
13114 if (obj2) {
13115 ecode3 = SWIG_AsVal_double(obj2, &val3);
13116 if (!SWIG_IsOK(ecode3)) {
13117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13118 }
13119 arg3 = static_cast< double >(val3);
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13124 wxPyEndAllowThreads(__tstate);
13125 if (PyErr_Occurred()) SWIG_fail;
13126 }
13127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13128 return resultobj;
13129 fail:
13130 return NULL;
13131 }
13132
13133
13134 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13135 PyObject *resultobj = 0;
13136 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13137 double arg2 ;
13138 void *argp1 = 0 ;
13139 int res1 = 0 ;
13140 double val2 ;
13141 int ecode2 = 0 ;
13142 PyObject *swig_obj[2] ;
13143
13144 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13146 if (!SWIG_IsOK(res1)) {
13147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13148 }
13149 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13150 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13151 if (!SWIG_IsOK(ecode2)) {
13152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13153 }
13154 arg2 = static_cast< double >(val2);
13155 if (arg1) (arg1)->hue = arg2;
13156
13157 resultobj = SWIG_Py_Void();
13158 return resultobj;
13159 fail:
13160 return NULL;
13161 }
13162
13163
13164 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13165 PyObject *resultobj = 0;
13166 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13167 double result;
13168 void *argp1 = 0 ;
13169 int res1 = 0 ;
13170 PyObject *swig_obj[1] ;
13171
13172 if (!args) SWIG_fail;
13173 swig_obj[0] = args;
13174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13175 if (!SWIG_IsOK(res1)) {
13176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13177 }
13178 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13179 result = (double) ((arg1)->hue);
13180 resultobj = SWIG_From_double(static_cast< double >(result));
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13188 PyObject *resultobj = 0;
13189 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13190 double arg2 ;
13191 void *argp1 = 0 ;
13192 int res1 = 0 ;
13193 double val2 ;
13194 int ecode2 = 0 ;
13195 PyObject *swig_obj[2] ;
13196
13197 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13199 if (!SWIG_IsOK(res1)) {
13200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13201 }
13202 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13203 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13204 if (!SWIG_IsOK(ecode2)) {
13205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13206 }
13207 arg2 = static_cast< double >(val2);
13208 if (arg1) (arg1)->saturation = arg2;
13209
13210 resultobj = SWIG_Py_Void();
13211 return resultobj;
13212 fail:
13213 return NULL;
13214 }
13215
13216
13217 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13218 PyObject *resultobj = 0;
13219 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13220 double result;
13221 void *argp1 = 0 ;
13222 int res1 = 0 ;
13223 PyObject *swig_obj[1] ;
13224
13225 if (!args) SWIG_fail;
13226 swig_obj[0] = args;
13227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13228 if (!SWIG_IsOK(res1)) {
13229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13230 }
13231 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13232 result = (double) ((arg1)->saturation);
13233 resultobj = SWIG_From_double(static_cast< double >(result));
13234 return resultobj;
13235 fail:
13236 return NULL;
13237 }
13238
13239
13240 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13241 PyObject *resultobj = 0;
13242 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13243 double arg2 ;
13244 void *argp1 = 0 ;
13245 int res1 = 0 ;
13246 double val2 ;
13247 int ecode2 = 0 ;
13248 PyObject *swig_obj[2] ;
13249
13250 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13252 if (!SWIG_IsOK(res1)) {
13253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13254 }
13255 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13256 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13257 if (!SWIG_IsOK(ecode2)) {
13258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13259 }
13260 arg2 = static_cast< double >(val2);
13261 if (arg1) (arg1)->value = arg2;
13262
13263 resultobj = SWIG_Py_Void();
13264 return resultobj;
13265 fail:
13266 return NULL;
13267 }
13268
13269
13270 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13271 PyObject *resultobj = 0;
13272 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13273 double result;
13274 void *argp1 = 0 ;
13275 int res1 = 0 ;
13276 PyObject *swig_obj[1] ;
13277
13278 if (!args) SWIG_fail;
13279 swig_obj[0] = args;
13280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13281 if (!SWIG_IsOK(res1)) {
13282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13283 }
13284 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13285 result = (double) ((arg1)->value);
13286 resultobj = SWIG_From_double(static_cast< double >(result));
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13294 PyObject *obj;
13295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13296 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13297 return SWIG_Py_Void();
13298 }
13299
13300 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13301 return SWIG_Python_InitShadowInstance(args);
13302 }
13303
13304 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13305 PyObject *resultobj = 0;
13306 wxString *arg1 = 0 ;
13307 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13308 int arg3 = (int) -1 ;
13309 wxImage *result = 0 ;
13310 bool temp1 = false ;
13311 long val2 ;
13312 int ecode2 = 0 ;
13313 int val3 ;
13314 int ecode3 = 0 ;
13315 PyObject * obj0 = 0 ;
13316 PyObject * obj1 = 0 ;
13317 PyObject * obj2 = 0 ;
13318 char * kwnames[] = {
13319 (char *) "name",(char *) "type",(char *) "index", NULL
13320 };
13321
13322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13323 {
13324 arg1 = wxString_in_helper(obj0);
13325 if (arg1 == NULL) SWIG_fail;
13326 temp1 = true;
13327 }
13328 if (obj1) {
13329 ecode2 = SWIG_AsVal_long(obj1, &val2);
13330 if (!SWIG_IsOK(ecode2)) {
13331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13332 }
13333 arg2 = static_cast< long >(val2);
13334 }
13335 if (obj2) {
13336 ecode3 = SWIG_AsVal_int(obj2, &val3);
13337 if (!SWIG_IsOK(ecode3)) {
13338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13339 }
13340 arg3 = static_cast< int >(val3);
13341 }
13342 {
13343 PyThreadState* __tstate = wxPyBeginAllowThreads();
13344 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13345 wxPyEndAllowThreads(__tstate);
13346 if (PyErr_Occurred()) SWIG_fail;
13347 }
13348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13349 {
13350 if (temp1)
13351 delete arg1;
13352 }
13353 return resultobj;
13354 fail:
13355 {
13356 if (temp1)
13357 delete arg1;
13358 }
13359 return NULL;
13360 }
13361
13362
13363 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13364 PyObject *resultobj = 0;
13365 wxImage *arg1 = (wxImage *) 0 ;
13366 void *argp1 = 0 ;
13367 int res1 = 0 ;
13368 PyObject *swig_obj[1] ;
13369
13370 if (!args) SWIG_fail;
13371 swig_obj[0] = args;
13372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13373 if (!SWIG_IsOK(res1)) {
13374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13375 }
13376 arg1 = reinterpret_cast< wxImage * >(argp1);
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 delete arg1;
13380
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 resultobj = SWIG_Py_Void();
13385 return resultobj;
13386 fail:
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13392 PyObject *resultobj = 0;
13393 wxString *arg1 = 0 ;
13394 wxString *arg2 = 0 ;
13395 int arg3 = (int) -1 ;
13396 wxImage *result = 0 ;
13397 bool temp1 = false ;
13398 bool temp2 = false ;
13399 int val3 ;
13400 int ecode3 = 0 ;
13401 PyObject * obj0 = 0 ;
13402 PyObject * obj1 = 0 ;
13403 PyObject * obj2 = 0 ;
13404 char * kwnames[] = {
13405 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13406 };
13407
13408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13409 {
13410 arg1 = wxString_in_helper(obj0);
13411 if (arg1 == NULL) SWIG_fail;
13412 temp1 = true;
13413 }
13414 {
13415 arg2 = wxString_in_helper(obj1);
13416 if (arg2 == NULL) SWIG_fail;
13417 temp2 = true;
13418 }
13419 if (obj2) {
13420 ecode3 = SWIG_AsVal_int(obj2, &val3);
13421 if (!SWIG_IsOK(ecode3)) {
13422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13423 }
13424 arg3 = static_cast< int >(val3);
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13433 {
13434 if (temp1)
13435 delete arg1;
13436 }
13437 {
13438 if (temp2)
13439 delete arg2;
13440 }
13441 return resultobj;
13442 fail:
13443 {
13444 if (temp1)
13445 delete arg1;
13446 }
13447 {
13448 if (temp2)
13449 delete arg2;
13450 }
13451 return NULL;
13452 }
13453
13454
13455 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13456 PyObject *resultobj = 0;
13457 wxInputStream *arg1 = 0 ;
13458 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13459 int arg3 = (int) -1 ;
13460 wxImage *result = 0 ;
13461 wxPyInputStream *temp1 ;
13462 bool created1 ;
13463 long val2 ;
13464 int ecode2 = 0 ;
13465 int val3 ;
13466 int ecode3 = 0 ;
13467 PyObject * obj0 = 0 ;
13468 PyObject * obj1 = 0 ;
13469 PyObject * obj2 = 0 ;
13470 char * kwnames[] = {
13471 (char *) "stream",(char *) "type",(char *) "index", NULL
13472 };
13473
13474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13475 {
13476 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13477 arg1 = temp1->m_wxis;
13478 created1 = false;
13479 } else {
13480 PyErr_Clear(); // clear the failure of the wxPyConvert above
13481 arg1 = wxPyCBInputStream_create(obj0, false);
13482 if (arg1 == NULL) {
13483 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13484 SWIG_fail;
13485 }
13486 created1 = true;
13487 }
13488 }
13489 if (obj1) {
13490 ecode2 = SWIG_AsVal_long(obj1, &val2);
13491 if (!SWIG_IsOK(ecode2)) {
13492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13493 }
13494 arg2 = static_cast< long >(val2);
13495 }
13496 if (obj2) {
13497 ecode3 = SWIG_AsVal_int(obj2, &val3);
13498 if (!SWIG_IsOK(ecode3)) {
13499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13500 }
13501 arg3 = static_cast< int >(val3);
13502 }
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13506 wxPyEndAllowThreads(__tstate);
13507 if (PyErr_Occurred()) SWIG_fail;
13508 }
13509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13510 {
13511 if (created1) delete arg1;
13512 }
13513 return resultobj;
13514 fail:
13515 {
13516 if (created1) delete arg1;
13517 }
13518 return NULL;
13519 }
13520
13521
13522 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13523 PyObject *resultobj = 0;
13524 wxInputStream *arg1 = 0 ;
13525 wxString *arg2 = 0 ;
13526 int arg3 = (int) -1 ;
13527 wxImage *result = 0 ;
13528 wxPyInputStream *temp1 ;
13529 bool created1 ;
13530 bool temp2 = false ;
13531 int val3 ;
13532 int ecode3 = 0 ;
13533 PyObject * obj0 = 0 ;
13534 PyObject * obj1 = 0 ;
13535 PyObject * obj2 = 0 ;
13536 char * kwnames[] = {
13537 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13538 };
13539
13540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13541 {
13542 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13543 arg1 = temp1->m_wxis;
13544 created1 = false;
13545 } else {
13546 PyErr_Clear(); // clear the failure of the wxPyConvert above
13547 arg1 = wxPyCBInputStream_create(obj0, false);
13548 if (arg1 == NULL) {
13549 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13550 SWIG_fail;
13551 }
13552 created1 = true;
13553 }
13554 }
13555 {
13556 arg2 = wxString_in_helper(obj1);
13557 if (arg2 == NULL) SWIG_fail;
13558 temp2 = true;
13559 }
13560 if (obj2) {
13561 ecode3 = SWIG_AsVal_int(obj2, &val3);
13562 if (!SWIG_IsOK(ecode3)) {
13563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13564 }
13565 arg3 = static_cast< int >(val3);
13566 }
13567 {
13568 PyThreadState* __tstate = wxPyBeginAllowThreads();
13569 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13570 wxPyEndAllowThreads(__tstate);
13571 if (PyErr_Occurred()) SWIG_fail;
13572 }
13573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13574 {
13575 if (created1) delete arg1;
13576 }
13577 {
13578 if (temp2)
13579 delete arg2;
13580 }
13581 return resultobj;
13582 fail:
13583 {
13584 if (created1) delete arg1;
13585 }
13586 {
13587 if (temp2)
13588 delete arg2;
13589 }
13590 return NULL;
13591 }
13592
13593
13594 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13595 PyObject *resultobj = 0;
13596 int arg1 = (int) 0 ;
13597 int arg2 = (int) 0 ;
13598 bool arg3 = (bool) true ;
13599 wxImage *result = 0 ;
13600 int val1 ;
13601 int ecode1 = 0 ;
13602 int val2 ;
13603 int ecode2 = 0 ;
13604 bool val3 ;
13605 int ecode3 = 0 ;
13606 PyObject * obj0 = 0 ;
13607 PyObject * obj1 = 0 ;
13608 PyObject * obj2 = 0 ;
13609 char * kwnames[] = {
13610 (char *) "width",(char *) "height",(char *) "clear", NULL
13611 };
13612
13613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13614 if (obj0) {
13615 ecode1 = SWIG_AsVal_int(obj0, &val1);
13616 if (!SWIG_IsOK(ecode1)) {
13617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13618 }
13619 arg1 = static_cast< int >(val1);
13620 }
13621 if (obj1) {
13622 ecode2 = SWIG_AsVal_int(obj1, &val2);
13623 if (!SWIG_IsOK(ecode2)) {
13624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13625 }
13626 arg2 = static_cast< int >(val2);
13627 }
13628 if (obj2) {
13629 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13630 if (!SWIG_IsOK(ecode3)) {
13631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13632 }
13633 arg3 = static_cast< bool >(val3);
13634 }
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13649 PyObject *resultobj = 0;
13650 wxBitmap *arg1 = 0 ;
13651 wxImage *result = 0 ;
13652 void *argp1 = 0 ;
13653 int res1 = 0 ;
13654 PyObject * obj0 = 0 ;
13655 char * kwnames[] = {
13656 (char *) "bitmap", NULL
13657 };
13658
13659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13660 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13661 if (!SWIG_IsOK(res1)) {
13662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13663 }
13664 if (!argp1) {
13665 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13666 }
13667 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13668 {
13669 if (!wxPyCheckForApp()) SWIG_fail;
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13676 return resultobj;
13677 fail:
13678 return NULL;
13679 }
13680
13681
13682 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13683 PyObject *resultobj = 0;
13684 int arg1 ;
13685 int arg2 ;
13686 buffer arg3 ;
13687 int arg4 ;
13688 wxImage *result = 0 ;
13689 int val1 ;
13690 int ecode1 = 0 ;
13691 int val2 ;
13692 int ecode2 = 0 ;
13693 Py_ssize_t temp3 ;
13694 PyObject * obj0 = 0 ;
13695 PyObject * obj1 = 0 ;
13696 PyObject * obj2 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "width",(char *) "height",(char *) "data", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13702 ecode1 = SWIG_AsVal_int(obj0, &val1);
13703 if (!SWIG_IsOK(ecode1)) {
13704 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13705 }
13706 arg1 = static_cast< int >(val1);
13707 ecode2 = SWIG_AsVal_int(obj1, &val2);
13708 if (!SWIG_IsOK(ecode2)) {
13709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13710 }
13711 arg2 = static_cast< int >(val2);
13712 {
13713 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13714 arg4 = (int)temp3;
13715 }
13716 {
13717 PyThreadState* __tstate = wxPyBeginAllowThreads();
13718 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13719 wxPyEndAllowThreads(__tstate);
13720 if (PyErr_Occurred()) SWIG_fail;
13721 }
13722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13723 return resultobj;
13724 fail:
13725 return NULL;
13726 }
13727
13728
13729 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13730 PyObject *resultobj = 0;
13731 int arg1 ;
13732 int arg2 ;
13733 buffer arg3 ;
13734 int arg4 ;
13735 buffer arg5 ;
13736 int arg6 ;
13737 wxImage *result = 0 ;
13738 int val1 ;
13739 int ecode1 = 0 ;
13740 int val2 ;
13741 int ecode2 = 0 ;
13742 Py_ssize_t temp3 ;
13743 Py_ssize_t temp5 ;
13744 PyObject * obj0 = 0 ;
13745 PyObject * obj1 = 0 ;
13746 PyObject * obj2 = 0 ;
13747 PyObject * obj3 = 0 ;
13748 char * kwnames[] = {
13749 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13750 };
13751
13752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13753 ecode1 = SWIG_AsVal_int(obj0, &val1);
13754 if (!SWIG_IsOK(ecode1)) {
13755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13756 }
13757 arg1 = static_cast< int >(val1);
13758 ecode2 = SWIG_AsVal_int(obj1, &val2);
13759 if (!SWIG_IsOK(ecode2)) {
13760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13761 }
13762 arg2 = static_cast< int >(val2);
13763 {
13764 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13765 arg4 = (int)temp3;
13766 }
13767 {
13768 if (obj3 != Py_None) {
13769 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13770 arg6 = (int)temp5;
13771 }
13772 }
13773 {
13774 PyThreadState* __tstate = wxPyBeginAllowThreads();
13775 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13776 wxPyEndAllowThreads(__tstate);
13777 if (PyErr_Occurred()) SWIG_fail;
13778 }
13779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13780 return resultobj;
13781 fail:
13782 return NULL;
13783 }
13784
13785
13786 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13787 PyObject *resultobj = 0;
13788 wxImage *arg1 = (wxImage *) 0 ;
13789 int arg2 ;
13790 int arg3 ;
13791 bool arg4 = (bool) true ;
13792 void *argp1 = 0 ;
13793 int res1 = 0 ;
13794 int val2 ;
13795 int ecode2 = 0 ;
13796 int val3 ;
13797 int ecode3 = 0 ;
13798 bool val4 ;
13799 int ecode4 = 0 ;
13800 PyObject * obj0 = 0 ;
13801 PyObject * obj1 = 0 ;
13802 PyObject * obj2 = 0 ;
13803 PyObject * obj3 = 0 ;
13804 char * kwnames[] = {
13805 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13806 };
13807
13808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13810 if (!SWIG_IsOK(res1)) {
13811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13812 }
13813 arg1 = reinterpret_cast< wxImage * >(argp1);
13814 ecode2 = SWIG_AsVal_int(obj1, &val2);
13815 if (!SWIG_IsOK(ecode2)) {
13816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13817 }
13818 arg2 = static_cast< int >(val2);
13819 ecode3 = SWIG_AsVal_int(obj2, &val3);
13820 if (!SWIG_IsOK(ecode3)) {
13821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13822 }
13823 arg3 = static_cast< int >(val3);
13824 if (obj3) {
13825 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13826 if (!SWIG_IsOK(ecode4)) {
13827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13828 }
13829 arg4 = static_cast< bool >(val4);
13830 }
13831 {
13832 PyThreadState* __tstate = wxPyBeginAllowThreads();
13833 (arg1)->Create(arg2,arg3,arg4);
13834 wxPyEndAllowThreads(__tstate);
13835 if (PyErr_Occurred()) SWIG_fail;
13836 }
13837 resultobj = SWIG_Py_Void();
13838 return resultobj;
13839 fail:
13840 return NULL;
13841 }
13842
13843
13844 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13845 PyObject *resultobj = 0;
13846 wxImage *arg1 = (wxImage *) 0 ;
13847 void *argp1 = 0 ;
13848 int res1 = 0 ;
13849 PyObject *swig_obj[1] ;
13850
13851 if (!args) SWIG_fail;
13852 swig_obj[0] = args;
13853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13854 if (!SWIG_IsOK(res1)) {
13855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13856 }
13857 arg1 = reinterpret_cast< wxImage * >(argp1);
13858 {
13859 PyThreadState* __tstate = wxPyBeginAllowThreads();
13860 (arg1)->Destroy();
13861 wxPyEndAllowThreads(__tstate);
13862 if (PyErr_Occurred()) SWIG_fail;
13863 }
13864 resultobj = SWIG_Py_Void();
13865 return resultobj;
13866 fail:
13867 return NULL;
13868 }
13869
13870
13871 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13872 PyObject *resultobj = 0;
13873 wxImage *arg1 = (wxImage *) 0 ;
13874 int arg2 ;
13875 int arg3 ;
13876 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13877 SwigValueWrapper<wxImage > result;
13878 void *argp1 = 0 ;
13879 int res1 = 0 ;
13880 int val2 ;
13881 int ecode2 = 0 ;
13882 int val3 ;
13883 int ecode3 = 0 ;
13884 int val4 ;
13885 int ecode4 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 PyObject * obj3 = 0 ;
13890 char * kwnames[] = {
13891 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13892 };
13893
13894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13896 if (!SWIG_IsOK(res1)) {
13897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13898 }
13899 arg1 = reinterpret_cast< wxImage * >(argp1);
13900 ecode2 = SWIG_AsVal_int(obj1, &val2);
13901 if (!SWIG_IsOK(ecode2)) {
13902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13903 }
13904 arg2 = static_cast< int >(val2);
13905 ecode3 = SWIG_AsVal_int(obj2, &val3);
13906 if (!SWIG_IsOK(ecode3)) {
13907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13908 }
13909 arg3 = static_cast< int >(val3);
13910 if (obj3) {
13911 ecode4 = SWIG_AsVal_int(obj3, &val4);
13912 if (!SWIG_IsOK(ecode4)) {
13913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13914 }
13915 arg4 = static_cast< int >(val4);
13916 }
13917 {
13918 PyThreadState* __tstate = wxPyBeginAllowThreads();
13919 result = (arg1)->Scale(arg2,arg3,arg4);
13920 wxPyEndAllowThreads(__tstate);
13921 if (PyErr_Occurred()) SWIG_fail;
13922 }
13923 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13924 return resultobj;
13925 fail:
13926 return NULL;
13927 }
13928
13929
13930 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13931 PyObject *resultobj = 0;
13932 wxImage *arg1 = (wxImage *) 0 ;
13933 int arg2 ;
13934 int arg3 ;
13935 SwigValueWrapper<wxImage > result;
13936 void *argp1 = 0 ;
13937 int res1 = 0 ;
13938 int val2 ;
13939 int ecode2 = 0 ;
13940 int val3 ;
13941 int ecode3 = 0 ;
13942 PyObject * obj0 = 0 ;
13943 PyObject * obj1 = 0 ;
13944 PyObject * obj2 = 0 ;
13945 char * kwnames[] = {
13946 (char *) "self",(char *) "width",(char *) "height", NULL
13947 };
13948
13949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13951 if (!SWIG_IsOK(res1)) {
13952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13953 }
13954 arg1 = reinterpret_cast< wxImage * >(argp1);
13955 ecode2 = SWIG_AsVal_int(obj1, &val2);
13956 if (!SWIG_IsOK(ecode2)) {
13957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13958 }
13959 arg2 = static_cast< int >(val2);
13960 ecode3 = SWIG_AsVal_int(obj2, &val3);
13961 if (!SWIG_IsOK(ecode3)) {
13962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13963 }
13964 arg3 = static_cast< int >(val3);
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13968 wxPyEndAllowThreads(__tstate);
13969 if (PyErr_Occurred()) SWIG_fail;
13970 }
13971 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13972 return resultobj;
13973 fail:
13974 return NULL;
13975 }
13976
13977
13978 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13979 PyObject *resultobj = 0;
13980 wxImage *arg1 = (wxImage *) 0 ;
13981 int arg2 ;
13982 int arg3 ;
13983 SwigValueWrapper<wxImage > result;
13984 void *argp1 = 0 ;
13985 int res1 = 0 ;
13986 int val2 ;
13987 int ecode2 = 0 ;
13988 int val3 ;
13989 int ecode3 = 0 ;
13990 PyObject * obj0 = 0 ;
13991 PyObject * obj1 = 0 ;
13992 PyObject * obj2 = 0 ;
13993 char * kwnames[] = {
13994 (char *) "self",(char *) "width",(char *) "height", NULL
13995 };
13996
13997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13999 if (!SWIG_IsOK(res1)) {
14000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14001 }
14002 arg1 = reinterpret_cast< wxImage * >(argp1);
14003 ecode2 = SWIG_AsVal_int(obj1, &val2);
14004 if (!SWIG_IsOK(ecode2)) {
14005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14006 }
14007 arg2 = static_cast< int >(val2);
14008 ecode3 = SWIG_AsVal_int(obj2, &val3);
14009 if (!SWIG_IsOK(ecode3)) {
14010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14011 }
14012 arg3 = static_cast< int >(val3);
14013 {
14014 PyThreadState* __tstate = wxPyBeginAllowThreads();
14015 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14020 return resultobj;
14021 fail:
14022 return NULL;
14023 }
14024
14025
14026 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14027 PyObject *resultobj = 0;
14028 wxImage *arg1 = (wxImage *) 0 ;
14029 int arg2 ;
14030 SwigValueWrapper<wxImage > result;
14031 void *argp1 = 0 ;
14032 int res1 = 0 ;
14033 int val2 ;
14034 int ecode2 = 0 ;
14035 PyObject * obj0 = 0 ;
14036 PyObject * obj1 = 0 ;
14037 char * kwnames[] = {
14038 (char *) "self",(char *) "radius", NULL
14039 };
14040
14041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14043 if (!SWIG_IsOK(res1)) {
14044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14045 }
14046 arg1 = reinterpret_cast< wxImage * >(argp1);
14047 ecode2 = SWIG_AsVal_int(obj1, &val2);
14048 if (!SWIG_IsOK(ecode2)) {
14049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14050 }
14051 arg2 = static_cast< int >(val2);
14052 {
14053 PyThreadState* __tstate = wxPyBeginAllowThreads();
14054 result = (arg1)->Blur(arg2);
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14059 return resultobj;
14060 fail:
14061 return NULL;
14062 }
14063
14064
14065 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14066 PyObject *resultobj = 0;
14067 wxImage *arg1 = (wxImage *) 0 ;
14068 int arg2 ;
14069 SwigValueWrapper<wxImage > result;
14070 void *argp1 = 0 ;
14071 int res1 = 0 ;
14072 int val2 ;
14073 int ecode2 = 0 ;
14074 PyObject * obj0 = 0 ;
14075 PyObject * obj1 = 0 ;
14076 char * kwnames[] = {
14077 (char *) "self",(char *) "radius", NULL
14078 };
14079
14080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14082 if (!SWIG_IsOK(res1)) {
14083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14084 }
14085 arg1 = reinterpret_cast< wxImage * >(argp1);
14086 ecode2 = SWIG_AsVal_int(obj1, &val2);
14087 if (!SWIG_IsOK(ecode2)) {
14088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14089 }
14090 arg2 = static_cast< int >(val2);
14091 {
14092 PyThreadState* __tstate = wxPyBeginAllowThreads();
14093 result = (arg1)->BlurHorizontal(arg2);
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14105 PyObject *resultobj = 0;
14106 wxImage *arg1 = (wxImage *) 0 ;
14107 int arg2 ;
14108 SwigValueWrapper<wxImage > result;
14109 void *argp1 = 0 ;
14110 int res1 = 0 ;
14111 int val2 ;
14112 int ecode2 = 0 ;
14113 PyObject * obj0 = 0 ;
14114 PyObject * obj1 = 0 ;
14115 char * kwnames[] = {
14116 (char *) "self",(char *) "radius", NULL
14117 };
14118
14119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14121 if (!SWIG_IsOK(res1)) {
14122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14123 }
14124 arg1 = reinterpret_cast< wxImage * >(argp1);
14125 ecode2 = SWIG_AsVal_int(obj1, &val2);
14126 if (!SWIG_IsOK(ecode2)) {
14127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14128 }
14129 arg2 = static_cast< int >(val2);
14130 {
14131 PyThreadState* __tstate = wxPyBeginAllowThreads();
14132 result = (arg1)->BlurVertical(arg2);
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj = 0;
14145 wxImage *arg1 = (wxImage *) 0 ;
14146 int arg2 ;
14147 int arg3 ;
14148 SwigValueWrapper<wxImage > result;
14149 void *argp1 = 0 ;
14150 int res1 = 0 ;
14151 int val2 ;
14152 int ecode2 = 0 ;
14153 int val3 ;
14154 int ecode3 = 0 ;
14155 PyObject * obj0 = 0 ;
14156 PyObject * obj1 = 0 ;
14157 PyObject * obj2 = 0 ;
14158 char * kwnames[] = {
14159 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14160 };
14161
14162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14164 if (!SWIG_IsOK(res1)) {
14165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14166 }
14167 arg1 = reinterpret_cast< wxImage * >(argp1);
14168 ecode2 = SWIG_AsVal_int(obj1, &val2);
14169 if (!SWIG_IsOK(ecode2)) {
14170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14171 }
14172 arg2 = static_cast< int >(val2);
14173 ecode3 = SWIG_AsVal_int(obj2, &val3);
14174 if (!SWIG_IsOK(ecode3)) {
14175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14176 }
14177 arg3 = static_cast< int >(val3);
14178 {
14179 PyThreadState* __tstate = wxPyBeginAllowThreads();
14180 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14181 wxPyEndAllowThreads(__tstate);
14182 if (PyErr_Occurred()) SWIG_fail;
14183 }
14184 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14185 return resultobj;
14186 fail:
14187 return NULL;
14188 }
14189
14190
14191 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14192 PyObject *resultobj = 0;
14193 wxImage *arg1 = (wxImage *) 0 ;
14194 int arg2 ;
14195 int arg3 ;
14196 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14197 wxImage *result = 0 ;
14198 void *argp1 = 0 ;
14199 int res1 = 0 ;
14200 int val2 ;
14201 int ecode2 = 0 ;
14202 int val3 ;
14203 int ecode3 = 0 ;
14204 int val4 ;
14205 int ecode4 = 0 ;
14206 PyObject * obj0 = 0 ;
14207 PyObject * obj1 = 0 ;
14208 PyObject * obj2 = 0 ;
14209 PyObject * obj3 = 0 ;
14210 char * kwnames[] = {
14211 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14212 };
14213
14214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14216 if (!SWIG_IsOK(res1)) {
14217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14218 }
14219 arg1 = reinterpret_cast< wxImage * >(argp1);
14220 ecode2 = SWIG_AsVal_int(obj1, &val2);
14221 if (!SWIG_IsOK(ecode2)) {
14222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14223 }
14224 arg2 = static_cast< int >(val2);
14225 ecode3 = SWIG_AsVal_int(obj2, &val3);
14226 if (!SWIG_IsOK(ecode3)) {
14227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14228 }
14229 arg3 = static_cast< int >(val3);
14230 if (obj3) {
14231 ecode4 = SWIG_AsVal_int(obj3, &val4);
14232 if (!SWIG_IsOK(ecode4)) {
14233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14234 }
14235 arg4 = static_cast< int >(val4);
14236 }
14237 {
14238 PyThreadState* __tstate = wxPyBeginAllowThreads();
14239 {
14240 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14241 result = (wxImage *) &_result_ref;
14242 }
14243 wxPyEndAllowThreads(__tstate);
14244 if (PyErr_Occurred()) SWIG_fail;
14245 }
14246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14247 return resultobj;
14248 fail:
14249 return NULL;
14250 }
14251
14252
14253 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14254 PyObject *resultobj = 0;
14255 wxImage *arg1 = (wxImage *) 0 ;
14256 wxSize *arg2 = 0 ;
14257 wxPoint *arg3 = 0 ;
14258 int arg4 = (int) -1 ;
14259 int arg5 = (int) -1 ;
14260 int arg6 = (int) -1 ;
14261 wxImage *result = 0 ;
14262 void *argp1 = 0 ;
14263 int res1 = 0 ;
14264 wxSize temp2 ;
14265 wxPoint temp3 ;
14266 int val4 ;
14267 int ecode4 = 0 ;
14268 int val5 ;
14269 int ecode5 = 0 ;
14270 int val6 ;
14271 int ecode6 = 0 ;
14272 PyObject * obj0 = 0 ;
14273 PyObject * obj1 = 0 ;
14274 PyObject * obj2 = 0 ;
14275 PyObject * obj3 = 0 ;
14276 PyObject * obj4 = 0 ;
14277 PyObject * obj5 = 0 ;
14278 char * kwnames[] = {
14279 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14280 };
14281
14282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14284 if (!SWIG_IsOK(res1)) {
14285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14286 }
14287 arg1 = reinterpret_cast< wxImage * >(argp1);
14288 {
14289 arg2 = &temp2;
14290 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14291 }
14292 {
14293 arg3 = &temp3;
14294 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14295 }
14296 if (obj3) {
14297 ecode4 = SWIG_AsVal_int(obj3, &val4);
14298 if (!SWIG_IsOK(ecode4)) {
14299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14300 }
14301 arg4 = static_cast< int >(val4);
14302 }
14303 if (obj4) {
14304 ecode5 = SWIG_AsVal_int(obj4, &val5);
14305 if (!SWIG_IsOK(ecode5)) {
14306 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14307 }
14308 arg5 = static_cast< int >(val5);
14309 }
14310 if (obj5) {
14311 ecode6 = SWIG_AsVal_int(obj5, &val6);
14312 if (!SWIG_IsOK(ecode6)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14314 }
14315 arg6 = static_cast< int >(val6);
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 {
14320 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14321 result = (wxImage *) &_result_ref;
14322 }
14323 wxPyEndAllowThreads(__tstate);
14324 if (PyErr_Occurred()) SWIG_fail;
14325 }
14326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14327 return resultobj;
14328 fail:
14329 return NULL;
14330 }
14331
14332
14333 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14334 PyObject *resultobj = 0;
14335 wxImage *arg1 = (wxImage *) 0 ;
14336 int arg2 ;
14337 int arg3 ;
14338 byte arg4 ;
14339 byte arg5 ;
14340 byte arg6 ;
14341 void *argp1 = 0 ;
14342 int res1 = 0 ;
14343 int val2 ;
14344 int ecode2 = 0 ;
14345 int val3 ;
14346 int ecode3 = 0 ;
14347 unsigned char val4 ;
14348 int ecode4 = 0 ;
14349 unsigned char val5 ;
14350 int ecode5 = 0 ;
14351 unsigned char val6 ;
14352 int ecode6 = 0 ;
14353 PyObject * obj0 = 0 ;
14354 PyObject * obj1 = 0 ;
14355 PyObject * obj2 = 0 ;
14356 PyObject * obj3 = 0 ;
14357 PyObject * obj4 = 0 ;
14358 PyObject * obj5 = 0 ;
14359 char * kwnames[] = {
14360 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14361 };
14362
14363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14365 if (!SWIG_IsOK(res1)) {
14366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14367 }
14368 arg1 = reinterpret_cast< wxImage * >(argp1);
14369 ecode2 = SWIG_AsVal_int(obj1, &val2);
14370 if (!SWIG_IsOK(ecode2)) {
14371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14372 }
14373 arg2 = static_cast< int >(val2);
14374 ecode3 = SWIG_AsVal_int(obj2, &val3);
14375 if (!SWIG_IsOK(ecode3)) {
14376 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14377 }
14378 arg3 = static_cast< int >(val3);
14379 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14380 if (!SWIG_IsOK(ecode4)) {
14381 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14382 }
14383 arg4 = static_cast< byte >(val4);
14384 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14385 if (!SWIG_IsOK(ecode5)) {
14386 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14387 }
14388 arg5 = static_cast< byte >(val5);
14389 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14390 if (!SWIG_IsOK(ecode6)) {
14391 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14392 }
14393 arg6 = static_cast< byte >(val6);
14394 {
14395 PyThreadState* __tstate = wxPyBeginAllowThreads();
14396 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14397 wxPyEndAllowThreads(__tstate);
14398 if (PyErr_Occurred()) SWIG_fail;
14399 }
14400 resultobj = SWIG_Py_Void();
14401 return resultobj;
14402 fail:
14403 return NULL;
14404 }
14405
14406
14407 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14408 PyObject *resultobj = 0;
14409 wxImage *arg1 = (wxImage *) 0 ;
14410 wxRect *arg2 = 0 ;
14411 byte arg3 ;
14412 byte arg4 ;
14413 byte arg5 ;
14414 void *argp1 = 0 ;
14415 int res1 = 0 ;
14416 wxRect temp2 ;
14417 unsigned char val3 ;
14418 int ecode3 = 0 ;
14419 unsigned char val4 ;
14420 int ecode4 = 0 ;
14421 unsigned char val5 ;
14422 int ecode5 = 0 ;
14423 PyObject * obj0 = 0 ;
14424 PyObject * obj1 = 0 ;
14425 PyObject * obj2 = 0 ;
14426 PyObject * obj3 = 0 ;
14427 PyObject * obj4 = 0 ;
14428 char * kwnames[] = {
14429 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14430 };
14431
14432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14434 if (!SWIG_IsOK(res1)) {
14435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14436 }
14437 arg1 = reinterpret_cast< wxImage * >(argp1);
14438 {
14439 arg2 = &temp2;
14440 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14441 }
14442 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14443 if (!SWIG_IsOK(ecode3)) {
14444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14445 }
14446 arg3 = static_cast< byte >(val3);
14447 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14448 if (!SWIG_IsOK(ecode4)) {
14449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14450 }
14451 arg4 = static_cast< byte >(val4);
14452 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14453 if (!SWIG_IsOK(ecode5)) {
14454 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14455 }
14456 arg5 = static_cast< byte >(val5);
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14460 wxPyEndAllowThreads(__tstate);
14461 if (PyErr_Occurred()) SWIG_fail;
14462 }
14463 resultobj = SWIG_Py_Void();
14464 return resultobj;
14465 fail:
14466 return NULL;
14467 }
14468
14469
14470 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14471 PyObject *resultobj = 0;
14472 wxImage *arg1 = (wxImage *) 0 ;
14473 int arg2 ;
14474 int arg3 ;
14475 byte result;
14476 void *argp1 = 0 ;
14477 int res1 = 0 ;
14478 int val2 ;
14479 int ecode2 = 0 ;
14480 int val3 ;
14481 int ecode3 = 0 ;
14482 PyObject * obj0 = 0 ;
14483 PyObject * obj1 = 0 ;
14484 PyObject * obj2 = 0 ;
14485 char * kwnames[] = {
14486 (char *) "self",(char *) "x",(char *) "y", NULL
14487 };
14488
14489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14493 }
14494 arg1 = reinterpret_cast< wxImage * >(argp1);
14495 ecode2 = SWIG_AsVal_int(obj1, &val2);
14496 if (!SWIG_IsOK(ecode2)) {
14497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14498 }
14499 arg2 = static_cast< int >(val2);
14500 ecode3 = SWIG_AsVal_int(obj2, &val3);
14501 if (!SWIG_IsOK(ecode3)) {
14502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14503 }
14504 arg3 = static_cast< int >(val3);
14505 {
14506 PyThreadState* __tstate = wxPyBeginAllowThreads();
14507 result = (byte)(arg1)->GetRed(arg2,arg3);
14508 wxPyEndAllowThreads(__tstate);
14509 if (PyErr_Occurred()) SWIG_fail;
14510 }
14511 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14512 return resultobj;
14513 fail:
14514 return NULL;
14515 }
14516
14517
14518 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14519 PyObject *resultobj = 0;
14520 wxImage *arg1 = (wxImage *) 0 ;
14521 int arg2 ;
14522 int arg3 ;
14523 byte result;
14524 void *argp1 = 0 ;
14525 int res1 = 0 ;
14526 int val2 ;
14527 int ecode2 = 0 ;
14528 int val3 ;
14529 int ecode3 = 0 ;
14530 PyObject * obj0 = 0 ;
14531 PyObject * obj1 = 0 ;
14532 PyObject * obj2 = 0 ;
14533 char * kwnames[] = {
14534 (char *) "self",(char *) "x",(char *) "y", NULL
14535 };
14536
14537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14539 if (!SWIG_IsOK(res1)) {
14540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14541 }
14542 arg1 = reinterpret_cast< wxImage * >(argp1);
14543 ecode2 = SWIG_AsVal_int(obj1, &val2);
14544 if (!SWIG_IsOK(ecode2)) {
14545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14546 }
14547 arg2 = static_cast< int >(val2);
14548 ecode3 = SWIG_AsVal_int(obj2, &val3);
14549 if (!SWIG_IsOK(ecode3)) {
14550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14551 }
14552 arg3 = static_cast< int >(val3);
14553 {
14554 PyThreadState* __tstate = wxPyBeginAllowThreads();
14555 result = (byte)(arg1)->GetGreen(arg2,arg3);
14556 wxPyEndAllowThreads(__tstate);
14557 if (PyErr_Occurred()) SWIG_fail;
14558 }
14559 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14560 return resultobj;
14561 fail:
14562 return NULL;
14563 }
14564
14565
14566 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14567 PyObject *resultobj = 0;
14568 wxImage *arg1 = (wxImage *) 0 ;
14569 int arg2 ;
14570 int arg3 ;
14571 byte result;
14572 void *argp1 = 0 ;
14573 int res1 = 0 ;
14574 int val2 ;
14575 int ecode2 = 0 ;
14576 int val3 ;
14577 int ecode3 = 0 ;
14578 PyObject * obj0 = 0 ;
14579 PyObject * obj1 = 0 ;
14580 PyObject * obj2 = 0 ;
14581 char * kwnames[] = {
14582 (char *) "self",(char *) "x",(char *) "y", NULL
14583 };
14584
14585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14587 if (!SWIG_IsOK(res1)) {
14588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14589 }
14590 arg1 = reinterpret_cast< wxImage * >(argp1);
14591 ecode2 = SWIG_AsVal_int(obj1, &val2);
14592 if (!SWIG_IsOK(ecode2)) {
14593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14594 }
14595 arg2 = static_cast< int >(val2);
14596 ecode3 = SWIG_AsVal_int(obj2, &val3);
14597 if (!SWIG_IsOK(ecode3)) {
14598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14599 }
14600 arg3 = static_cast< int >(val3);
14601 {
14602 PyThreadState* __tstate = wxPyBeginAllowThreads();
14603 result = (byte)(arg1)->GetBlue(arg2,arg3);
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj = 0;
14616 wxImage *arg1 = (wxImage *) 0 ;
14617 int arg2 ;
14618 int arg3 ;
14619 byte arg4 ;
14620 void *argp1 = 0 ;
14621 int res1 = 0 ;
14622 int val2 ;
14623 int ecode2 = 0 ;
14624 int val3 ;
14625 int ecode3 = 0 ;
14626 unsigned char val4 ;
14627 int ecode4 = 0 ;
14628 PyObject * obj0 = 0 ;
14629 PyObject * obj1 = 0 ;
14630 PyObject * obj2 = 0 ;
14631 PyObject * obj3 = 0 ;
14632 char * kwnames[] = {
14633 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14634 };
14635
14636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14638 if (!SWIG_IsOK(res1)) {
14639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14640 }
14641 arg1 = reinterpret_cast< wxImage * >(argp1);
14642 ecode2 = SWIG_AsVal_int(obj1, &val2);
14643 if (!SWIG_IsOK(ecode2)) {
14644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14645 }
14646 arg2 = static_cast< int >(val2);
14647 ecode3 = SWIG_AsVal_int(obj2, &val3);
14648 if (!SWIG_IsOK(ecode3)) {
14649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14650 }
14651 arg3 = static_cast< int >(val3);
14652 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14653 if (!SWIG_IsOK(ecode4)) {
14654 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14655 }
14656 arg4 = static_cast< byte >(val4);
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 (arg1)->SetAlpha(arg2,arg3,arg4);
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 resultobj = SWIG_Py_Void();
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj = 0;
14672 wxImage *arg1 = (wxImage *) 0 ;
14673 int arg2 ;
14674 int arg3 ;
14675 byte result;
14676 void *argp1 = 0 ;
14677 int res1 = 0 ;
14678 int val2 ;
14679 int ecode2 = 0 ;
14680 int val3 ;
14681 int ecode3 = 0 ;
14682 PyObject * obj0 = 0 ;
14683 PyObject * obj1 = 0 ;
14684 PyObject * obj2 = 0 ;
14685 char * kwnames[] = {
14686 (char *) "self",(char *) "x",(char *) "y", NULL
14687 };
14688
14689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14691 if (!SWIG_IsOK(res1)) {
14692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14693 }
14694 arg1 = reinterpret_cast< wxImage * >(argp1);
14695 ecode2 = SWIG_AsVal_int(obj1, &val2);
14696 if (!SWIG_IsOK(ecode2)) {
14697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14698 }
14699 arg2 = static_cast< int >(val2);
14700 ecode3 = SWIG_AsVal_int(obj2, &val3);
14701 if (!SWIG_IsOK(ecode3)) {
14702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14703 }
14704 arg3 = static_cast< int >(val3);
14705 {
14706 PyThreadState* __tstate = wxPyBeginAllowThreads();
14707 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14708 wxPyEndAllowThreads(__tstate);
14709 if (PyErr_Occurred()) SWIG_fail;
14710 }
14711 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14712 return resultobj;
14713 fail:
14714 return NULL;
14715 }
14716
14717
14718 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14719 PyObject *resultobj = 0;
14720 wxImage *arg1 = (wxImage *) 0 ;
14721 bool result;
14722 void *argp1 = 0 ;
14723 int res1 = 0 ;
14724 PyObject *swig_obj[1] ;
14725
14726 if (!args) SWIG_fail;
14727 swig_obj[0] = args;
14728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14729 if (!SWIG_IsOK(res1)) {
14730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14731 }
14732 arg1 = reinterpret_cast< wxImage * >(argp1);
14733 {
14734 PyThreadState* __tstate = wxPyBeginAllowThreads();
14735 result = (bool)(arg1)->HasAlpha();
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 {
14740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14741 }
14742 return resultobj;
14743 fail:
14744 return NULL;
14745 }
14746
14747
14748 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14749 PyObject *resultobj = 0;
14750 wxImage *arg1 = (wxImage *) 0 ;
14751 void *argp1 = 0 ;
14752 int res1 = 0 ;
14753 PyObject *swig_obj[1] ;
14754
14755 if (!args) SWIG_fail;
14756 swig_obj[0] = args;
14757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14758 if (!SWIG_IsOK(res1)) {
14759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14760 }
14761 arg1 = reinterpret_cast< wxImage * >(argp1);
14762 {
14763 PyThreadState* __tstate = wxPyBeginAllowThreads();
14764 (arg1)->InitAlpha();
14765 wxPyEndAllowThreads(__tstate);
14766 if (PyErr_Occurred()) SWIG_fail;
14767 }
14768 resultobj = SWIG_Py_Void();
14769 return resultobj;
14770 fail:
14771 return NULL;
14772 }
14773
14774
14775 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14776 PyObject *resultobj = 0;
14777 wxImage *arg1 = (wxImage *) 0 ;
14778 int arg2 ;
14779 int arg3 ;
14780 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14781 bool result;
14782 void *argp1 = 0 ;
14783 int res1 = 0 ;
14784 int val2 ;
14785 int ecode2 = 0 ;
14786 int val3 ;
14787 int ecode3 = 0 ;
14788 unsigned char val4 ;
14789 int ecode4 = 0 ;
14790 PyObject * obj0 = 0 ;
14791 PyObject * obj1 = 0 ;
14792 PyObject * obj2 = 0 ;
14793 PyObject * obj3 = 0 ;
14794 char * kwnames[] = {
14795 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14796 };
14797
14798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14800 if (!SWIG_IsOK(res1)) {
14801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14802 }
14803 arg1 = reinterpret_cast< wxImage * >(argp1);
14804 ecode2 = SWIG_AsVal_int(obj1, &val2);
14805 if (!SWIG_IsOK(ecode2)) {
14806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14807 }
14808 arg2 = static_cast< int >(val2);
14809 ecode3 = SWIG_AsVal_int(obj2, &val3);
14810 if (!SWIG_IsOK(ecode3)) {
14811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14812 }
14813 arg3 = static_cast< int >(val3);
14814 if (obj3) {
14815 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14816 if (!SWIG_IsOK(ecode4)) {
14817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14818 }
14819 arg4 = static_cast< byte >(val4);
14820 }
14821 {
14822 PyThreadState* __tstate = wxPyBeginAllowThreads();
14823 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 {
14828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14829 }
14830 return resultobj;
14831 fail:
14832 return NULL;
14833 }
14834
14835
14836 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14837 PyObject *resultobj = 0;
14838 wxImage *arg1 = (wxImage *) 0 ;
14839 byte *arg2 = (byte *) 0 ;
14840 byte *arg3 = (byte *) 0 ;
14841 byte *arg4 = (byte *) 0 ;
14842 byte arg5 = (byte) 0 ;
14843 byte arg6 = (byte) 0 ;
14844 byte arg7 = (byte) 0 ;
14845 bool result;
14846 void *argp1 = 0 ;
14847 int res1 = 0 ;
14848 byte temp2 ;
14849 int res2 = SWIG_TMPOBJ ;
14850 byte temp3 ;
14851 int res3 = SWIG_TMPOBJ ;
14852 byte temp4 ;
14853 int res4 = SWIG_TMPOBJ ;
14854 unsigned char val5 ;
14855 int ecode5 = 0 ;
14856 unsigned char val6 ;
14857 int ecode6 = 0 ;
14858 unsigned char val7 ;
14859 int ecode7 = 0 ;
14860 PyObject * obj0 = 0 ;
14861 PyObject * obj1 = 0 ;
14862 PyObject * obj2 = 0 ;
14863 PyObject * obj3 = 0 ;
14864 char * kwnames[] = {
14865 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14866 };
14867
14868 arg2 = &temp2;
14869 arg3 = &temp3;
14870 arg4 = &temp4;
14871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14873 if (!SWIG_IsOK(res1)) {
14874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14875 }
14876 arg1 = reinterpret_cast< wxImage * >(argp1);
14877 if (obj1) {
14878 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14879 if (!SWIG_IsOK(ecode5)) {
14880 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14881 }
14882 arg5 = static_cast< byte >(val5);
14883 }
14884 if (obj2) {
14885 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14886 if (!SWIG_IsOK(ecode6)) {
14887 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14888 }
14889 arg6 = static_cast< byte >(val6);
14890 }
14891 if (obj3) {
14892 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14893 if (!SWIG_IsOK(ecode7)) {
14894 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14895 }
14896 arg7 = static_cast< byte >(val7);
14897 }
14898 {
14899 PyThreadState* __tstate = wxPyBeginAllowThreads();
14900 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 {
14905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14906 }
14907 if (SWIG_IsTmpObj(res2)) {
14908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14909 } else {
14910 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14912 }
14913 if (SWIG_IsTmpObj(res3)) {
14914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14915 } else {
14916 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14918 }
14919 if (SWIG_IsTmpObj(res4)) {
14920 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14921 } else {
14922 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14924 }
14925 return resultobj;
14926 fail:
14927 return NULL;
14928 }
14929
14930
14931 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14932 PyObject *resultobj = 0;
14933 wxImage *arg1 = (wxImage *) 0 ;
14934 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14935 bool result;
14936 void *argp1 = 0 ;
14937 int res1 = 0 ;
14938 unsigned char val2 ;
14939 int ecode2 = 0 ;
14940 PyObject * obj0 = 0 ;
14941 PyObject * obj1 = 0 ;
14942 char * kwnames[] = {
14943 (char *) "self",(char *) "threshold", NULL
14944 };
14945
14946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14948 if (!SWIG_IsOK(res1)) {
14949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14950 }
14951 arg1 = reinterpret_cast< wxImage * >(argp1);
14952 if (obj1) {
14953 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14954 if (!SWIG_IsOK(ecode2)) {
14955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14956 }
14957 arg2 = static_cast< byte >(val2);
14958 }
14959 {
14960 PyThreadState* __tstate = wxPyBeginAllowThreads();
14961 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14962 wxPyEndAllowThreads(__tstate);
14963 if (PyErr_Occurred()) SWIG_fail;
14964 }
14965 {
14966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14967 }
14968 return resultobj;
14969 fail:
14970 return NULL;
14971 }
14972
14973
14974 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14975 PyObject *resultobj = 0;
14976 wxImage *arg1 = (wxImage *) 0 ;
14977 byte arg2 ;
14978 byte arg3 ;
14979 byte arg4 ;
14980 bool result;
14981 void *argp1 = 0 ;
14982 int res1 = 0 ;
14983 unsigned char val2 ;
14984 int ecode2 = 0 ;
14985 unsigned char val3 ;
14986 int ecode3 = 0 ;
14987 unsigned char val4 ;
14988 int ecode4 = 0 ;
14989 PyObject * obj0 = 0 ;
14990 PyObject * obj1 = 0 ;
14991 PyObject * obj2 = 0 ;
14992 PyObject * obj3 = 0 ;
14993 char * kwnames[] = {
14994 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14995 };
14996
14997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14999 if (!SWIG_IsOK(res1)) {
15000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15001 }
15002 arg1 = reinterpret_cast< wxImage * >(argp1);
15003 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15004 if (!SWIG_IsOK(ecode2)) {
15005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15006 }
15007 arg2 = static_cast< byte >(val2);
15008 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15009 if (!SWIG_IsOK(ecode3)) {
15010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15011 }
15012 arg3 = static_cast< byte >(val3);
15013 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15014 if (!SWIG_IsOK(ecode4)) {
15015 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15016 }
15017 arg4 = static_cast< byte >(val4);
15018 {
15019 PyThreadState* __tstate = wxPyBeginAllowThreads();
15020 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 {
15025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15026 }
15027 return resultobj;
15028 fail:
15029 return NULL;
15030 }
15031
15032
15033 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj = 0;
15035 wxImage *arg1 = (wxImage *) 0 ;
15036 wxImage *arg2 = 0 ;
15037 byte arg3 ;
15038 byte arg4 ;
15039 byte arg5 ;
15040 bool result;
15041 void *argp1 = 0 ;
15042 int res1 = 0 ;
15043 void *argp2 = 0 ;
15044 int res2 = 0 ;
15045 unsigned char val3 ;
15046 int ecode3 = 0 ;
15047 unsigned char val4 ;
15048 int ecode4 = 0 ;
15049 unsigned char val5 ;
15050 int ecode5 = 0 ;
15051 PyObject * obj0 = 0 ;
15052 PyObject * obj1 = 0 ;
15053 PyObject * obj2 = 0 ;
15054 PyObject * obj3 = 0 ;
15055 PyObject * obj4 = 0 ;
15056 char * kwnames[] = {
15057 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15058 };
15059
15060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15062 if (!SWIG_IsOK(res1)) {
15063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15064 }
15065 arg1 = reinterpret_cast< wxImage * >(argp1);
15066 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15067 if (!SWIG_IsOK(res2)) {
15068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15069 }
15070 if (!argp2) {
15071 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15072 }
15073 arg2 = reinterpret_cast< wxImage * >(argp2);
15074 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15075 if (!SWIG_IsOK(ecode3)) {
15076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15077 }
15078 arg3 = static_cast< byte >(val3);
15079 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15080 if (!SWIG_IsOK(ecode4)) {
15081 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15082 }
15083 arg4 = static_cast< byte >(val4);
15084 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15085 if (!SWIG_IsOK(ecode5)) {
15086 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15087 }
15088 arg5 = static_cast< byte >(val5);
15089 {
15090 PyThreadState* __tstate = wxPyBeginAllowThreads();
15091 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15092 wxPyEndAllowThreads(__tstate);
15093 if (PyErr_Occurred()) SWIG_fail;
15094 }
15095 {
15096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15097 }
15098 return resultobj;
15099 fail:
15100 return NULL;
15101 }
15102
15103
15104 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15105 PyObject *resultobj = 0;
15106 wxString *arg1 = 0 ;
15107 bool result;
15108 bool temp1 = false ;
15109 PyObject * obj0 = 0 ;
15110 char * kwnames[] = {
15111 (char *) "filename", NULL
15112 };
15113
15114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15115 {
15116 arg1 = wxString_in_helper(obj0);
15117 if (arg1 == NULL) SWIG_fail;
15118 temp1 = true;
15119 }
15120 {
15121 PyThreadState* __tstate = wxPyBeginAllowThreads();
15122 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 {
15127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15128 }
15129 {
15130 if (temp1)
15131 delete arg1;
15132 }
15133 return resultobj;
15134 fail:
15135 {
15136 if (temp1)
15137 delete arg1;
15138 }
15139 return NULL;
15140 }
15141
15142
15143 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15144 PyObject *resultobj = 0;
15145 wxString *arg1 = 0 ;
15146 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15147 int result;
15148 bool temp1 = false ;
15149 long val2 ;
15150 int ecode2 = 0 ;
15151 PyObject * obj0 = 0 ;
15152 PyObject * obj1 = 0 ;
15153 char * kwnames[] = {
15154 (char *) "filename",(char *) "type", NULL
15155 };
15156
15157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15158 {
15159 arg1 = wxString_in_helper(obj0);
15160 if (arg1 == NULL) SWIG_fail;
15161 temp1 = true;
15162 }
15163 if (obj1) {
15164 ecode2 = SWIG_AsVal_long(obj1, &val2);
15165 if (!SWIG_IsOK(ecode2)) {
15166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15167 }
15168 arg2 = static_cast< long >(val2);
15169 }
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 resultobj = SWIG_From_int(static_cast< int >(result));
15177 {
15178 if (temp1)
15179 delete arg1;
15180 }
15181 return resultobj;
15182 fail:
15183 {
15184 if (temp1)
15185 delete arg1;
15186 }
15187 return NULL;
15188 }
15189
15190
15191 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15192 PyObject *resultobj = 0;
15193 wxImage *arg1 = (wxImage *) 0 ;
15194 wxString *arg2 = 0 ;
15195 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15196 int arg4 = (int) -1 ;
15197 bool result;
15198 void *argp1 = 0 ;
15199 int res1 = 0 ;
15200 bool temp2 = false ;
15201 long val3 ;
15202 int ecode3 = 0 ;
15203 int val4 ;
15204 int ecode4 = 0 ;
15205 PyObject * obj0 = 0 ;
15206 PyObject * obj1 = 0 ;
15207 PyObject * obj2 = 0 ;
15208 PyObject * obj3 = 0 ;
15209 char * kwnames[] = {
15210 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15211 };
15212
15213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15217 }
15218 arg1 = reinterpret_cast< wxImage * >(argp1);
15219 {
15220 arg2 = wxString_in_helper(obj1);
15221 if (arg2 == NULL) SWIG_fail;
15222 temp2 = true;
15223 }
15224 if (obj2) {
15225 ecode3 = SWIG_AsVal_long(obj2, &val3);
15226 if (!SWIG_IsOK(ecode3)) {
15227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15228 }
15229 arg3 = static_cast< long >(val3);
15230 }
15231 if (obj3) {
15232 ecode4 = SWIG_AsVal_int(obj3, &val4);
15233 if (!SWIG_IsOK(ecode4)) {
15234 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15235 }
15236 arg4 = static_cast< int >(val4);
15237 }
15238 {
15239 PyThreadState* __tstate = wxPyBeginAllowThreads();
15240 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15241 wxPyEndAllowThreads(__tstate);
15242 if (PyErr_Occurred()) SWIG_fail;
15243 }
15244 {
15245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15246 }
15247 {
15248 if (temp2)
15249 delete arg2;
15250 }
15251 return resultobj;
15252 fail:
15253 {
15254 if (temp2)
15255 delete arg2;
15256 }
15257 return NULL;
15258 }
15259
15260
15261 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15262 PyObject *resultobj = 0;
15263 wxImage *arg1 = (wxImage *) 0 ;
15264 wxString *arg2 = 0 ;
15265 wxString *arg3 = 0 ;
15266 int arg4 = (int) -1 ;
15267 bool result;
15268 void *argp1 = 0 ;
15269 int res1 = 0 ;
15270 bool temp2 = false ;
15271 bool temp3 = false ;
15272 int val4 ;
15273 int ecode4 = 0 ;
15274 PyObject * obj0 = 0 ;
15275 PyObject * obj1 = 0 ;
15276 PyObject * obj2 = 0 ;
15277 PyObject * obj3 = 0 ;
15278 char * kwnames[] = {
15279 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15280 };
15281
15282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15284 if (!SWIG_IsOK(res1)) {
15285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15286 }
15287 arg1 = reinterpret_cast< wxImage * >(argp1);
15288 {
15289 arg2 = wxString_in_helper(obj1);
15290 if (arg2 == NULL) SWIG_fail;
15291 temp2 = true;
15292 }
15293 {
15294 arg3 = wxString_in_helper(obj2);
15295 if (arg3 == NULL) SWIG_fail;
15296 temp3 = true;
15297 }
15298 if (obj3) {
15299 ecode4 = SWIG_AsVal_int(obj3, &val4);
15300 if (!SWIG_IsOK(ecode4)) {
15301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15302 }
15303 arg4 = static_cast< int >(val4);
15304 }
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15308 wxPyEndAllowThreads(__tstate);
15309 if (PyErr_Occurred()) SWIG_fail;
15310 }
15311 {
15312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15313 }
15314 {
15315 if (temp2)
15316 delete arg2;
15317 }
15318 {
15319 if (temp3)
15320 delete arg3;
15321 }
15322 return resultobj;
15323 fail:
15324 {
15325 if (temp2)
15326 delete arg2;
15327 }
15328 {
15329 if (temp3)
15330 delete arg3;
15331 }
15332 return NULL;
15333 }
15334
15335
15336 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15337 PyObject *resultobj = 0;
15338 wxImage *arg1 = (wxImage *) 0 ;
15339 wxString *arg2 = 0 ;
15340 int arg3 ;
15341 bool result;
15342 void *argp1 = 0 ;
15343 int res1 = 0 ;
15344 bool temp2 = false ;
15345 int val3 ;
15346 int ecode3 = 0 ;
15347 PyObject * obj0 = 0 ;
15348 PyObject * obj1 = 0 ;
15349 PyObject * obj2 = 0 ;
15350 char * kwnames[] = {
15351 (char *) "self",(char *) "name",(char *) "type", NULL
15352 };
15353
15354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15356 if (!SWIG_IsOK(res1)) {
15357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15358 }
15359 arg1 = reinterpret_cast< wxImage * >(argp1);
15360 {
15361 arg2 = wxString_in_helper(obj1);
15362 if (arg2 == NULL) SWIG_fail;
15363 temp2 = true;
15364 }
15365 ecode3 = SWIG_AsVal_int(obj2, &val3);
15366 if (!SWIG_IsOK(ecode3)) {
15367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15368 }
15369 arg3 = static_cast< int >(val3);
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 {
15377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15378 }
15379 {
15380 if (temp2)
15381 delete arg2;
15382 }
15383 return resultobj;
15384 fail:
15385 {
15386 if (temp2)
15387 delete arg2;
15388 }
15389 return NULL;
15390 }
15391
15392
15393 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15394 PyObject *resultobj = 0;
15395 wxImage *arg1 = (wxImage *) 0 ;
15396 wxString *arg2 = 0 ;
15397 wxString *arg3 = 0 ;
15398 bool result;
15399 void *argp1 = 0 ;
15400 int res1 = 0 ;
15401 bool temp2 = false ;
15402 bool temp3 = false ;
15403 PyObject * obj0 = 0 ;
15404 PyObject * obj1 = 0 ;
15405 PyObject * obj2 = 0 ;
15406 char * kwnames[] = {
15407 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15408 };
15409
15410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15412 if (!SWIG_IsOK(res1)) {
15413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15414 }
15415 arg1 = reinterpret_cast< wxImage * >(argp1);
15416 {
15417 arg2 = wxString_in_helper(obj1);
15418 if (arg2 == NULL) SWIG_fail;
15419 temp2 = true;
15420 }
15421 {
15422 arg3 = wxString_in_helper(obj2);
15423 if (arg3 == NULL) SWIG_fail;
15424 temp3 = true;
15425 }
15426 {
15427 PyThreadState* __tstate = wxPyBeginAllowThreads();
15428 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 {
15433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15434 }
15435 {
15436 if (temp2)
15437 delete arg2;
15438 }
15439 {
15440 if (temp3)
15441 delete arg3;
15442 }
15443 return resultobj;
15444 fail:
15445 {
15446 if (temp2)
15447 delete arg2;
15448 }
15449 {
15450 if (temp3)
15451 delete arg3;
15452 }
15453 return NULL;
15454 }
15455
15456
15457 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15458 PyObject *resultobj = 0;
15459 wxInputStream *arg1 = 0 ;
15460 bool result;
15461 wxPyInputStream *temp1 ;
15462 bool created1 ;
15463 PyObject * obj0 = 0 ;
15464 char * kwnames[] = {
15465 (char *) "stream", NULL
15466 };
15467
15468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15469 {
15470 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15471 arg1 = temp1->m_wxis;
15472 created1 = false;
15473 } else {
15474 PyErr_Clear(); // clear the failure of the wxPyConvert above
15475 arg1 = wxPyCBInputStream_create(obj0, false);
15476 if (arg1 == NULL) {
15477 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15478 SWIG_fail;
15479 }
15480 created1 = true;
15481 }
15482 }
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = (bool)wxImage::CanRead(*arg1);
15486 wxPyEndAllowThreads(__tstate);
15487 if (PyErr_Occurred()) SWIG_fail;
15488 }
15489 {
15490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15491 }
15492 {
15493 if (created1) delete arg1;
15494 }
15495 return resultobj;
15496 fail:
15497 {
15498 if (created1) delete arg1;
15499 }
15500 return NULL;
15501 }
15502
15503
15504 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15505 PyObject *resultobj = 0;
15506 wxImage *arg1 = (wxImage *) 0 ;
15507 wxInputStream *arg2 = 0 ;
15508 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15509 int arg4 = (int) -1 ;
15510 bool result;
15511 void *argp1 = 0 ;
15512 int res1 = 0 ;
15513 wxPyInputStream *temp2 ;
15514 bool created2 ;
15515 long val3 ;
15516 int ecode3 = 0 ;
15517 int val4 ;
15518 int ecode4 = 0 ;
15519 PyObject * obj0 = 0 ;
15520 PyObject * obj1 = 0 ;
15521 PyObject * obj2 = 0 ;
15522 PyObject * obj3 = 0 ;
15523 char * kwnames[] = {
15524 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15525 };
15526
15527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15529 if (!SWIG_IsOK(res1)) {
15530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15531 }
15532 arg1 = reinterpret_cast< wxImage * >(argp1);
15533 {
15534 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15535 arg2 = temp2->m_wxis;
15536 created2 = false;
15537 } else {
15538 PyErr_Clear(); // clear the failure of the wxPyConvert above
15539 arg2 = wxPyCBInputStream_create(obj1, false);
15540 if (arg2 == NULL) {
15541 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15542 SWIG_fail;
15543 }
15544 created2 = true;
15545 }
15546 }
15547 if (obj2) {
15548 ecode3 = SWIG_AsVal_long(obj2, &val3);
15549 if (!SWIG_IsOK(ecode3)) {
15550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15551 }
15552 arg3 = static_cast< long >(val3);
15553 }
15554 if (obj3) {
15555 ecode4 = SWIG_AsVal_int(obj3, &val4);
15556 if (!SWIG_IsOK(ecode4)) {
15557 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15558 }
15559 arg4 = static_cast< int >(val4);
15560 }
15561 {
15562 PyThreadState* __tstate = wxPyBeginAllowThreads();
15563 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15564 wxPyEndAllowThreads(__tstate);
15565 if (PyErr_Occurred()) SWIG_fail;
15566 }
15567 {
15568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15569 }
15570 {
15571 if (created2) delete arg2;
15572 }
15573 return resultobj;
15574 fail:
15575 {
15576 if (created2) delete arg2;
15577 }
15578 return NULL;
15579 }
15580
15581
15582 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15583 PyObject *resultobj = 0;
15584 wxImage *arg1 = (wxImage *) 0 ;
15585 wxInputStream *arg2 = 0 ;
15586 wxString *arg3 = 0 ;
15587 int arg4 = (int) -1 ;
15588 bool result;
15589 void *argp1 = 0 ;
15590 int res1 = 0 ;
15591 wxPyInputStream *temp2 ;
15592 bool created2 ;
15593 bool temp3 = false ;
15594 int val4 ;
15595 int ecode4 = 0 ;
15596 PyObject * obj0 = 0 ;
15597 PyObject * obj1 = 0 ;
15598 PyObject * obj2 = 0 ;
15599 PyObject * obj3 = 0 ;
15600 char * kwnames[] = {
15601 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15602 };
15603
15604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15606 if (!SWIG_IsOK(res1)) {
15607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15608 }
15609 arg1 = reinterpret_cast< wxImage * >(argp1);
15610 {
15611 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15612 arg2 = temp2->m_wxis;
15613 created2 = false;
15614 } else {
15615 PyErr_Clear(); // clear the failure of the wxPyConvert above
15616 arg2 = wxPyCBInputStream_create(obj1, false);
15617 if (arg2 == NULL) {
15618 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15619 SWIG_fail;
15620 }
15621 created2 = true;
15622 }
15623 }
15624 {
15625 arg3 = wxString_in_helper(obj2);
15626 if (arg3 == NULL) SWIG_fail;
15627 temp3 = true;
15628 }
15629 if (obj3) {
15630 ecode4 = SWIG_AsVal_int(obj3, &val4);
15631 if (!SWIG_IsOK(ecode4)) {
15632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15633 }
15634 arg4 = static_cast< int >(val4);
15635 }
15636 {
15637 PyThreadState* __tstate = wxPyBeginAllowThreads();
15638 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15639 wxPyEndAllowThreads(__tstate);
15640 if (PyErr_Occurred()) SWIG_fail;
15641 }
15642 {
15643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15644 }
15645 {
15646 if (created2) delete arg2;
15647 }
15648 {
15649 if (temp3)
15650 delete arg3;
15651 }
15652 return resultobj;
15653 fail:
15654 {
15655 if (created2) delete arg2;
15656 }
15657 {
15658 if (temp3)
15659 delete arg3;
15660 }
15661 return NULL;
15662 }
15663
15664
15665 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15666 PyObject *resultobj = 0;
15667 wxImage *arg1 = (wxImage *) 0 ;
15668 bool result;
15669 void *argp1 = 0 ;
15670 int res1 = 0 ;
15671 PyObject *swig_obj[1] ;
15672
15673 if (!args) SWIG_fail;
15674 swig_obj[0] = args;
15675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15676 if (!SWIG_IsOK(res1)) {
15677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15678 }
15679 arg1 = reinterpret_cast< wxImage * >(argp1);
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 result = (bool)(arg1)->Ok();
15683 wxPyEndAllowThreads(__tstate);
15684 if (PyErr_Occurred()) SWIG_fail;
15685 }
15686 {
15687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15688 }
15689 return resultobj;
15690 fail:
15691 return NULL;
15692 }
15693
15694
15695 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15696 PyObject *resultobj = 0;
15697 wxImage *arg1 = (wxImage *) 0 ;
15698 int result;
15699 void *argp1 = 0 ;
15700 int res1 = 0 ;
15701 PyObject *swig_obj[1] ;
15702
15703 if (!args) SWIG_fail;
15704 swig_obj[0] = args;
15705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15706 if (!SWIG_IsOK(res1)) {
15707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15708 }
15709 arg1 = reinterpret_cast< wxImage * >(argp1);
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 result = (int)(arg1)->GetWidth();
15713 wxPyEndAllowThreads(__tstate);
15714 if (PyErr_Occurred()) SWIG_fail;
15715 }
15716 resultobj = SWIG_From_int(static_cast< int >(result));
15717 return resultobj;
15718 fail:
15719 return NULL;
15720 }
15721
15722
15723 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15724 PyObject *resultobj = 0;
15725 wxImage *arg1 = (wxImage *) 0 ;
15726 int result;
15727 void *argp1 = 0 ;
15728 int res1 = 0 ;
15729 PyObject *swig_obj[1] ;
15730
15731 if (!args) SWIG_fail;
15732 swig_obj[0] = args;
15733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15734 if (!SWIG_IsOK(res1)) {
15735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15736 }
15737 arg1 = reinterpret_cast< wxImage * >(argp1);
15738 {
15739 PyThreadState* __tstate = wxPyBeginAllowThreads();
15740 result = (int)(arg1)->GetHeight();
15741 wxPyEndAllowThreads(__tstate);
15742 if (PyErr_Occurred()) SWIG_fail;
15743 }
15744 resultobj = SWIG_From_int(static_cast< int >(result));
15745 return resultobj;
15746 fail:
15747 return NULL;
15748 }
15749
15750
15751 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15752 PyObject *resultobj = 0;
15753 wxImage *arg1 = (wxImage *) 0 ;
15754 wxSize result;
15755 void *argp1 = 0 ;
15756 int res1 = 0 ;
15757 PyObject *swig_obj[1] ;
15758
15759 if (!args) SWIG_fail;
15760 swig_obj[0] = args;
15761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15762 if (!SWIG_IsOK(res1)) {
15763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15764 }
15765 arg1 = reinterpret_cast< wxImage * >(argp1);
15766 {
15767 PyThreadState* __tstate = wxPyBeginAllowThreads();
15768 result = wxImage_GetSize(arg1);
15769 wxPyEndAllowThreads(__tstate);
15770 if (PyErr_Occurred()) SWIG_fail;
15771 }
15772 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15773 return resultobj;
15774 fail:
15775 return NULL;
15776 }
15777
15778
15779 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15780 PyObject *resultobj = 0;
15781 wxImage *arg1 = (wxImage *) 0 ;
15782 wxRect *arg2 = 0 ;
15783 SwigValueWrapper<wxImage > result;
15784 void *argp1 = 0 ;
15785 int res1 = 0 ;
15786 wxRect temp2 ;
15787 PyObject * obj0 = 0 ;
15788 PyObject * obj1 = 0 ;
15789 char * kwnames[] = {
15790 (char *) "self",(char *) "rect", NULL
15791 };
15792
15793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15795 if (!SWIG_IsOK(res1)) {
15796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15797 }
15798 arg1 = reinterpret_cast< wxImage * >(argp1);
15799 {
15800 arg2 = &temp2;
15801 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15802 }
15803 {
15804 PyThreadState* __tstate = wxPyBeginAllowThreads();
15805 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15806 wxPyEndAllowThreads(__tstate);
15807 if (PyErr_Occurred()) SWIG_fail;
15808 }
15809 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15810 return resultobj;
15811 fail:
15812 return NULL;
15813 }
15814
15815
15816 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15817 PyObject *resultobj = 0;
15818 wxImage *arg1 = (wxImage *) 0 ;
15819 wxSize *arg2 = 0 ;
15820 wxPoint *arg3 = 0 ;
15821 int arg4 = (int) -1 ;
15822 int arg5 = (int) -1 ;
15823 int arg6 = (int) -1 ;
15824 SwigValueWrapper<wxImage > result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 wxSize temp2 ;
15828 wxPoint temp3 ;
15829 int val4 ;
15830 int ecode4 = 0 ;
15831 int val5 ;
15832 int ecode5 = 0 ;
15833 int val6 ;
15834 int ecode6 = 0 ;
15835 PyObject * obj0 = 0 ;
15836 PyObject * obj1 = 0 ;
15837 PyObject * obj2 = 0 ;
15838 PyObject * obj3 = 0 ;
15839 PyObject * obj4 = 0 ;
15840 PyObject * obj5 = 0 ;
15841 char * kwnames[] = {
15842 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15843 };
15844
15845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15847 if (!SWIG_IsOK(res1)) {
15848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15849 }
15850 arg1 = reinterpret_cast< wxImage * >(argp1);
15851 {
15852 arg2 = &temp2;
15853 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15854 }
15855 {
15856 arg3 = &temp3;
15857 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15858 }
15859 if (obj3) {
15860 ecode4 = SWIG_AsVal_int(obj3, &val4);
15861 if (!SWIG_IsOK(ecode4)) {
15862 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15863 }
15864 arg4 = static_cast< int >(val4);
15865 }
15866 if (obj4) {
15867 ecode5 = SWIG_AsVal_int(obj4, &val5);
15868 if (!SWIG_IsOK(ecode5)) {
15869 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15870 }
15871 arg5 = static_cast< int >(val5);
15872 }
15873 if (obj5) {
15874 ecode6 = SWIG_AsVal_int(obj5, &val6);
15875 if (!SWIG_IsOK(ecode6)) {
15876 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15877 }
15878 arg6 = static_cast< int >(val6);
15879 }
15880 {
15881 PyThreadState* __tstate = wxPyBeginAllowThreads();
15882 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15883 wxPyEndAllowThreads(__tstate);
15884 if (PyErr_Occurred()) SWIG_fail;
15885 }
15886 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15887 return resultobj;
15888 fail:
15889 return NULL;
15890 }
15891
15892
15893 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15894 PyObject *resultobj = 0;
15895 wxImage *arg1 = (wxImage *) 0 ;
15896 SwigValueWrapper<wxImage > result;
15897 void *argp1 = 0 ;
15898 int res1 = 0 ;
15899 PyObject *swig_obj[1] ;
15900
15901 if (!args) SWIG_fail;
15902 swig_obj[0] = args;
15903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15904 if (!SWIG_IsOK(res1)) {
15905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15906 }
15907 arg1 = reinterpret_cast< wxImage * >(argp1);
15908 {
15909 PyThreadState* __tstate = wxPyBeginAllowThreads();
15910 result = (arg1)->Copy();
15911 wxPyEndAllowThreads(__tstate);
15912 if (PyErr_Occurred()) SWIG_fail;
15913 }
15914 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15915 return resultobj;
15916 fail:
15917 return NULL;
15918 }
15919
15920
15921 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15922 PyObject *resultobj = 0;
15923 wxImage *arg1 = (wxImage *) 0 ;
15924 wxImage *arg2 = 0 ;
15925 int arg3 ;
15926 int arg4 ;
15927 void *argp1 = 0 ;
15928 int res1 = 0 ;
15929 void *argp2 = 0 ;
15930 int res2 = 0 ;
15931 int val3 ;
15932 int ecode3 = 0 ;
15933 int val4 ;
15934 int ecode4 = 0 ;
15935 PyObject * obj0 = 0 ;
15936 PyObject * obj1 = 0 ;
15937 PyObject * obj2 = 0 ;
15938 PyObject * obj3 = 0 ;
15939 char * kwnames[] = {
15940 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15941 };
15942
15943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15945 if (!SWIG_IsOK(res1)) {
15946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15947 }
15948 arg1 = reinterpret_cast< wxImage * >(argp1);
15949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15950 if (!SWIG_IsOK(res2)) {
15951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15952 }
15953 if (!argp2) {
15954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15955 }
15956 arg2 = reinterpret_cast< wxImage * >(argp2);
15957 ecode3 = SWIG_AsVal_int(obj2, &val3);
15958 if (!SWIG_IsOK(ecode3)) {
15959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15960 }
15961 arg3 = static_cast< int >(val3);
15962 ecode4 = SWIG_AsVal_int(obj3, &val4);
15963 if (!SWIG_IsOK(ecode4)) {
15964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15965 }
15966 arg4 = static_cast< int >(val4);
15967 {
15968 PyThreadState* __tstate = wxPyBeginAllowThreads();
15969 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15970 wxPyEndAllowThreads(__tstate);
15971 if (PyErr_Occurred()) SWIG_fail;
15972 }
15973 resultobj = SWIG_Py_Void();
15974 return resultobj;
15975 fail:
15976 return NULL;
15977 }
15978
15979
15980 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15981 PyObject *resultobj = 0;
15982 wxImage *arg1 = (wxImage *) 0 ;
15983 PyObject *result = 0 ;
15984 void *argp1 = 0 ;
15985 int res1 = 0 ;
15986 PyObject *swig_obj[1] ;
15987
15988 if (!args) SWIG_fail;
15989 swig_obj[0] = args;
15990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15991 if (!SWIG_IsOK(res1)) {
15992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15993 }
15994 arg1 = reinterpret_cast< wxImage * >(argp1);
15995 {
15996 PyThreadState* __tstate = wxPyBeginAllowThreads();
15997 result = (PyObject *)wxImage_GetData(arg1);
15998 wxPyEndAllowThreads(__tstate);
15999 if (PyErr_Occurred()) SWIG_fail;
16000 }
16001 resultobj = result;
16002 return resultobj;
16003 fail:
16004 return NULL;
16005 }
16006
16007
16008 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16009 PyObject *resultobj = 0;
16010 wxImage *arg1 = (wxImage *) 0 ;
16011 buffer arg2 ;
16012 int arg3 ;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 Py_ssize_t temp2 ;
16016 PyObject * obj0 = 0 ;
16017 PyObject * obj1 = 0 ;
16018 char * kwnames[] = {
16019 (char *) "self",(char *) "data", NULL
16020 };
16021
16022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16024 if (!SWIG_IsOK(res1)) {
16025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16026 }
16027 arg1 = reinterpret_cast< wxImage * >(argp1);
16028 {
16029 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16030 arg3 = (int)temp2;
16031 }
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 wxImage_SetData(arg1,arg2,arg3);
16035 wxPyEndAllowThreads(__tstate);
16036 if (PyErr_Occurred()) SWIG_fail;
16037 }
16038 resultobj = SWIG_Py_Void();
16039 return resultobj;
16040 fail:
16041 return NULL;
16042 }
16043
16044
16045 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16046 PyObject *resultobj = 0;
16047 wxImage *arg1 = (wxImage *) 0 ;
16048 PyObject *result = 0 ;
16049 void *argp1 = 0 ;
16050 int res1 = 0 ;
16051 PyObject *swig_obj[1] ;
16052
16053 if (!args) SWIG_fail;
16054 swig_obj[0] = args;
16055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16056 if (!SWIG_IsOK(res1)) {
16057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16058 }
16059 arg1 = reinterpret_cast< wxImage * >(argp1);
16060 {
16061 PyThreadState* __tstate = wxPyBeginAllowThreads();
16062 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16063 wxPyEndAllowThreads(__tstate);
16064 if (PyErr_Occurred()) SWIG_fail;
16065 }
16066 resultobj = result;
16067 return resultobj;
16068 fail:
16069 return NULL;
16070 }
16071
16072
16073 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16074 PyObject *resultobj = 0;
16075 wxImage *arg1 = (wxImage *) 0 ;
16076 buffer arg2 ;
16077 int arg3 ;
16078 void *argp1 = 0 ;
16079 int res1 = 0 ;
16080 Py_ssize_t temp2 ;
16081 PyObject * obj0 = 0 ;
16082 PyObject * obj1 = 0 ;
16083 char * kwnames[] = {
16084 (char *) "self",(char *) "data", NULL
16085 };
16086
16087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16089 if (!SWIG_IsOK(res1)) {
16090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16091 }
16092 arg1 = reinterpret_cast< wxImage * >(argp1);
16093 {
16094 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16095 arg3 = (int)temp2;
16096 }
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 wxImage_SetDataBuffer(arg1,arg2,arg3);
16100 wxPyEndAllowThreads(__tstate);
16101 if (PyErr_Occurred()) SWIG_fail;
16102 }
16103 resultobj = SWIG_Py_Void();
16104 return resultobj;
16105 fail:
16106 return NULL;
16107 }
16108
16109
16110 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16111 PyObject *resultobj = 0;
16112 wxImage *arg1 = (wxImage *) 0 ;
16113 PyObject *result = 0 ;
16114 void *argp1 = 0 ;
16115 int res1 = 0 ;
16116 PyObject *swig_obj[1] ;
16117
16118 if (!args) SWIG_fail;
16119 swig_obj[0] = args;
16120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16121 if (!SWIG_IsOK(res1)) {
16122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16123 }
16124 arg1 = reinterpret_cast< wxImage * >(argp1);
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (PyObject *)wxImage_GetAlphaData(arg1);
16128 wxPyEndAllowThreads(__tstate);
16129 if (PyErr_Occurred()) SWIG_fail;
16130 }
16131 resultobj = result;
16132 return resultobj;
16133 fail:
16134 return NULL;
16135 }
16136
16137
16138 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16139 PyObject *resultobj = 0;
16140 wxImage *arg1 = (wxImage *) 0 ;
16141 buffer arg2 ;
16142 int arg3 ;
16143 void *argp1 = 0 ;
16144 int res1 = 0 ;
16145 Py_ssize_t temp2 ;
16146 PyObject * obj0 = 0 ;
16147 PyObject * obj1 = 0 ;
16148 char * kwnames[] = {
16149 (char *) "self",(char *) "alpha", NULL
16150 };
16151
16152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16154 if (!SWIG_IsOK(res1)) {
16155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16156 }
16157 arg1 = reinterpret_cast< wxImage * >(argp1);
16158 {
16159 if (obj1 != Py_None) {
16160 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16161 arg3 = (int)temp2;
16162 }
16163 }
16164 {
16165 PyThreadState* __tstate = wxPyBeginAllowThreads();
16166 wxImage_SetAlphaData(arg1,arg2,arg3);
16167 wxPyEndAllowThreads(__tstate);
16168 if (PyErr_Occurred()) SWIG_fail;
16169 }
16170 resultobj = SWIG_Py_Void();
16171 return resultobj;
16172 fail:
16173 return NULL;
16174 }
16175
16176
16177 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16178 PyObject *resultobj = 0;
16179 wxImage *arg1 = (wxImage *) 0 ;
16180 PyObject *result = 0 ;
16181 void *argp1 = 0 ;
16182 int res1 = 0 ;
16183 PyObject *swig_obj[1] ;
16184
16185 if (!args) SWIG_fail;
16186 swig_obj[0] = args;
16187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16188 if (!SWIG_IsOK(res1)) {
16189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16190 }
16191 arg1 = reinterpret_cast< wxImage * >(argp1);
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = result;
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj = 0;
16207 wxImage *arg1 = (wxImage *) 0 ;
16208 buffer arg2 ;
16209 int arg3 ;
16210 void *argp1 = 0 ;
16211 int res1 = 0 ;
16212 Py_ssize_t temp2 ;
16213 PyObject * obj0 = 0 ;
16214 PyObject * obj1 = 0 ;
16215 char * kwnames[] = {
16216 (char *) "self",(char *) "alpha", NULL
16217 };
16218
16219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16221 if (!SWIG_IsOK(res1)) {
16222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16223 }
16224 arg1 = reinterpret_cast< wxImage * >(argp1);
16225 {
16226 if (obj1 != Py_None) {
16227 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16228 arg3 = (int)temp2;
16229 }
16230 }
16231 {
16232 PyThreadState* __tstate = wxPyBeginAllowThreads();
16233 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16234 wxPyEndAllowThreads(__tstate);
16235 if (PyErr_Occurred()) SWIG_fail;
16236 }
16237 resultobj = SWIG_Py_Void();
16238 return resultobj;
16239 fail:
16240 return NULL;
16241 }
16242
16243
16244 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16245 PyObject *resultobj = 0;
16246 wxImage *arg1 = (wxImage *) 0 ;
16247 byte arg2 ;
16248 byte arg3 ;
16249 byte arg4 ;
16250 void *argp1 = 0 ;
16251 int res1 = 0 ;
16252 unsigned char val2 ;
16253 int ecode2 = 0 ;
16254 unsigned char val3 ;
16255 int ecode3 = 0 ;
16256 unsigned char val4 ;
16257 int ecode4 = 0 ;
16258 PyObject * obj0 = 0 ;
16259 PyObject * obj1 = 0 ;
16260 PyObject * obj2 = 0 ;
16261 PyObject * obj3 = 0 ;
16262 char * kwnames[] = {
16263 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16264 };
16265
16266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16268 if (!SWIG_IsOK(res1)) {
16269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16270 }
16271 arg1 = reinterpret_cast< wxImage * >(argp1);
16272 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16273 if (!SWIG_IsOK(ecode2)) {
16274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16275 }
16276 arg2 = static_cast< byte >(val2);
16277 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16278 if (!SWIG_IsOK(ecode3)) {
16279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16280 }
16281 arg3 = static_cast< byte >(val3);
16282 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16283 if (!SWIG_IsOK(ecode4)) {
16284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16285 }
16286 arg4 = static_cast< byte >(val4);
16287 {
16288 PyThreadState* __tstate = wxPyBeginAllowThreads();
16289 (arg1)->SetMaskColour(arg2,arg3,arg4);
16290 wxPyEndAllowThreads(__tstate);
16291 if (PyErr_Occurred()) SWIG_fail;
16292 }
16293 resultobj = SWIG_Py_Void();
16294 return resultobj;
16295 fail:
16296 return NULL;
16297 }
16298
16299
16300 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16301 PyObject *resultobj = 0;
16302 wxImage *arg1 = (wxImage *) 0 ;
16303 byte *arg2 = (byte *) 0 ;
16304 byte *arg3 = (byte *) 0 ;
16305 byte *arg4 = (byte *) 0 ;
16306 void *argp1 = 0 ;
16307 int res1 = 0 ;
16308 byte temp2 ;
16309 int res2 = SWIG_TMPOBJ ;
16310 byte temp3 ;
16311 int res3 = SWIG_TMPOBJ ;
16312 byte temp4 ;
16313 int res4 = SWIG_TMPOBJ ;
16314 PyObject *swig_obj[1] ;
16315
16316 arg2 = &temp2;
16317 arg3 = &temp3;
16318 arg4 = &temp4;
16319 if (!args) SWIG_fail;
16320 swig_obj[0] = args;
16321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16322 if (!SWIG_IsOK(res1)) {
16323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16324 }
16325 arg1 = reinterpret_cast< wxImage * >(argp1);
16326 {
16327 PyThreadState* __tstate = wxPyBeginAllowThreads();
16328 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16329 wxPyEndAllowThreads(__tstate);
16330 if (PyErr_Occurred()) SWIG_fail;
16331 }
16332 resultobj = SWIG_Py_Void();
16333 if (SWIG_IsTmpObj(res2)) {
16334 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16335 } else {
16336 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16337 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16338 }
16339 if (SWIG_IsTmpObj(res3)) {
16340 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16341 } else {
16342 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16344 }
16345 if (SWIG_IsTmpObj(res4)) {
16346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16347 } else {
16348 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16350 }
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16358 PyObject *resultobj = 0;
16359 wxImage *arg1 = (wxImage *) 0 ;
16360 byte result;
16361 void *argp1 = 0 ;
16362 int res1 = 0 ;
16363 PyObject *swig_obj[1] ;
16364
16365 if (!args) SWIG_fail;
16366 swig_obj[0] = args;
16367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16368 if (!SWIG_IsOK(res1)) {
16369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16370 }
16371 arg1 = reinterpret_cast< wxImage * >(argp1);
16372 {
16373 PyThreadState* __tstate = wxPyBeginAllowThreads();
16374 result = (byte)(arg1)->GetMaskRed();
16375 wxPyEndAllowThreads(__tstate);
16376 if (PyErr_Occurred()) SWIG_fail;
16377 }
16378 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16379 return resultobj;
16380 fail:
16381 return NULL;
16382 }
16383
16384
16385 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16386 PyObject *resultobj = 0;
16387 wxImage *arg1 = (wxImage *) 0 ;
16388 byte result;
16389 void *argp1 = 0 ;
16390 int res1 = 0 ;
16391 PyObject *swig_obj[1] ;
16392
16393 if (!args) SWIG_fail;
16394 swig_obj[0] = args;
16395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16396 if (!SWIG_IsOK(res1)) {
16397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16398 }
16399 arg1 = reinterpret_cast< wxImage * >(argp1);
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 result = (byte)(arg1)->GetMaskGreen();
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16407 return resultobj;
16408 fail:
16409 return NULL;
16410 }
16411
16412
16413 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16414 PyObject *resultobj = 0;
16415 wxImage *arg1 = (wxImage *) 0 ;
16416 byte result;
16417 void *argp1 = 0 ;
16418 int res1 = 0 ;
16419 PyObject *swig_obj[1] ;
16420
16421 if (!args) SWIG_fail;
16422 swig_obj[0] = args;
16423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16426 }
16427 arg1 = reinterpret_cast< wxImage * >(argp1);
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 result = (byte)(arg1)->GetMaskBlue();
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16435 return resultobj;
16436 fail:
16437 return NULL;
16438 }
16439
16440
16441 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16442 PyObject *resultobj = 0;
16443 wxImage *arg1 = (wxImage *) 0 ;
16444 bool arg2 = (bool) true ;
16445 void *argp1 = 0 ;
16446 int res1 = 0 ;
16447 bool val2 ;
16448 int ecode2 = 0 ;
16449 PyObject * obj0 = 0 ;
16450 PyObject * obj1 = 0 ;
16451 char * kwnames[] = {
16452 (char *) "self",(char *) "mask", NULL
16453 };
16454
16455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16457 if (!SWIG_IsOK(res1)) {
16458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16459 }
16460 arg1 = reinterpret_cast< wxImage * >(argp1);
16461 if (obj1) {
16462 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16463 if (!SWIG_IsOK(ecode2)) {
16464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16465 }
16466 arg2 = static_cast< bool >(val2);
16467 }
16468 {
16469 PyThreadState* __tstate = wxPyBeginAllowThreads();
16470 (arg1)->SetMask(arg2);
16471 wxPyEndAllowThreads(__tstate);
16472 if (PyErr_Occurred()) SWIG_fail;
16473 }
16474 resultobj = SWIG_Py_Void();
16475 return resultobj;
16476 fail:
16477 return NULL;
16478 }
16479
16480
16481 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16482 PyObject *resultobj = 0;
16483 wxImage *arg1 = (wxImage *) 0 ;
16484 bool result;
16485 void *argp1 = 0 ;
16486 int res1 = 0 ;
16487 PyObject *swig_obj[1] ;
16488
16489 if (!args) SWIG_fail;
16490 swig_obj[0] = args;
16491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16492 if (!SWIG_IsOK(res1)) {
16493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16494 }
16495 arg1 = reinterpret_cast< wxImage * >(argp1);
16496 {
16497 PyThreadState* __tstate = wxPyBeginAllowThreads();
16498 result = (bool)(arg1)->HasMask();
16499 wxPyEndAllowThreads(__tstate);
16500 if (PyErr_Occurred()) SWIG_fail;
16501 }
16502 {
16503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16504 }
16505 return resultobj;
16506 fail:
16507 return NULL;
16508 }
16509
16510
16511 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16512 PyObject *resultobj = 0;
16513 wxImage *arg1 = (wxImage *) 0 ;
16514 double arg2 ;
16515 wxPoint *arg3 = 0 ;
16516 bool arg4 = (bool) true ;
16517 wxPoint *arg5 = (wxPoint *) NULL ;
16518 SwigValueWrapper<wxImage > result;
16519 void *argp1 = 0 ;
16520 int res1 = 0 ;
16521 double val2 ;
16522 int ecode2 = 0 ;
16523 wxPoint temp3 ;
16524 bool val4 ;
16525 int ecode4 = 0 ;
16526 void *argp5 = 0 ;
16527 int res5 = 0 ;
16528 PyObject * obj0 = 0 ;
16529 PyObject * obj1 = 0 ;
16530 PyObject * obj2 = 0 ;
16531 PyObject * obj3 = 0 ;
16532 PyObject * obj4 = 0 ;
16533 char * kwnames[] = {
16534 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16535 };
16536
16537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16539 if (!SWIG_IsOK(res1)) {
16540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16541 }
16542 arg1 = reinterpret_cast< wxImage * >(argp1);
16543 ecode2 = SWIG_AsVal_double(obj1, &val2);
16544 if (!SWIG_IsOK(ecode2)) {
16545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16546 }
16547 arg2 = static_cast< double >(val2);
16548 {
16549 arg3 = &temp3;
16550 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16551 }
16552 if (obj3) {
16553 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16554 if (!SWIG_IsOK(ecode4)) {
16555 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16556 }
16557 arg4 = static_cast< bool >(val4);
16558 }
16559 if (obj4) {
16560 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16561 if (!SWIG_IsOK(res5)) {
16562 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16563 }
16564 arg5 = reinterpret_cast< wxPoint * >(argp5);
16565 }
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16569 wxPyEndAllowThreads(__tstate);
16570 if (PyErr_Occurred()) SWIG_fail;
16571 }
16572 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16573 return resultobj;
16574 fail:
16575 return NULL;
16576 }
16577
16578
16579 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16580 PyObject *resultobj = 0;
16581 wxImage *arg1 = (wxImage *) 0 ;
16582 bool arg2 = (bool) true ;
16583 SwigValueWrapper<wxImage > result;
16584 void *argp1 = 0 ;
16585 int res1 = 0 ;
16586 bool val2 ;
16587 int ecode2 = 0 ;
16588 PyObject * obj0 = 0 ;
16589 PyObject * obj1 = 0 ;
16590 char * kwnames[] = {
16591 (char *) "self",(char *) "clockwise", NULL
16592 };
16593
16594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16596 if (!SWIG_IsOK(res1)) {
16597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16598 }
16599 arg1 = reinterpret_cast< wxImage * >(argp1);
16600 if (obj1) {
16601 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16602 if (!SWIG_IsOK(ecode2)) {
16603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16604 }
16605 arg2 = static_cast< bool >(val2);
16606 }
16607 {
16608 PyThreadState* __tstate = wxPyBeginAllowThreads();
16609 result = (arg1)->Rotate90(arg2);
16610 wxPyEndAllowThreads(__tstate);
16611 if (PyErr_Occurred()) SWIG_fail;
16612 }
16613 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16614 return resultobj;
16615 fail:
16616 return NULL;
16617 }
16618
16619
16620 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16621 PyObject *resultobj = 0;
16622 wxImage *arg1 = (wxImage *) 0 ;
16623 bool arg2 = (bool) true ;
16624 SwigValueWrapper<wxImage > result;
16625 void *argp1 = 0 ;
16626 int res1 = 0 ;
16627 bool val2 ;
16628 int ecode2 = 0 ;
16629 PyObject * obj0 = 0 ;
16630 PyObject * obj1 = 0 ;
16631 char * kwnames[] = {
16632 (char *) "self",(char *) "horizontally", NULL
16633 };
16634
16635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16637 if (!SWIG_IsOK(res1)) {
16638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16639 }
16640 arg1 = reinterpret_cast< wxImage * >(argp1);
16641 if (obj1) {
16642 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16643 if (!SWIG_IsOK(ecode2)) {
16644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16645 }
16646 arg2 = static_cast< bool >(val2);
16647 }
16648 {
16649 PyThreadState* __tstate = wxPyBeginAllowThreads();
16650 result = (arg1)->Mirror(arg2);
16651 wxPyEndAllowThreads(__tstate);
16652 if (PyErr_Occurred()) SWIG_fail;
16653 }
16654 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj = 0;
16663 wxImage *arg1 = (wxImage *) 0 ;
16664 byte arg2 ;
16665 byte arg3 ;
16666 byte arg4 ;
16667 byte arg5 ;
16668 byte arg6 ;
16669 byte arg7 ;
16670 void *argp1 = 0 ;
16671 int res1 = 0 ;
16672 unsigned char val2 ;
16673 int ecode2 = 0 ;
16674 unsigned char val3 ;
16675 int ecode3 = 0 ;
16676 unsigned char val4 ;
16677 int ecode4 = 0 ;
16678 unsigned char val5 ;
16679 int ecode5 = 0 ;
16680 unsigned char val6 ;
16681 int ecode6 = 0 ;
16682 unsigned char val7 ;
16683 int ecode7 = 0 ;
16684 PyObject * obj0 = 0 ;
16685 PyObject * obj1 = 0 ;
16686 PyObject * obj2 = 0 ;
16687 PyObject * obj3 = 0 ;
16688 PyObject * obj4 = 0 ;
16689 PyObject * obj5 = 0 ;
16690 PyObject * obj6 = 0 ;
16691 char * kwnames[] = {
16692 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16693 };
16694
16695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16697 if (!SWIG_IsOK(res1)) {
16698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16699 }
16700 arg1 = reinterpret_cast< wxImage * >(argp1);
16701 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16702 if (!SWIG_IsOK(ecode2)) {
16703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16704 }
16705 arg2 = static_cast< byte >(val2);
16706 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16707 if (!SWIG_IsOK(ecode3)) {
16708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16709 }
16710 arg3 = static_cast< byte >(val3);
16711 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16712 if (!SWIG_IsOK(ecode4)) {
16713 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16714 }
16715 arg4 = static_cast< byte >(val4);
16716 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16717 if (!SWIG_IsOK(ecode5)) {
16718 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16719 }
16720 arg5 = static_cast< byte >(val5);
16721 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16722 if (!SWIG_IsOK(ecode6)) {
16723 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16724 }
16725 arg6 = static_cast< byte >(val6);
16726 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16727 if (!SWIG_IsOK(ecode7)) {
16728 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16729 }
16730 arg7 = static_cast< byte >(val7);
16731 {
16732 PyThreadState* __tstate = wxPyBeginAllowThreads();
16733 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16734 wxPyEndAllowThreads(__tstate);
16735 if (PyErr_Occurred()) SWIG_fail;
16736 }
16737 resultobj = SWIG_Py_Void();
16738 return resultobj;
16739 fail:
16740 return NULL;
16741 }
16742
16743
16744 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16745 PyObject *resultobj = 0;
16746 wxImage *arg1 = (wxImage *) 0 ;
16747 double arg2 = (double) 0.299 ;
16748 double arg3 = (double) 0.587 ;
16749 double arg4 = (double) 0.114 ;
16750 SwigValueWrapper<wxImage > result;
16751 void *argp1 = 0 ;
16752 int res1 = 0 ;
16753 double val2 ;
16754 int ecode2 = 0 ;
16755 double val3 ;
16756 int ecode3 = 0 ;
16757 double val4 ;
16758 int ecode4 = 0 ;
16759 PyObject * obj0 = 0 ;
16760 PyObject * obj1 = 0 ;
16761 PyObject * obj2 = 0 ;
16762 PyObject * obj3 = 0 ;
16763 char * kwnames[] = {
16764 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16765 };
16766
16767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16769 if (!SWIG_IsOK(res1)) {
16770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16771 }
16772 arg1 = reinterpret_cast< wxImage * >(argp1);
16773 if (obj1) {
16774 ecode2 = SWIG_AsVal_double(obj1, &val2);
16775 if (!SWIG_IsOK(ecode2)) {
16776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16777 }
16778 arg2 = static_cast< double >(val2);
16779 }
16780 if (obj2) {
16781 ecode3 = SWIG_AsVal_double(obj2, &val3);
16782 if (!SWIG_IsOK(ecode3)) {
16783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16784 }
16785 arg3 = static_cast< double >(val3);
16786 }
16787 if (obj3) {
16788 ecode4 = SWIG_AsVal_double(obj3, &val4);
16789 if (!SWIG_IsOK(ecode4)) {
16790 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16791 }
16792 arg4 = static_cast< double >(val4);
16793 }
16794 {
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16797 wxPyEndAllowThreads(__tstate);
16798 if (PyErr_Occurred()) SWIG_fail;
16799 }
16800 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16801 return resultobj;
16802 fail:
16803 return NULL;
16804 }
16805
16806
16807 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16808 PyObject *resultobj = 0;
16809 wxImage *arg1 = (wxImage *) 0 ;
16810 byte arg2 ;
16811 byte arg3 ;
16812 byte arg4 ;
16813 SwigValueWrapper<wxImage > result;
16814 void *argp1 = 0 ;
16815 int res1 = 0 ;
16816 unsigned char val2 ;
16817 int ecode2 = 0 ;
16818 unsigned char val3 ;
16819 int ecode3 = 0 ;
16820 unsigned char val4 ;
16821 int ecode4 = 0 ;
16822 PyObject * obj0 = 0 ;
16823 PyObject * obj1 = 0 ;
16824 PyObject * obj2 = 0 ;
16825 PyObject * obj3 = 0 ;
16826 char * kwnames[] = {
16827 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16828 };
16829
16830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16832 if (!SWIG_IsOK(res1)) {
16833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16834 }
16835 arg1 = reinterpret_cast< wxImage * >(argp1);
16836 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16837 if (!SWIG_IsOK(ecode2)) {
16838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16839 }
16840 arg2 = static_cast< byte >(val2);
16841 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16842 if (!SWIG_IsOK(ecode3)) {
16843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16844 }
16845 arg3 = static_cast< byte >(val3);
16846 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16847 if (!SWIG_IsOK(ecode4)) {
16848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16849 }
16850 arg4 = static_cast< byte >(val4);
16851 {
16852 PyThreadState* __tstate = wxPyBeginAllowThreads();
16853 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16854 wxPyEndAllowThreads(__tstate);
16855 if (PyErr_Occurred()) SWIG_fail;
16856 }
16857 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16865 PyObject *resultobj = 0;
16866 wxImage *arg1 = (wxImage *) 0 ;
16867 wxString *arg2 = 0 ;
16868 wxString *arg3 = 0 ;
16869 void *argp1 = 0 ;
16870 int res1 = 0 ;
16871 bool temp2 = false ;
16872 bool temp3 = false ;
16873 PyObject * obj0 = 0 ;
16874 PyObject * obj1 = 0 ;
16875 PyObject * obj2 = 0 ;
16876 char * kwnames[] = {
16877 (char *) "self",(char *) "name",(char *) "value", NULL
16878 };
16879
16880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16882 if (!SWIG_IsOK(res1)) {
16883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16884 }
16885 arg1 = reinterpret_cast< wxImage * >(argp1);
16886 {
16887 arg2 = wxString_in_helper(obj1);
16888 if (arg2 == NULL) SWIG_fail;
16889 temp2 = true;
16890 }
16891 {
16892 arg3 = wxString_in_helper(obj2);
16893 if (arg3 == NULL) SWIG_fail;
16894 temp3 = true;
16895 }
16896 {
16897 PyThreadState* __tstate = wxPyBeginAllowThreads();
16898 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 resultobj = SWIG_Py_Void();
16903 {
16904 if (temp2)
16905 delete arg2;
16906 }
16907 {
16908 if (temp3)
16909 delete arg3;
16910 }
16911 return resultobj;
16912 fail:
16913 {
16914 if (temp2)
16915 delete arg2;
16916 }
16917 {
16918 if (temp3)
16919 delete arg3;
16920 }
16921 return NULL;
16922 }
16923
16924
16925 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16926 PyObject *resultobj = 0;
16927 wxImage *arg1 = (wxImage *) 0 ;
16928 wxString *arg2 = 0 ;
16929 int arg3 ;
16930 void *argp1 = 0 ;
16931 int res1 = 0 ;
16932 bool temp2 = false ;
16933 int val3 ;
16934 int ecode3 = 0 ;
16935 PyObject * obj0 = 0 ;
16936 PyObject * obj1 = 0 ;
16937 PyObject * obj2 = 0 ;
16938 char * kwnames[] = {
16939 (char *) "self",(char *) "name",(char *) "value", NULL
16940 };
16941
16942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16944 if (!SWIG_IsOK(res1)) {
16945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16946 }
16947 arg1 = reinterpret_cast< wxImage * >(argp1);
16948 {
16949 arg2 = wxString_in_helper(obj1);
16950 if (arg2 == NULL) SWIG_fail;
16951 temp2 = true;
16952 }
16953 ecode3 = SWIG_AsVal_int(obj2, &val3);
16954 if (!SWIG_IsOK(ecode3)) {
16955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16956 }
16957 arg3 = static_cast< int >(val3);
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 (arg1)->SetOption((wxString const &)*arg2,arg3);
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 resultobj = SWIG_Py_Void();
16965 {
16966 if (temp2)
16967 delete arg2;
16968 }
16969 return resultobj;
16970 fail:
16971 {
16972 if (temp2)
16973 delete arg2;
16974 }
16975 return NULL;
16976 }
16977
16978
16979 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16980 PyObject *resultobj = 0;
16981 wxImage *arg1 = (wxImage *) 0 ;
16982 wxString *arg2 = 0 ;
16983 wxString result;
16984 void *argp1 = 0 ;
16985 int res1 = 0 ;
16986 bool temp2 = false ;
16987 PyObject * obj0 = 0 ;
16988 PyObject * obj1 = 0 ;
16989 char * kwnames[] = {
16990 (char *) "self",(char *) "name", NULL
16991 };
16992
16993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16995 if (!SWIG_IsOK(res1)) {
16996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16997 }
16998 arg1 = reinterpret_cast< wxImage * >(argp1);
16999 {
17000 arg2 = wxString_in_helper(obj1);
17001 if (arg2 == NULL) SWIG_fail;
17002 temp2 = true;
17003 }
17004 {
17005 PyThreadState* __tstate = wxPyBeginAllowThreads();
17006 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17007 wxPyEndAllowThreads(__tstate);
17008 if (PyErr_Occurred()) SWIG_fail;
17009 }
17010 {
17011 #if wxUSE_UNICODE
17012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17013 #else
17014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17015 #endif
17016 }
17017 {
17018 if (temp2)
17019 delete arg2;
17020 }
17021 return resultobj;
17022 fail:
17023 {
17024 if (temp2)
17025 delete arg2;
17026 }
17027 return NULL;
17028 }
17029
17030
17031 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17032 PyObject *resultobj = 0;
17033 wxImage *arg1 = (wxImage *) 0 ;
17034 wxString *arg2 = 0 ;
17035 int result;
17036 void *argp1 = 0 ;
17037 int res1 = 0 ;
17038 bool temp2 = false ;
17039 PyObject * obj0 = 0 ;
17040 PyObject * obj1 = 0 ;
17041 char * kwnames[] = {
17042 (char *) "self",(char *) "name", NULL
17043 };
17044
17045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17047 if (!SWIG_IsOK(res1)) {
17048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17049 }
17050 arg1 = reinterpret_cast< wxImage * >(argp1);
17051 {
17052 arg2 = wxString_in_helper(obj1);
17053 if (arg2 == NULL) SWIG_fail;
17054 temp2 = true;
17055 }
17056 {
17057 PyThreadState* __tstate = wxPyBeginAllowThreads();
17058 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17059 wxPyEndAllowThreads(__tstate);
17060 if (PyErr_Occurred()) SWIG_fail;
17061 }
17062 resultobj = SWIG_From_int(static_cast< int >(result));
17063 {
17064 if (temp2)
17065 delete arg2;
17066 }
17067 return resultobj;
17068 fail:
17069 {
17070 if (temp2)
17071 delete arg2;
17072 }
17073 return NULL;
17074 }
17075
17076
17077 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17078 PyObject *resultobj = 0;
17079 wxImage *arg1 = (wxImage *) 0 ;
17080 wxString *arg2 = 0 ;
17081 bool result;
17082 void *argp1 = 0 ;
17083 int res1 = 0 ;
17084 bool temp2 = false ;
17085 PyObject * obj0 = 0 ;
17086 PyObject * obj1 = 0 ;
17087 char * kwnames[] = {
17088 (char *) "self",(char *) "name", NULL
17089 };
17090
17091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17093 if (!SWIG_IsOK(res1)) {
17094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17095 }
17096 arg1 = reinterpret_cast< wxImage * >(argp1);
17097 {
17098 arg2 = wxString_in_helper(obj1);
17099 if (arg2 == NULL) SWIG_fail;
17100 temp2 = true;
17101 }
17102 {
17103 PyThreadState* __tstate = wxPyBeginAllowThreads();
17104 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17105 wxPyEndAllowThreads(__tstate);
17106 if (PyErr_Occurred()) SWIG_fail;
17107 }
17108 {
17109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17110 }
17111 {
17112 if (temp2)
17113 delete arg2;
17114 }
17115 return resultobj;
17116 fail:
17117 {
17118 if (temp2)
17119 delete arg2;
17120 }
17121 return NULL;
17122 }
17123
17124
17125 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17126 PyObject *resultobj = 0;
17127 wxImage *arg1 = (wxImage *) 0 ;
17128 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17129 unsigned long result;
17130 void *argp1 = 0 ;
17131 int res1 = 0 ;
17132 unsigned long val2 ;
17133 int ecode2 = 0 ;
17134 PyObject * obj0 = 0 ;
17135 PyObject * obj1 = 0 ;
17136 char * kwnames[] = {
17137 (char *) "self",(char *) "stopafter", NULL
17138 };
17139
17140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17142 if (!SWIG_IsOK(res1)) {
17143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17144 }
17145 arg1 = reinterpret_cast< wxImage * >(argp1);
17146 if (obj1) {
17147 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17148 if (!SWIG_IsOK(ecode2)) {
17149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17150 }
17151 arg2 = static_cast< unsigned long >(val2);
17152 }
17153 {
17154 PyThreadState* __tstate = wxPyBeginAllowThreads();
17155 result = (unsigned long)(arg1)->CountColours(arg2);
17156 wxPyEndAllowThreads(__tstate);
17157 if (PyErr_Occurred()) SWIG_fail;
17158 }
17159 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17160 return resultobj;
17161 fail:
17162 return NULL;
17163 }
17164
17165
17166 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17167 PyObject *resultobj = 0;
17168 wxImage *arg1 = (wxImage *) 0 ;
17169 wxImageHistogram *arg2 = 0 ;
17170 unsigned long result;
17171 void *argp1 = 0 ;
17172 int res1 = 0 ;
17173 void *argp2 = 0 ;
17174 int res2 = 0 ;
17175 PyObject * obj0 = 0 ;
17176 PyObject * obj1 = 0 ;
17177 char * kwnames[] = {
17178 (char *) "self",(char *) "h", NULL
17179 };
17180
17181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17183 if (!SWIG_IsOK(res1)) {
17184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17185 }
17186 arg1 = reinterpret_cast< wxImage * >(argp1);
17187 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17188 if (!SWIG_IsOK(res2)) {
17189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17190 }
17191 if (!argp2) {
17192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17193 }
17194 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17195 {
17196 PyThreadState* __tstate = wxPyBeginAllowThreads();
17197 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17202 return resultobj;
17203 fail:
17204 return NULL;
17205 }
17206
17207
17208 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17209 PyObject *resultobj = 0;
17210 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17211 void *argp1 = 0 ;
17212 int res1 = 0 ;
17213 PyObject * obj0 = 0 ;
17214 char * kwnames[] = {
17215 (char *) "handler", NULL
17216 };
17217
17218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17220 if (!SWIG_IsOK(res1)) {
17221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17222 }
17223 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17224 {
17225 PyThreadState* __tstate = wxPyBeginAllowThreads();
17226 wxImage::AddHandler(arg1);
17227 wxPyEndAllowThreads(__tstate);
17228 if (PyErr_Occurred()) SWIG_fail;
17229 }
17230 resultobj = SWIG_Py_Void();
17231 return resultobj;
17232 fail:
17233 return NULL;
17234 }
17235
17236
17237 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17238 PyObject *resultobj = 0;
17239 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17240 void *argp1 = 0 ;
17241 int res1 = 0 ;
17242 PyObject * obj0 = 0 ;
17243 char * kwnames[] = {
17244 (char *) "handler", NULL
17245 };
17246
17247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17249 if (!SWIG_IsOK(res1)) {
17250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17251 }
17252 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17253 {
17254 PyThreadState* __tstate = wxPyBeginAllowThreads();
17255 wxImage::InsertHandler(arg1);
17256 wxPyEndAllowThreads(__tstate);
17257 if (PyErr_Occurred()) SWIG_fail;
17258 }
17259 resultobj = SWIG_Py_Void();
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj = 0;
17268 wxString *arg1 = 0 ;
17269 bool result;
17270 bool temp1 = false ;
17271 PyObject * obj0 = 0 ;
17272 char * kwnames[] = {
17273 (char *) "name", NULL
17274 };
17275
17276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17277 {
17278 arg1 = wxString_in_helper(obj0);
17279 if (arg1 == NULL) SWIG_fail;
17280 temp1 = true;
17281 }
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17285 wxPyEndAllowThreads(__tstate);
17286 if (PyErr_Occurred()) SWIG_fail;
17287 }
17288 {
17289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17290 }
17291 {
17292 if (temp1)
17293 delete arg1;
17294 }
17295 return resultobj;
17296 fail:
17297 {
17298 if (temp1)
17299 delete arg1;
17300 }
17301 return NULL;
17302 }
17303
17304
17305 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17306 PyObject *resultobj = 0;
17307 PyObject *result = 0 ;
17308
17309 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17310 {
17311 PyThreadState* __tstate = wxPyBeginAllowThreads();
17312 result = (PyObject *)wxImage_GetHandlers();
17313 wxPyEndAllowThreads(__tstate);
17314 if (PyErr_Occurred()) SWIG_fail;
17315 }
17316 resultobj = result;
17317 return resultobj;
17318 fail:
17319 return NULL;
17320 }
17321
17322
17323 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17324 PyObject *resultobj = 0;
17325 wxString result;
17326
17327 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17328 {
17329 PyThreadState* __tstate = wxPyBeginAllowThreads();
17330 result = wxImage::GetImageExtWildcard();
17331 wxPyEndAllowThreads(__tstate);
17332 if (PyErr_Occurred()) SWIG_fail;
17333 }
17334 {
17335 #if wxUSE_UNICODE
17336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17337 #else
17338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17339 #endif
17340 }
17341 return resultobj;
17342 fail:
17343 return NULL;
17344 }
17345
17346
17347 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17348 PyObject *resultobj = 0;
17349 wxImage *arg1 = (wxImage *) 0 ;
17350 int arg2 = (int) -1 ;
17351 wxBitmap result;
17352 void *argp1 = 0 ;
17353 int res1 = 0 ;
17354 int val2 ;
17355 int ecode2 = 0 ;
17356 PyObject * obj0 = 0 ;
17357 PyObject * obj1 = 0 ;
17358 char * kwnames[] = {
17359 (char *) "self",(char *) "depth", NULL
17360 };
17361
17362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17364 if (!SWIG_IsOK(res1)) {
17365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17366 }
17367 arg1 = reinterpret_cast< wxImage * >(argp1);
17368 if (obj1) {
17369 ecode2 = SWIG_AsVal_int(obj1, &val2);
17370 if (!SWIG_IsOK(ecode2)) {
17371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17372 }
17373 arg2 = static_cast< int >(val2);
17374 }
17375 {
17376 if (!wxPyCheckForApp()) SWIG_fail;
17377 PyThreadState* __tstate = wxPyBeginAllowThreads();
17378 result = wxImage_ConvertToBitmap(arg1,arg2);
17379 wxPyEndAllowThreads(__tstate);
17380 if (PyErr_Occurred()) SWIG_fail;
17381 }
17382 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17383 return resultobj;
17384 fail:
17385 return NULL;
17386 }
17387
17388
17389 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17390 PyObject *resultobj = 0;
17391 wxImage *arg1 = (wxImage *) 0 ;
17392 byte arg2 ;
17393 byte arg3 ;
17394 byte arg4 ;
17395 wxBitmap result;
17396 void *argp1 = 0 ;
17397 int res1 = 0 ;
17398 unsigned char val2 ;
17399 int ecode2 = 0 ;
17400 unsigned char val3 ;
17401 int ecode3 = 0 ;
17402 unsigned char val4 ;
17403 int ecode4 = 0 ;
17404 PyObject * obj0 = 0 ;
17405 PyObject * obj1 = 0 ;
17406 PyObject * obj2 = 0 ;
17407 PyObject * obj3 = 0 ;
17408 char * kwnames[] = {
17409 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17410 };
17411
17412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17414 if (!SWIG_IsOK(res1)) {
17415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17416 }
17417 arg1 = reinterpret_cast< wxImage * >(argp1);
17418 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17419 if (!SWIG_IsOK(ecode2)) {
17420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17421 }
17422 arg2 = static_cast< byte >(val2);
17423 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17424 if (!SWIG_IsOK(ecode3)) {
17425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17426 }
17427 arg3 = static_cast< byte >(val3);
17428 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17429 if (!SWIG_IsOK(ecode4)) {
17430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17431 }
17432 arg4 = static_cast< byte >(val4);
17433 {
17434 if (!wxPyCheckForApp()) SWIG_fail;
17435 PyThreadState* __tstate = wxPyBeginAllowThreads();
17436 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17437 wxPyEndAllowThreads(__tstate);
17438 if (PyErr_Occurred()) SWIG_fail;
17439 }
17440 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17441 return resultobj;
17442 fail:
17443 return NULL;
17444 }
17445
17446
17447 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17448 PyObject *resultobj = 0;
17449 wxImage *arg1 = (wxImage *) 0 ;
17450 double arg2 ;
17451 void *argp1 = 0 ;
17452 int res1 = 0 ;
17453 double val2 ;
17454 int ecode2 = 0 ;
17455 PyObject * obj0 = 0 ;
17456 PyObject * obj1 = 0 ;
17457 char * kwnames[] = {
17458 (char *) "self",(char *) "angle", NULL
17459 };
17460
17461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17463 if (!SWIG_IsOK(res1)) {
17464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17465 }
17466 arg1 = reinterpret_cast< wxImage * >(argp1);
17467 ecode2 = SWIG_AsVal_double(obj1, &val2);
17468 if (!SWIG_IsOK(ecode2)) {
17469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17470 }
17471 arg2 = static_cast< double >(val2);
17472 {
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 (arg1)->RotateHue(arg2);
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 resultobj = SWIG_Py_Void();
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj = 0;
17487 wxImage_RGBValue arg1 ;
17488 wxImage_HSVValue result;
17489 void *argp1 ;
17490 int res1 = 0 ;
17491 PyObject * obj0 = 0 ;
17492 char * kwnames[] = {
17493 (char *) "rgb", NULL
17494 };
17495
17496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17497 {
17498 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17499 if (!SWIG_IsOK(res1)) {
17500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17501 }
17502 if (!argp1) {
17503 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17504 } else {
17505 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17506 arg1 = *temp;
17507 if (SWIG_IsNewObj(res1)) delete temp;
17508 }
17509 }
17510 {
17511 PyThreadState* __tstate = wxPyBeginAllowThreads();
17512 result = wxImage::RGBtoHSV(arg1);
17513 wxPyEndAllowThreads(__tstate);
17514 if (PyErr_Occurred()) SWIG_fail;
17515 }
17516 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17517 return resultobj;
17518 fail:
17519 return NULL;
17520 }
17521
17522
17523 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17524 PyObject *resultobj = 0;
17525 wxImage_HSVValue arg1 ;
17526 wxImage_RGBValue result;
17527 void *argp1 ;
17528 int res1 = 0 ;
17529 PyObject * obj0 = 0 ;
17530 char * kwnames[] = {
17531 (char *) "hsv", NULL
17532 };
17533
17534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17535 {
17536 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17537 if (!SWIG_IsOK(res1)) {
17538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17539 }
17540 if (!argp1) {
17541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17542 } else {
17543 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17544 arg1 = *temp;
17545 if (SWIG_IsNewObj(res1)) delete temp;
17546 }
17547 }
17548 {
17549 PyThreadState* __tstate = wxPyBeginAllowThreads();
17550 result = wxImage::HSVtoRGB(arg1);
17551 wxPyEndAllowThreads(__tstate);
17552 if (PyErr_Occurred()) SWIG_fail;
17553 }
17554 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17555 return resultobj;
17556 fail:
17557 return NULL;
17558 }
17559
17560
17561 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17562 PyObject *obj;
17563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17564 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17565 return SWIG_Py_Void();
17566 }
17567
17568 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17569 return SWIG_Python_InitShadowInstance(args);
17570 }
17571
17572 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17573 PyObject *resultobj = 0;
17574 int arg1 ;
17575 int arg2 ;
17576 buffer arg3 ;
17577 int arg4 ;
17578 buffer arg5 = (buffer) NULL ;
17579 int arg6 = (int) 0 ;
17580 wxImage *result = 0 ;
17581 int val1 ;
17582 int ecode1 = 0 ;
17583 int val2 ;
17584 int ecode2 = 0 ;
17585 Py_ssize_t temp3 ;
17586 Py_ssize_t temp5 ;
17587 PyObject * obj0 = 0 ;
17588 PyObject * obj1 = 0 ;
17589 PyObject * obj2 = 0 ;
17590 PyObject * obj3 = 0 ;
17591 char * kwnames[] = {
17592 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17593 };
17594
17595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17596 ecode1 = SWIG_AsVal_int(obj0, &val1);
17597 if (!SWIG_IsOK(ecode1)) {
17598 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17599 }
17600 arg1 = static_cast< int >(val1);
17601 ecode2 = SWIG_AsVal_int(obj1, &val2);
17602 if (!SWIG_IsOK(ecode2)) {
17603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17604 }
17605 arg2 = static_cast< int >(val2);
17606 {
17607 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17608 arg4 = (int)temp3;
17609 }
17610 if (obj3) {
17611 {
17612 if (obj3 != Py_None) {
17613 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17614 arg6 = (int)temp5;
17615 }
17616 }
17617 }
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17621 wxPyEndAllowThreads(__tstate);
17622 if (PyErr_Occurred()) SWIG_fail;
17623 }
17624 {
17625 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17626 }
17627 return resultobj;
17628 fail:
17629 return NULL;
17630 }
17631
17632
17633 SWIGINTERN int NullImage_set(PyObject *) {
17634 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17635 return 1;
17636 }
17637
17638
17639 SWIGINTERN PyObject *NullImage_get(void) {
17640 PyObject *pyobj = 0;
17641
17642 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17643 return pyobj;
17644 }
17645
17646
17647 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17648 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17649 return 1;
17650 }
17651
17652
17653 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17654 PyObject *pyobj = 0;
17655
17656 {
17657 #if wxUSE_UNICODE
17658 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17659 #else
17660 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17661 #endif
17662 }
17663 return pyobj;
17664 }
17665
17666
17667 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17668 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17669 return 1;
17670 }
17671
17672
17673 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17674 PyObject *pyobj = 0;
17675
17676 {
17677 #if wxUSE_UNICODE
17678 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17679 #else
17680 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17681 #endif
17682 }
17683 return pyobj;
17684 }
17685
17686
17687 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17688 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17689 return 1;
17690 }
17691
17692
17693 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17694 PyObject *pyobj = 0;
17695
17696 {
17697 #if wxUSE_UNICODE
17698 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17699 #else
17700 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17701 #endif
17702 }
17703 return pyobj;
17704 }
17705
17706
17707 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17708 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17709 return 1;
17710 }
17711
17712
17713 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17714 PyObject *pyobj = 0;
17715
17716 {
17717 #if wxUSE_UNICODE
17718 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17719 #else
17720 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17721 #endif
17722 }
17723 return pyobj;
17724 }
17725
17726
17727 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17728 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17729 return 1;
17730 }
17731
17732
17733 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17734 PyObject *pyobj = 0;
17735
17736 {
17737 #if wxUSE_UNICODE
17738 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17739 #else
17740 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17741 #endif
17742 }
17743 return pyobj;
17744 }
17745
17746
17747 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17748 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17749 return 1;
17750 }
17751
17752
17753 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17754 PyObject *pyobj = 0;
17755
17756 {
17757 #if wxUSE_UNICODE
17758 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17759 #else
17760 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17761 #endif
17762 }
17763 return pyobj;
17764 }
17765
17766
17767 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17768 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17769 return 1;
17770 }
17771
17772
17773 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17774 PyObject *pyobj = 0;
17775
17776 {
17777 #if wxUSE_UNICODE
17778 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17779 #else
17780 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17781 #endif
17782 }
17783 return pyobj;
17784 }
17785
17786
17787 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17788 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17789 return 1;
17790 }
17791
17792
17793 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17794 PyObject *pyobj = 0;
17795
17796 {
17797 #if wxUSE_UNICODE
17798 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17799 #else
17800 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17801 #endif
17802 }
17803 return pyobj;
17804 }
17805
17806
17807 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17808 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17809 return 1;
17810 }
17811
17812
17813 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17814 PyObject *pyobj = 0;
17815
17816 {
17817 #if wxUSE_UNICODE
17818 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17819 #else
17820 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17821 #endif
17822 }
17823 return pyobj;
17824 }
17825
17826
17827 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17828 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17829 return 1;
17830 }
17831
17832
17833 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17834 PyObject *pyobj = 0;
17835
17836 {
17837 #if wxUSE_UNICODE
17838 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17839 #else
17840 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17841 #endif
17842 }
17843 return pyobj;
17844 }
17845
17846
17847 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17848 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17849 return 1;
17850 }
17851
17852
17853 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17854 PyObject *pyobj = 0;
17855
17856 {
17857 #if wxUSE_UNICODE
17858 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17859 #else
17860 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17861 #endif
17862 }
17863 return pyobj;
17864 }
17865
17866
17867 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17868 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17869 return 1;
17870 }
17871
17872
17873 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17874 PyObject *pyobj = 0;
17875
17876 {
17877 #if wxUSE_UNICODE
17878 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17879 #else
17880 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17881 #endif
17882 }
17883 return pyobj;
17884 }
17885
17886
17887 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17888 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17889 return 1;
17890 }
17891
17892
17893 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17894 PyObject *pyobj = 0;
17895
17896 {
17897 #if wxUSE_UNICODE
17898 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17899 #else
17900 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17901 #endif
17902 }
17903 return pyobj;
17904 }
17905
17906
17907 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17908 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17909 return 1;
17910 }
17911
17912
17913 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17914 PyObject *pyobj = 0;
17915
17916 {
17917 #if wxUSE_UNICODE
17918 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17919 #else
17920 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17921 #endif
17922 }
17923 return pyobj;
17924 }
17925
17926
17927 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17928 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17929 return 1;
17930 }
17931
17932
17933 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17934 PyObject *pyobj = 0;
17935
17936 {
17937 #if wxUSE_UNICODE
17938 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17939 #else
17940 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17941 #endif
17942 }
17943 return pyobj;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17948 PyObject *resultobj = 0;
17949 wxBMPHandler *result = 0 ;
17950
17951 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17952 {
17953 PyThreadState* __tstate = wxPyBeginAllowThreads();
17954 result = (wxBMPHandler *)new wxBMPHandler();
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17966 PyObject *obj;
17967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17968 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17969 return SWIG_Py_Void();
17970 }
17971
17972 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17973 return SWIG_Python_InitShadowInstance(args);
17974 }
17975
17976 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17977 PyObject *resultobj = 0;
17978 wxICOHandler *result = 0 ;
17979
17980 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 result = (wxICOHandler *)new wxICOHandler();
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 PyObject *obj;
17996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17997 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17998 return SWIG_Py_Void();
17999 }
18000
18001 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18002 return SWIG_Python_InitShadowInstance(args);
18003 }
18004
18005 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18006 PyObject *resultobj = 0;
18007 wxCURHandler *result = 0 ;
18008
18009 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 result = (wxCURHandler *)new wxCURHandler();
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18024 PyObject *obj;
18025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18026 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18027 return SWIG_Py_Void();
18028 }
18029
18030 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18031 return SWIG_Python_InitShadowInstance(args);
18032 }
18033
18034 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18035 PyObject *resultobj = 0;
18036 wxANIHandler *result = 0 ;
18037
18038 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18039 {
18040 PyThreadState* __tstate = wxPyBeginAllowThreads();
18041 result = (wxANIHandler *)new wxANIHandler();
18042 wxPyEndAllowThreads(__tstate);
18043 if (PyErr_Occurred()) SWIG_fail;
18044 }
18045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18046 return resultobj;
18047 fail:
18048 return NULL;
18049 }
18050
18051
18052 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18053 PyObject *obj;
18054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18055 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18056 return SWIG_Py_Void();
18057 }
18058
18059 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18060 return SWIG_Python_InitShadowInstance(args);
18061 }
18062
18063 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18064 PyObject *resultobj = 0;
18065 wxPNGHandler *result = 0 ;
18066
18067 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18068 {
18069 PyThreadState* __tstate = wxPyBeginAllowThreads();
18070 result = (wxPNGHandler *)new wxPNGHandler();
18071 wxPyEndAllowThreads(__tstate);
18072 if (PyErr_Occurred()) SWIG_fail;
18073 }
18074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18075 return resultobj;
18076 fail:
18077 return NULL;
18078 }
18079
18080
18081 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18082 PyObject *obj;
18083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18084 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18085 return SWIG_Py_Void();
18086 }
18087
18088 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18089 return SWIG_Python_InitShadowInstance(args);
18090 }
18091
18092 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18093 PyObject *resultobj = 0;
18094 wxGIFHandler *result = 0 ;
18095
18096 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18097 {
18098 PyThreadState* __tstate = wxPyBeginAllowThreads();
18099 result = (wxGIFHandler *)new wxGIFHandler();
18100 wxPyEndAllowThreads(__tstate);
18101 if (PyErr_Occurred()) SWIG_fail;
18102 }
18103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18104 return resultobj;
18105 fail:
18106 return NULL;
18107 }
18108
18109
18110 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18111 PyObject *obj;
18112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18113 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18114 return SWIG_Py_Void();
18115 }
18116
18117 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18118 return SWIG_Python_InitShadowInstance(args);
18119 }
18120
18121 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18122 PyObject *resultobj = 0;
18123 wxPCXHandler *result = 0 ;
18124
18125 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18126 {
18127 PyThreadState* __tstate = wxPyBeginAllowThreads();
18128 result = (wxPCXHandler *)new wxPCXHandler();
18129 wxPyEndAllowThreads(__tstate);
18130 if (PyErr_Occurred()) SWIG_fail;
18131 }
18132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18133 return resultobj;
18134 fail:
18135 return NULL;
18136 }
18137
18138
18139 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18140 PyObject *obj;
18141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18142 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18143 return SWIG_Py_Void();
18144 }
18145
18146 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 return SWIG_Python_InitShadowInstance(args);
18148 }
18149
18150 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18151 PyObject *resultobj = 0;
18152 wxJPEGHandler *result = 0 ;
18153
18154 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18155 {
18156 PyThreadState* __tstate = wxPyBeginAllowThreads();
18157 result = (wxJPEGHandler *)new wxJPEGHandler();
18158 wxPyEndAllowThreads(__tstate);
18159 if (PyErr_Occurred()) SWIG_fail;
18160 }
18161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18162 return resultobj;
18163 fail:
18164 return NULL;
18165 }
18166
18167
18168 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18169 PyObject *obj;
18170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18171 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18172 return SWIG_Py_Void();
18173 }
18174
18175 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18176 return SWIG_Python_InitShadowInstance(args);
18177 }
18178
18179 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18180 PyObject *resultobj = 0;
18181 wxPNMHandler *result = 0 ;
18182
18183 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18184 {
18185 PyThreadState* __tstate = wxPyBeginAllowThreads();
18186 result = (wxPNMHandler *)new wxPNMHandler();
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18198 PyObject *obj;
18199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18200 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18201 return SWIG_Py_Void();
18202 }
18203
18204 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18205 return SWIG_Python_InitShadowInstance(args);
18206 }
18207
18208 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18209 PyObject *resultobj = 0;
18210 wxXPMHandler *result = 0 ;
18211
18212 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 result = (wxXPMHandler *)new wxXPMHandler();
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18220 return resultobj;
18221 fail:
18222 return NULL;
18223 }
18224
18225
18226 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18227 PyObject *obj;
18228 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18229 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18230 return SWIG_Py_Void();
18231 }
18232
18233 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18234 return SWIG_Python_InitShadowInstance(args);
18235 }
18236
18237 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18238 PyObject *resultobj = 0;
18239 wxTIFFHandler *result = 0 ;
18240
18241 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18242 {
18243 PyThreadState* __tstate = wxPyBeginAllowThreads();
18244 result = (wxTIFFHandler *)new wxTIFFHandler();
18245 wxPyEndAllowThreads(__tstate);
18246 if (PyErr_Occurred()) SWIG_fail;
18247 }
18248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18249 return resultobj;
18250 fail:
18251 return NULL;
18252 }
18253
18254
18255 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18256 PyObject *obj;
18257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18258 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18259 return SWIG_Py_Void();
18260 }
18261
18262 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18263 return SWIG_Python_InitShadowInstance(args);
18264 }
18265
18266 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18267 PyObject *resultobj = 0;
18268 wxImage *arg1 = 0 ;
18269 wxImage *arg2 = 0 ;
18270 int arg3 = (int) 236 ;
18271 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18272 bool result;
18273 void *argp1 = 0 ;
18274 int res1 = 0 ;
18275 void *argp2 = 0 ;
18276 int res2 = 0 ;
18277 int val3 ;
18278 int ecode3 = 0 ;
18279 int val4 ;
18280 int ecode4 = 0 ;
18281 PyObject * obj0 = 0 ;
18282 PyObject * obj1 = 0 ;
18283 PyObject * obj2 = 0 ;
18284 PyObject * obj3 = 0 ;
18285 char * kwnames[] = {
18286 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18287 };
18288
18289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18290 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18291 if (!SWIG_IsOK(res1)) {
18292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18293 }
18294 if (!argp1) {
18295 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18296 }
18297 arg1 = reinterpret_cast< wxImage * >(argp1);
18298 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18299 if (!SWIG_IsOK(res2)) {
18300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18301 }
18302 if (!argp2) {
18303 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18304 }
18305 arg2 = reinterpret_cast< wxImage * >(argp2);
18306 if (obj2) {
18307 ecode3 = SWIG_AsVal_int(obj2, &val3);
18308 if (!SWIG_IsOK(ecode3)) {
18309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18310 }
18311 arg3 = static_cast< int >(val3);
18312 }
18313 if (obj3) {
18314 ecode4 = SWIG_AsVal_int(obj3, &val4);
18315 if (!SWIG_IsOK(ecode4)) {
18316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18317 }
18318 arg4 = static_cast< int >(val4);
18319 }
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18323 wxPyEndAllowThreads(__tstate);
18324 if (PyErr_Occurred()) SWIG_fail;
18325 }
18326 {
18327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18328 }
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18336 PyObject *obj;
18337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18338 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18339 return SWIG_Py_Void();
18340 }
18341
18342 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18343 PyObject *resultobj = 0;
18344 wxEvtHandler *result = 0 ;
18345
18346 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18347 {
18348 PyThreadState* __tstate = wxPyBeginAllowThreads();
18349 result = (wxEvtHandler *)new wxEvtHandler();
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18354 return resultobj;
18355 fail:
18356 return NULL;
18357 }
18358
18359
18360 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18361 PyObject *resultobj = 0;
18362 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18363 wxEvtHandler *result = 0 ;
18364 void *argp1 = 0 ;
18365 int res1 = 0 ;
18366 PyObject *swig_obj[1] ;
18367
18368 if (!args) SWIG_fail;
18369 swig_obj[0] = args;
18370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18371 if (!SWIG_IsOK(res1)) {
18372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18373 }
18374 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18375 {
18376 PyThreadState* __tstate = wxPyBeginAllowThreads();
18377 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 {
18382 resultobj = wxPyMake_wxObject(result, 0);
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18391 PyObject *resultobj = 0;
18392 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18393 wxEvtHandler *result = 0 ;
18394 void *argp1 = 0 ;
18395 int res1 = 0 ;
18396 PyObject *swig_obj[1] ;
18397
18398 if (!args) SWIG_fail;
18399 swig_obj[0] = args;
18400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18401 if (!SWIG_IsOK(res1)) {
18402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18403 }
18404 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 {
18412 resultobj = wxPyMake_wxObject(result, 0);
18413 }
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18421 PyObject *resultobj = 0;
18422 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18423 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18424 void *argp1 = 0 ;
18425 int res1 = 0 ;
18426 void *argp2 = 0 ;
18427 int res2 = 0 ;
18428 PyObject * obj0 = 0 ;
18429 PyObject * obj1 = 0 ;
18430 char * kwnames[] = {
18431 (char *) "self",(char *) "handler", NULL
18432 };
18433
18434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18436 if (!SWIG_IsOK(res1)) {
18437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18438 }
18439 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18440 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18441 if (!SWIG_IsOK(res2)) {
18442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18443 }
18444 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18445 {
18446 PyThreadState* __tstate = wxPyBeginAllowThreads();
18447 (arg1)->SetNextHandler(arg2);
18448 wxPyEndAllowThreads(__tstate);
18449 if (PyErr_Occurred()) SWIG_fail;
18450 }
18451 resultobj = SWIG_Py_Void();
18452 return resultobj;
18453 fail:
18454 return NULL;
18455 }
18456
18457
18458 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18459 PyObject *resultobj = 0;
18460 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18461 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18462 void *argp1 = 0 ;
18463 int res1 = 0 ;
18464 void *argp2 = 0 ;
18465 int res2 = 0 ;
18466 PyObject * obj0 = 0 ;
18467 PyObject * obj1 = 0 ;
18468 char * kwnames[] = {
18469 (char *) "self",(char *) "handler", NULL
18470 };
18471
18472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18474 if (!SWIG_IsOK(res1)) {
18475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18476 }
18477 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18478 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18479 if (!SWIG_IsOK(res2)) {
18480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18481 }
18482 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18483 {
18484 PyThreadState* __tstate = wxPyBeginAllowThreads();
18485 (arg1)->SetPreviousHandler(arg2);
18486 wxPyEndAllowThreads(__tstate);
18487 if (PyErr_Occurred()) SWIG_fail;
18488 }
18489 resultobj = SWIG_Py_Void();
18490 return resultobj;
18491 fail:
18492 return NULL;
18493 }
18494
18495
18496 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18497 PyObject *resultobj = 0;
18498 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18499 bool result;
18500 void *argp1 = 0 ;
18501 int res1 = 0 ;
18502 PyObject *swig_obj[1] ;
18503
18504 if (!args) SWIG_fail;
18505 swig_obj[0] = args;
18506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18507 if (!SWIG_IsOK(res1)) {
18508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18509 }
18510 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18511 {
18512 PyThreadState* __tstate = wxPyBeginAllowThreads();
18513 result = (bool)(arg1)->GetEvtHandlerEnabled();
18514 wxPyEndAllowThreads(__tstate);
18515 if (PyErr_Occurred()) SWIG_fail;
18516 }
18517 {
18518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18519 }
18520 return resultobj;
18521 fail:
18522 return NULL;
18523 }
18524
18525
18526 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18527 PyObject *resultobj = 0;
18528 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18529 bool arg2 ;
18530 void *argp1 = 0 ;
18531 int res1 = 0 ;
18532 bool val2 ;
18533 int ecode2 = 0 ;
18534 PyObject * obj0 = 0 ;
18535 PyObject * obj1 = 0 ;
18536 char * kwnames[] = {
18537 (char *) "self",(char *) "enabled", NULL
18538 };
18539
18540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18542 if (!SWIG_IsOK(res1)) {
18543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18544 }
18545 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18546 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18547 if (!SWIG_IsOK(ecode2)) {
18548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18549 }
18550 arg2 = static_cast< bool >(val2);
18551 {
18552 PyThreadState* __tstate = wxPyBeginAllowThreads();
18553 (arg1)->SetEvtHandlerEnabled(arg2);
18554 wxPyEndAllowThreads(__tstate);
18555 if (PyErr_Occurred()) SWIG_fail;
18556 }
18557 resultobj = SWIG_Py_Void();
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18565 PyObject *resultobj = 0;
18566 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18567 wxEvent *arg2 = 0 ;
18568 bool result;
18569 void *argp1 = 0 ;
18570 int res1 = 0 ;
18571 void *argp2 = 0 ;
18572 int res2 = 0 ;
18573 PyObject * obj0 = 0 ;
18574 PyObject * obj1 = 0 ;
18575 char * kwnames[] = {
18576 (char *) "self",(char *) "event", NULL
18577 };
18578
18579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18581 if (!SWIG_IsOK(res1)) {
18582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18583 }
18584 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18585 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18586 if (!SWIG_IsOK(res2)) {
18587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18588 }
18589 if (!argp2) {
18590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18591 }
18592 arg2 = reinterpret_cast< wxEvent * >(argp2);
18593 {
18594 PyThreadState* __tstate = wxPyBeginAllowThreads();
18595 result = (bool)(arg1)->ProcessEvent(*arg2);
18596 wxPyEndAllowThreads(__tstate);
18597 if (PyErr_Occurred()) SWIG_fail;
18598 }
18599 {
18600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18601 }
18602 return resultobj;
18603 fail:
18604 return NULL;
18605 }
18606
18607
18608 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj = 0;
18610 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18611 wxEvent *arg2 = 0 ;
18612 void *argp1 = 0 ;
18613 int res1 = 0 ;
18614 void *argp2 = 0 ;
18615 int res2 = 0 ;
18616 PyObject * obj0 = 0 ;
18617 PyObject * obj1 = 0 ;
18618 char * kwnames[] = {
18619 (char *) "self",(char *) "event", NULL
18620 };
18621
18622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18624 if (!SWIG_IsOK(res1)) {
18625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18626 }
18627 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18628 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18629 if (!SWIG_IsOK(res2)) {
18630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18631 }
18632 if (!argp2) {
18633 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18634 }
18635 arg2 = reinterpret_cast< wxEvent * >(argp2);
18636 {
18637 PyThreadState* __tstate = wxPyBeginAllowThreads();
18638 (arg1)->AddPendingEvent(*arg2);
18639 wxPyEndAllowThreads(__tstate);
18640 if (PyErr_Occurred()) SWIG_fail;
18641 }
18642 resultobj = SWIG_Py_Void();
18643 return resultobj;
18644 fail:
18645 return NULL;
18646 }
18647
18648
18649 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18650 PyObject *resultobj = 0;
18651 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18652 void *argp1 = 0 ;
18653 int res1 = 0 ;
18654 PyObject *swig_obj[1] ;
18655
18656 if (!args) SWIG_fail;
18657 swig_obj[0] = args;
18658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18659 if (!SWIG_IsOK(res1)) {
18660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18661 }
18662 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18663 {
18664 PyThreadState* __tstate = wxPyBeginAllowThreads();
18665 (arg1)->ProcessPendingEvents();
18666 wxPyEndAllowThreads(__tstate);
18667 if (PyErr_Occurred()) SWIG_fail;
18668 }
18669 resultobj = SWIG_Py_Void();
18670 return resultobj;
18671 fail:
18672 return NULL;
18673 }
18674
18675
18676 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18677 PyObject *resultobj = 0;
18678 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18679 int arg2 ;
18680 int arg3 ;
18681 int arg4 ;
18682 PyObject *arg5 = (PyObject *) 0 ;
18683 void *argp1 = 0 ;
18684 int res1 = 0 ;
18685 int val2 ;
18686 int ecode2 = 0 ;
18687 int val3 ;
18688 int ecode3 = 0 ;
18689 int val4 ;
18690 int ecode4 = 0 ;
18691 PyObject * obj0 = 0 ;
18692 PyObject * obj1 = 0 ;
18693 PyObject * obj2 = 0 ;
18694 PyObject * obj3 = 0 ;
18695 PyObject * obj4 = 0 ;
18696 char * kwnames[] = {
18697 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18698 };
18699
18700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18702 if (!SWIG_IsOK(res1)) {
18703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18704 }
18705 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18706 ecode2 = SWIG_AsVal_int(obj1, &val2);
18707 if (!SWIG_IsOK(ecode2)) {
18708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18709 }
18710 arg2 = static_cast< int >(val2);
18711 ecode3 = SWIG_AsVal_int(obj2, &val3);
18712 if (!SWIG_IsOK(ecode3)) {
18713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18714 }
18715 arg3 = static_cast< int >(val3);
18716 ecode4 = SWIG_AsVal_int(obj3, &val4);
18717 if (!SWIG_IsOK(ecode4)) {
18718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18719 }
18720 arg4 = static_cast< int >(val4);
18721 arg5 = obj4;
18722 {
18723 PyThreadState* __tstate = wxPyBeginAllowThreads();
18724 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 resultobj = SWIG_Py_Void();
18729 return resultobj;
18730 fail:
18731 return NULL;
18732 }
18733
18734
18735 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18736 PyObject *resultobj = 0;
18737 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18738 int arg2 ;
18739 int arg3 = (int) -1 ;
18740 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18741 bool result;
18742 void *argp1 = 0 ;
18743 int res1 = 0 ;
18744 int val2 ;
18745 int ecode2 = 0 ;
18746 int val3 ;
18747 int ecode3 = 0 ;
18748 int val4 ;
18749 int ecode4 = 0 ;
18750 PyObject * obj0 = 0 ;
18751 PyObject * obj1 = 0 ;
18752 PyObject * obj2 = 0 ;
18753 PyObject * obj3 = 0 ;
18754 char * kwnames[] = {
18755 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18756 };
18757
18758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18760 if (!SWIG_IsOK(res1)) {
18761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18762 }
18763 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18764 ecode2 = SWIG_AsVal_int(obj1, &val2);
18765 if (!SWIG_IsOK(ecode2)) {
18766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18767 }
18768 arg2 = static_cast< int >(val2);
18769 if (obj2) {
18770 ecode3 = SWIG_AsVal_int(obj2, &val3);
18771 if (!SWIG_IsOK(ecode3)) {
18772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18773 }
18774 arg3 = static_cast< int >(val3);
18775 }
18776 if (obj3) {
18777 ecode4 = SWIG_AsVal_int(obj3, &val4);
18778 if (!SWIG_IsOK(ecode4)) {
18779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18780 }
18781 arg4 = static_cast< wxEventType >(val4);
18782 }
18783 {
18784 PyThreadState* __tstate = wxPyBeginAllowThreads();
18785 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18786 wxPyEndAllowThreads(__tstate);
18787 if (PyErr_Occurred()) SWIG_fail;
18788 }
18789 {
18790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18791 }
18792 return resultobj;
18793 fail:
18794 return NULL;
18795 }
18796
18797
18798 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj = 0;
18800 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18801 PyObject *arg2 = (PyObject *) 0 ;
18802 bool arg3 = (bool) true ;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 bool val3 ;
18806 int ecode3 = 0 ;
18807 PyObject * obj0 = 0 ;
18808 PyObject * obj1 = 0 ;
18809 PyObject * obj2 = 0 ;
18810 char * kwnames[] = {
18811 (char *) "self",(char *) "_self",(char *) "incref", NULL
18812 };
18813
18814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18816 if (!SWIG_IsOK(res1)) {
18817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18818 }
18819 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18820 arg2 = obj1;
18821 if (obj2) {
18822 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18823 if (!SWIG_IsOK(ecode3)) {
18824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18825 }
18826 arg3 = static_cast< bool >(val3);
18827 }
18828 {
18829 PyThreadState* __tstate = wxPyBeginAllowThreads();
18830 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18831 wxPyEndAllowThreads(__tstate);
18832 if (PyErr_Occurred()) SWIG_fail;
18833 }
18834 resultobj = SWIG_Py_Void();
18835 return resultobj;
18836 fail:
18837 return NULL;
18838 }
18839
18840
18841 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18842 PyObject *obj;
18843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18844 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18845 return SWIG_Py_Void();
18846 }
18847
18848 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18849 return SWIG_Python_InitShadowInstance(args);
18850 }
18851
18852 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18853 PyObject *resultobj = 0;
18854 wxEventType result;
18855
18856 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18857 {
18858 PyThreadState* __tstate = wxPyBeginAllowThreads();
18859 result = (wxEventType)wxNewEventType();
18860 wxPyEndAllowThreads(__tstate);
18861 if (PyErr_Occurred()) SWIG_fail;
18862 }
18863 resultobj = SWIG_From_int(static_cast< int >(result));
18864 return resultobj;
18865 fail:
18866 return NULL;
18867 }
18868
18869
18870 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18871 PyObject *resultobj = 0;
18872 wxEvent *arg1 = (wxEvent *) 0 ;
18873 void *argp1 = 0 ;
18874 int res1 = 0 ;
18875 PyObject *swig_obj[1] ;
18876
18877 if (!args) SWIG_fail;
18878 swig_obj[0] = args;
18879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18880 if (!SWIG_IsOK(res1)) {
18881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18882 }
18883 arg1 = reinterpret_cast< wxEvent * >(argp1);
18884 {
18885 PyThreadState* __tstate = wxPyBeginAllowThreads();
18886 delete arg1;
18887
18888 wxPyEndAllowThreads(__tstate);
18889 if (PyErr_Occurred()) SWIG_fail;
18890 }
18891 resultobj = SWIG_Py_Void();
18892 return resultobj;
18893 fail:
18894 return NULL;
18895 }
18896
18897
18898 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj = 0;
18900 wxEvent *arg1 = (wxEvent *) 0 ;
18901 wxEventType arg2 ;
18902 void *argp1 = 0 ;
18903 int res1 = 0 ;
18904 int val2 ;
18905 int ecode2 = 0 ;
18906 PyObject * obj0 = 0 ;
18907 PyObject * obj1 = 0 ;
18908 char * kwnames[] = {
18909 (char *) "self",(char *) "typ", NULL
18910 };
18911
18912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18914 if (!SWIG_IsOK(res1)) {
18915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18916 }
18917 arg1 = reinterpret_cast< wxEvent * >(argp1);
18918 ecode2 = SWIG_AsVal_int(obj1, &val2);
18919 if (!SWIG_IsOK(ecode2)) {
18920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18921 }
18922 arg2 = static_cast< wxEventType >(val2);
18923 {
18924 PyThreadState* __tstate = wxPyBeginAllowThreads();
18925 (arg1)->SetEventType(arg2);
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 resultobj = SWIG_Py_Void();
18930 return resultobj;
18931 fail:
18932 return NULL;
18933 }
18934
18935
18936 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18937 PyObject *resultobj = 0;
18938 wxEvent *arg1 = (wxEvent *) 0 ;
18939 wxEventType result;
18940 void *argp1 = 0 ;
18941 int res1 = 0 ;
18942 PyObject *swig_obj[1] ;
18943
18944 if (!args) SWIG_fail;
18945 swig_obj[0] = args;
18946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18947 if (!SWIG_IsOK(res1)) {
18948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18949 }
18950 arg1 = reinterpret_cast< wxEvent * >(argp1);
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 resultobj = SWIG_From_int(static_cast< int >(result));
18958 return resultobj;
18959 fail:
18960 return NULL;
18961 }
18962
18963
18964 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18965 PyObject *resultobj = 0;
18966 wxEvent *arg1 = (wxEvent *) 0 ;
18967 wxObject *result = 0 ;
18968 void *argp1 = 0 ;
18969 int res1 = 0 ;
18970 PyObject *swig_obj[1] ;
18971
18972 if (!args) SWIG_fail;
18973 swig_obj[0] = args;
18974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18975 if (!SWIG_IsOK(res1)) {
18976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18977 }
18978 arg1 = reinterpret_cast< wxEvent * >(argp1);
18979 {
18980 PyThreadState* __tstate = wxPyBeginAllowThreads();
18981 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18982 wxPyEndAllowThreads(__tstate);
18983 if (PyErr_Occurred()) SWIG_fail;
18984 }
18985 {
18986 resultobj = wxPyMake_wxObject(result, (bool)0);
18987 }
18988 return resultobj;
18989 fail:
18990 return NULL;
18991 }
18992
18993
18994 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj = 0;
18996 wxEvent *arg1 = (wxEvent *) 0 ;
18997 wxObject *arg2 = (wxObject *) 0 ;
18998 void *argp1 = 0 ;
18999 int res1 = 0 ;
19000 void *argp2 = 0 ;
19001 int res2 = 0 ;
19002 PyObject * obj0 = 0 ;
19003 PyObject * obj1 = 0 ;
19004 char * kwnames[] = {
19005 (char *) "self",(char *) "obj", NULL
19006 };
19007
19008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19010 if (!SWIG_IsOK(res1)) {
19011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19012 }
19013 arg1 = reinterpret_cast< wxEvent * >(argp1);
19014 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19015 if (!SWIG_IsOK(res2)) {
19016 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19017 }
19018 arg2 = reinterpret_cast< wxObject * >(argp2);
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 (arg1)->SetEventObject(arg2);
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 resultobj = SWIG_Py_Void();
19026 return resultobj;
19027 fail:
19028 return NULL;
19029 }
19030
19031
19032 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19033 PyObject *resultobj = 0;
19034 wxEvent *arg1 = (wxEvent *) 0 ;
19035 long result;
19036 void *argp1 = 0 ;
19037 int res1 = 0 ;
19038 PyObject *swig_obj[1] ;
19039
19040 if (!args) SWIG_fail;
19041 swig_obj[0] = args;
19042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19043 if (!SWIG_IsOK(res1)) {
19044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19045 }
19046 arg1 = reinterpret_cast< wxEvent * >(argp1);
19047 {
19048 PyThreadState* __tstate = wxPyBeginAllowThreads();
19049 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19050 wxPyEndAllowThreads(__tstate);
19051 if (PyErr_Occurred()) SWIG_fail;
19052 }
19053 resultobj = SWIG_From_long(static_cast< long >(result));
19054 return resultobj;
19055 fail:
19056 return NULL;
19057 }
19058
19059
19060 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19061 PyObject *resultobj = 0;
19062 wxEvent *arg1 = (wxEvent *) 0 ;
19063 long arg2 = (long) 0 ;
19064 void *argp1 = 0 ;
19065 int res1 = 0 ;
19066 long val2 ;
19067 int ecode2 = 0 ;
19068 PyObject * obj0 = 0 ;
19069 PyObject * obj1 = 0 ;
19070 char * kwnames[] = {
19071 (char *) "self",(char *) "ts", NULL
19072 };
19073
19074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19076 if (!SWIG_IsOK(res1)) {
19077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19078 }
19079 arg1 = reinterpret_cast< wxEvent * >(argp1);
19080 if (obj1) {
19081 ecode2 = SWIG_AsVal_long(obj1, &val2);
19082 if (!SWIG_IsOK(ecode2)) {
19083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19084 }
19085 arg2 = static_cast< long >(val2);
19086 }
19087 {
19088 PyThreadState* __tstate = wxPyBeginAllowThreads();
19089 (arg1)->SetTimestamp(arg2);
19090 wxPyEndAllowThreads(__tstate);
19091 if (PyErr_Occurred()) SWIG_fail;
19092 }
19093 resultobj = SWIG_Py_Void();
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19101 PyObject *resultobj = 0;
19102 wxEvent *arg1 = (wxEvent *) 0 ;
19103 int result;
19104 void *argp1 = 0 ;
19105 int res1 = 0 ;
19106 PyObject *swig_obj[1] ;
19107
19108 if (!args) SWIG_fail;
19109 swig_obj[0] = args;
19110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19111 if (!SWIG_IsOK(res1)) {
19112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19113 }
19114 arg1 = reinterpret_cast< wxEvent * >(argp1);
19115 {
19116 PyThreadState* __tstate = wxPyBeginAllowThreads();
19117 result = (int)((wxEvent const *)arg1)->GetId();
19118 wxPyEndAllowThreads(__tstate);
19119 if (PyErr_Occurred()) SWIG_fail;
19120 }
19121 resultobj = SWIG_From_int(static_cast< int >(result));
19122 return resultobj;
19123 fail:
19124 return NULL;
19125 }
19126
19127
19128 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19129 PyObject *resultobj = 0;
19130 wxEvent *arg1 = (wxEvent *) 0 ;
19131 int arg2 ;
19132 void *argp1 = 0 ;
19133 int res1 = 0 ;
19134 int val2 ;
19135 int ecode2 = 0 ;
19136 PyObject * obj0 = 0 ;
19137 PyObject * obj1 = 0 ;
19138 char * kwnames[] = {
19139 (char *) "self",(char *) "Id", NULL
19140 };
19141
19142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19144 if (!SWIG_IsOK(res1)) {
19145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19146 }
19147 arg1 = reinterpret_cast< wxEvent * >(argp1);
19148 ecode2 = SWIG_AsVal_int(obj1, &val2);
19149 if (!SWIG_IsOK(ecode2)) {
19150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19151 }
19152 arg2 = static_cast< int >(val2);
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 (arg1)->SetId(arg2);
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 resultobj = SWIG_Py_Void();
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19167 PyObject *resultobj = 0;
19168 wxEvent *arg1 = (wxEvent *) 0 ;
19169 bool result;
19170 void *argp1 = 0 ;
19171 int res1 = 0 ;
19172 PyObject *swig_obj[1] ;
19173
19174 if (!args) SWIG_fail;
19175 swig_obj[0] = args;
19176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19177 if (!SWIG_IsOK(res1)) {
19178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19179 }
19180 arg1 = reinterpret_cast< wxEvent * >(argp1);
19181 {
19182 PyThreadState* __tstate = wxPyBeginAllowThreads();
19183 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19184 wxPyEndAllowThreads(__tstate);
19185 if (PyErr_Occurred()) SWIG_fail;
19186 }
19187 {
19188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19189 }
19190 return resultobj;
19191 fail:
19192 return NULL;
19193 }
19194
19195
19196 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19197 PyObject *resultobj = 0;
19198 wxEvent *arg1 = (wxEvent *) 0 ;
19199 bool arg2 = (bool) true ;
19200 void *argp1 = 0 ;
19201 int res1 = 0 ;
19202 bool val2 ;
19203 int ecode2 = 0 ;
19204 PyObject * obj0 = 0 ;
19205 PyObject * obj1 = 0 ;
19206 char * kwnames[] = {
19207 (char *) "self",(char *) "skip", NULL
19208 };
19209
19210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19214 }
19215 arg1 = reinterpret_cast< wxEvent * >(argp1);
19216 if (obj1) {
19217 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19218 if (!SWIG_IsOK(ecode2)) {
19219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19220 }
19221 arg2 = static_cast< bool >(val2);
19222 }
19223 {
19224 PyThreadState* __tstate = wxPyBeginAllowThreads();
19225 (arg1)->Skip(arg2);
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 resultobj = SWIG_Py_Void();
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19237 PyObject *resultobj = 0;
19238 wxEvent *arg1 = (wxEvent *) 0 ;
19239 bool result;
19240 void *argp1 = 0 ;
19241 int res1 = 0 ;
19242 PyObject *swig_obj[1] ;
19243
19244 if (!args) SWIG_fail;
19245 swig_obj[0] = args;
19246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19247 if (!SWIG_IsOK(res1)) {
19248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19249 }
19250 arg1 = reinterpret_cast< wxEvent * >(argp1);
19251 {
19252 PyThreadState* __tstate = wxPyBeginAllowThreads();
19253 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 {
19258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19259 }
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19267 PyObject *resultobj = 0;
19268 wxEvent *arg1 = (wxEvent *) 0 ;
19269 bool result;
19270 void *argp1 = 0 ;
19271 int res1 = 0 ;
19272 PyObject *swig_obj[1] ;
19273
19274 if (!args) SWIG_fail;
19275 swig_obj[0] = args;
19276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19277 if (!SWIG_IsOK(res1)) {
19278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19279 }
19280 arg1 = reinterpret_cast< wxEvent * >(argp1);
19281 {
19282 PyThreadState* __tstate = wxPyBeginAllowThreads();
19283 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19284 wxPyEndAllowThreads(__tstate);
19285 if (PyErr_Occurred()) SWIG_fail;
19286 }
19287 {
19288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19289 }
19290 return resultobj;
19291 fail:
19292 return NULL;
19293 }
19294
19295
19296 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19297 PyObject *resultobj = 0;
19298 wxEvent *arg1 = (wxEvent *) 0 ;
19299 int result;
19300 void *argp1 = 0 ;
19301 int res1 = 0 ;
19302 PyObject *swig_obj[1] ;
19303
19304 if (!args) SWIG_fail;
19305 swig_obj[0] = args;
19306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19307 if (!SWIG_IsOK(res1)) {
19308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19309 }
19310 arg1 = reinterpret_cast< wxEvent * >(argp1);
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 result = (int)(arg1)->StopPropagation();
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 resultobj = SWIG_From_int(static_cast< int >(result));
19318 return resultobj;
19319 fail:
19320 return NULL;
19321 }
19322
19323
19324 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19325 PyObject *resultobj = 0;
19326 wxEvent *arg1 = (wxEvent *) 0 ;
19327 int arg2 ;
19328 void *argp1 = 0 ;
19329 int res1 = 0 ;
19330 int val2 ;
19331 int ecode2 = 0 ;
19332 PyObject * obj0 = 0 ;
19333 PyObject * obj1 = 0 ;
19334 char * kwnames[] = {
19335 (char *) "self",(char *) "propagationLevel", NULL
19336 };
19337
19338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19340 if (!SWIG_IsOK(res1)) {
19341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19342 }
19343 arg1 = reinterpret_cast< wxEvent * >(argp1);
19344 ecode2 = SWIG_AsVal_int(obj1, &val2);
19345 if (!SWIG_IsOK(ecode2)) {
19346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19347 }
19348 arg2 = static_cast< int >(val2);
19349 {
19350 PyThreadState* __tstate = wxPyBeginAllowThreads();
19351 (arg1)->ResumePropagation(arg2);
19352 wxPyEndAllowThreads(__tstate);
19353 if (PyErr_Occurred()) SWIG_fail;
19354 }
19355 resultobj = SWIG_Py_Void();
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19363 PyObject *resultobj = 0;
19364 wxEvent *arg1 = (wxEvent *) 0 ;
19365 wxEvent *result = 0 ;
19366 void *argp1 = 0 ;
19367 int res1 = 0 ;
19368 PyObject *swig_obj[1] ;
19369
19370 if (!args) SWIG_fail;
19371 swig_obj[0] = args;
19372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19373 if (!SWIG_IsOK(res1)) {
19374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19375 }
19376 arg1 = reinterpret_cast< wxEvent * >(argp1);
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (wxEvent *)(arg1)->Clone();
19380 wxPyEndAllowThreads(__tstate);
19381 if (PyErr_Occurred()) SWIG_fail;
19382 }
19383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19384 return resultobj;
19385 fail:
19386 return NULL;
19387 }
19388
19389
19390 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19391 PyObject *obj;
19392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19393 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19394 return SWIG_Py_Void();
19395 }
19396
19397 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19398 PyObject *resultobj = 0;
19399 wxEvent *arg1 = 0 ;
19400 wxPropagationDisabler *result = 0 ;
19401 void *argp1 = 0 ;
19402 int res1 = 0 ;
19403 PyObject * obj0 = 0 ;
19404 char * kwnames[] = {
19405 (char *) "event", NULL
19406 };
19407
19408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19409 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19410 if (!SWIG_IsOK(res1)) {
19411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19412 }
19413 if (!argp1) {
19414 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19415 }
19416 arg1 = reinterpret_cast< wxEvent * >(argp1);
19417 {
19418 PyThreadState* __tstate = wxPyBeginAllowThreads();
19419 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19431 PyObject *resultobj = 0;
19432 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19433 void *argp1 = 0 ;
19434 int res1 = 0 ;
19435 PyObject *swig_obj[1] ;
19436
19437 if (!args) SWIG_fail;
19438 swig_obj[0] = args;
19439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19440 if (!SWIG_IsOK(res1)) {
19441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19442 }
19443 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 delete arg1;
19447
19448 wxPyEndAllowThreads(__tstate);
19449 if (PyErr_Occurred()) SWIG_fail;
19450 }
19451 resultobj = SWIG_Py_Void();
19452 return resultobj;
19453 fail:
19454 return NULL;
19455 }
19456
19457
19458 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19459 PyObject *obj;
19460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19461 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19462 return SWIG_Py_Void();
19463 }
19464
19465 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19466 return SWIG_Python_InitShadowInstance(args);
19467 }
19468
19469 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19470 PyObject *resultobj = 0;
19471 wxEvent *arg1 = 0 ;
19472 wxPropagateOnce *result = 0 ;
19473 void *argp1 = 0 ;
19474 int res1 = 0 ;
19475 PyObject * obj0 = 0 ;
19476 char * kwnames[] = {
19477 (char *) "event", NULL
19478 };
19479
19480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19481 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19482 if (!SWIG_IsOK(res1)) {
19483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19484 }
19485 if (!argp1) {
19486 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19487 }
19488 arg1 = reinterpret_cast< wxEvent * >(argp1);
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19492 wxPyEndAllowThreads(__tstate);
19493 if (PyErr_Occurred()) SWIG_fail;
19494 }
19495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19496 return resultobj;
19497 fail:
19498 return NULL;
19499 }
19500
19501
19502 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19503 PyObject *resultobj = 0;
19504 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19505 void *argp1 = 0 ;
19506 int res1 = 0 ;
19507 PyObject *swig_obj[1] ;
19508
19509 if (!args) SWIG_fail;
19510 swig_obj[0] = args;
19511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19512 if (!SWIG_IsOK(res1)) {
19513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19514 }
19515 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19516 {
19517 PyThreadState* __tstate = wxPyBeginAllowThreads();
19518 delete arg1;
19519
19520 wxPyEndAllowThreads(__tstate);
19521 if (PyErr_Occurred()) SWIG_fail;
19522 }
19523 resultobj = SWIG_Py_Void();
19524 return resultobj;
19525 fail:
19526 return NULL;
19527 }
19528
19529
19530 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19531 PyObject *obj;
19532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19533 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19534 return SWIG_Py_Void();
19535 }
19536
19537 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19538 return SWIG_Python_InitShadowInstance(args);
19539 }
19540
19541 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19542 PyObject *resultobj = 0;
19543 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19544 int arg2 = (int) 0 ;
19545 wxCommandEvent *result = 0 ;
19546 int val1 ;
19547 int ecode1 = 0 ;
19548 int val2 ;
19549 int ecode2 = 0 ;
19550 PyObject * obj0 = 0 ;
19551 PyObject * obj1 = 0 ;
19552 char * kwnames[] = {
19553 (char *) "commandType",(char *) "winid", NULL
19554 };
19555
19556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19557 if (obj0) {
19558 ecode1 = SWIG_AsVal_int(obj0, &val1);
19559 if (!SWIG_IsOK(ecode1)) {
19560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19561 }
19562 arg1 = static_cast< wxEventType >(val1);
19563 }
19564 if (obj1) {
19565 ecode2 = SWIG_AsVal_int(obj1, &val2);
19566 if (!SWIG_IsOK(ecode2)) {
19567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19568 }
19569 arg2 = static_cast< int >(val2);
19570 }
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19574 wxPyEndAllowThreads(__tstate);
19575 if (PyErr_Occurred()) SWIG_fail;
19576 }
19577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19578 return resultobj;
19579 fail:
19580 return NULL;
19581 }
19582
19583
19584 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19585 PyObject *resultobj = 0;
19586 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19587 int result;
19588 void *argp1 = 0 ;
19589 int res1 = 0 ;
19590 PyObject *swig_obj[1] ;
19591
19592 if (!args) SWIG_fail;
19593 swig_obj[0] = args;
19594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19595 if (!SWIG_IsOK(res1)) {
19596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19597 }
19598 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19599 {
19600 PyThreadState* __tstate = wxPyBeginAllowThreads();
19601 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19602 wxPyEndAllowThreads(__tstate);
19603 if (PyErr_Occurred()) SWIG_fail;
19604 }
19605 resultobj = SWIG_From_int(static_cast< int >(result));
19606 return resultobj;
19607 fail:
19608 return NULL;
19609 }
19610
19611
19612 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19613 PyObject *resultobj = 0;
19614 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19615 wxString *arg2 = 0 ;
19616 void *argp1 = 0 ;
19617 int res1 = 0 ;
19618 bool temp2 = false ;
19619 PyObject * obj0 = 0 ;
19620 PyObject * obj1 = 0 ;
19621 char * kwnames[] = {
19622 (char *) "self",(char *) "s", NULL
19623 };
19624
19625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19627 if (!SWIG_IsOK(res1)) {
19628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19629 }
19630 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19631 {
19632 arg2 = wxString_in_helper(obj1);
19633 if (arg2 == NULL) SWIG_fail;
19634 temp2 = true;
19635 }
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 (arg1)->SetString((wxString const &)*arg2);
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 resultobj = SWIG_Py_Void();
19643 {
19644 if (temp2)
19645 delete arg2;
19646 }
19647 return resultobj;
19648 fail:
19649 {
19650 if (temp2)
19651 delete arg2;
19652 }
19653 return NULL;
19654 }
19655
19656
19657 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19658 PyObject *resultobj = 0;
19659 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19660 wxString result;
19661 void *argp1 = 0 ;
19662 int res1 = 0 ;
19663 PyObject *swig_obj[1] ;
19664
19665 if (!args) SWIG_fail;
19666 swig_obj[0] = args;
19667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19668 if (!SWIG_IsOK(res1)) {
19669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19670 }
19671 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19672 {
19673 PyThreadState* __tstate = wxPyBeginAllowThreads();
19674 result = ((wxCommandEvent const *)arg1)->GetString();
19675 wxPyEndAllowThreads(__tstate);
19676 if (PyErr_Occurred()) SWIG_fail;
19677 }
19678 {
19679 #if wxUSE_UNICODE
19680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19681 #else
19682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19683 #endif
19684 }
19685 return resultobj;
19686 fail:
19687 return NULL;
19688 }
19689
19690
19691 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19692 PyObject *resultobj = 0;
19693 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19694 bool result;
19695 void *argp1 = 0 ;
19696 int res1 = 0 ;
19697 PyObject *swig_obj[1] ;
19698
19699 if (!args) SWIG_fail;
19700 swig_obj[0] = args;
19701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19702 if (!SWIG_IsOK(res1)) {
19703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19704 }
19705 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19706 {
19707 PyThreadState* __tstate = wxPyBeginAllowThreads();
19708 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19709 wxPyEndAllowThreads(__tstate);
19710 if (PyErr_Occurred()) SWIG_fail;
19711 }
19712 {
19713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19714 }
19715 return resultobj;
19716 fail:
19717 return NULL;
19718 }
19719
19720
19721 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19722 PyObject *resultobj = 0;
19723 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19724 bool result;
19725 void *argp1 = 0 ;
19726 int res1 = 0 ;
19727 PyObject *swig_obj[1] ;
19728
19729 if (!args) SWIG_fail;
19730 swig_obj[0] = args;
19731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19732 if (!SWIG_IsOK(res1)) {
19733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19734 }
19735 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19736 {
19737 PyThreadState* __tstate = wxPyBeginAllowThreads();
19738 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19739 wxPyEndAllowThreads(__tstate);
19740 if (PyErr_Occurred()) SWIG_fail;
19741 }
19742 {
19743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19744 }
19745 return resultobj;
19746 fail:
19747 return NULL;
19748 }
19749
19750
19751 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19752 PyObject *resultobj = 0;
19753 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19754 long arg2 ;
19755 void *argp1 = 0 ;
19756 int res1 = 0 ;
19757 long val2 ;
19758 int ecode2 = 0 ;
19759 PyObject * obj0 = 0 ;
19760 PyObject * obj1 = 0 ;
19761 char * kwnames[] = {
19762 (char *) "self",(char *) "extraLong", NULL
19763 };
19764
19765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19767 if (!SWIG_IsOK(res1)) {
19768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19769 }
19770 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19771 ecode2 = SWIG_AsVal_long(obj1, &val2);
19772 if (!SWIG_IsOK(ecode2)) {
19773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19774 }
19775 arg2 = static_cast< long >(val2);
19776 {
19777 PyThreadState* __tstate = wxPyBeginAllowThreads();
19778 (arg1)->SetExtraLong(arg2);
19779 wxPyEndAllowThreads(__tstate);
19780 if (PyErr_Occurred()) SWIG_fail;
19781 }
19782 resultobj = SWIG_Py_Void();
19783 return resultobj;
19784 fail:
19785 return NULL;
19786 }
19787
19788
19789 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19790 PyObject *resultobj = 0;
19791 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19792 long result;
19793 void *argp1 = 0 ;
19794 int res1 = 0 ;
19795 PyObject *swig_obj[1] ;
19796
19797 if (!args) SWIG_fail;
19798 swig_obj[0] = args;
19799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19800 if (!SWIG_IsOK(res1)) {
19801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19802 }
19803 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19804 {
19805 PyThreadState* __tstate = wxPyBeginAllowThreads();
19806 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19807 wxPyEndAllowThreads(__tstate);
19808 if (PyErr_Occurred()) SWIG_fail;
19809 }
19810 resultobj = SWIG_From_long(static_cast< long >(result));
19811 return resultobj;
19812 fail:
19813 return NULL;
19814 }
19815
19816
19817 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19818 PyObject *resultobj = 0;
19819 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19820 int arg2 ;
19821 void *argp1 = 0 ;
19822 int res1 = 0 ;
19823 int val2 ;
19824 int ecode2 = 0 ;
19825 PyObject * obj0 = 0 ;
19826 PyObject * obj1 = 0 ;
19827 char * kwnames[] = {
19828 (char *) "self",(char *) "i", NULL
19829 };
19830
19831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19833 if (!SWIG_IsOK(res1)) {
19834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19835 }
19836 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19837 ecode2 = SWIG_AsVal_int(obj1, &val2);
19838 if (!SWIG_IsOK(ecode2)) {
19839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19840 }
19841 arg2 = static_cast< int >(val2);
19842 {
19843 PyThreadState* __tstate = wxPyBeginAllowThreads();
19844 (arg1)->SetInt(arg2);
19845 wxPyEndAllowThreads(__tstate);
19846 if (PyErr_Occurred()) SWIG_fail;
19847 }
19848 resultobj = SWIG_Py_Void();
19849 return resultobj;
19850 fail:
19851 return NULL;
19852 }
19853
19854
19855 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19856 PyObject *resultobj = 0;
19857 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19858 int result;
19859 void *argp1 = 0 ;
19860 int res1 = 0 ;
19861 PyObject *swig_obj[1] ;
19862
19863 if (!args) SWIG_fail;
19864 swig_obj[0] = args;
19865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19866 if (!SWIG_IsOK(res1)) {
19867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19868 }
19869 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19870 {
19871 PyThreadState* __tstate = wxPyBeginAllowThreads();
19872 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19873 wxPyEndAllowThreads(__tstate);
19874 if (PyErr_Occurred()) SWIG_fail;
19875 }
19876 resultobj = SWIG_From_int(static_cast< int >(result));
19877 return resultobj;
19878 fail:
19879 return NULL;
19880 }
19881
19882
19883 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19884 PyObject *resultobj = 0;
19885 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19886 PyObject *result = 0 ;
19887 void *argp1 = 0 ;
19888 int res1 = 0 ;
19889 PyObject *swig_obj[1] ;
19890
19891 if (!args) SWIG_fail;
19892 swig_obj[0] = args;
19893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19894 if (!SWIG_IsOK(res1)) {
19895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19896 }
19897 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19898 {
19899 PyThreadState* __tstate = wxPyBeginAllowThreads();
19900 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19901 wxPyEndAllowThreads(__tstate);
19902 if (PyErr_Occurred()) SWIG_fail;
19903 }
19904 resultobj = result;
19905 return resultobj;
19906 fail:
19907 return NULL;
19908 }
19909
19910
19911 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19912 PyObject *resultobj = 0;
19913 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19914 PyObject *arg2 = (PyObject *) 0 ;
19915 void *argp1 = 0 ;
19916 int res1 = 0 ;
19917 PyObject * obj0 = 0 ;
19918 PyObject * obj1 = 0 ;
19919 char * kwnames[] = {
19920 (char *) "self",(char *) "clientData", NULL
19921 };
19922
19923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19925 if (!SWIG_IsOK(res1)) {
19926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19927 }
19928 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19929 arg2 = obj1;
19930 {
19931 PyThreadState* __tstate = wxPyBeginAllowThreads();
19932 wxCommandEvent_SetClientData(arg1,arg2);
19933 wxPyEndAllowThreads(__tstate);
19934 if (PyErr_Occurred()) SWIG_fail;
19935 }
19936 resultobj = SWIG_Py_Void();
19937 return resultobj;
19938 fail:
19939 return NULL;
19940 }
19941
19942
19943 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19944 PyObject *resultobj = 0;
19945 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19946 wxEvent *result = 0 ;
19947 void *argp1 = 0 ;
19948 int res1 = 0 ;
19949 PyObject *swig_obj[1] ;
19950
19951 if (!args) SWIG_fail;
19952 swig_obj[0] = args;
19953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19954 if (!SWIG_IsOK(res1)) {
19955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19956 }
19957 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19958 {
19959 PyThreadState* __tstate = wxPyBeginAllowThreads();
19960 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19961 wxPyEndAllowThreads(__tstate);
19962 if (PyErr_Occurred()) SWIG_fail;
19963 }
19964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19965 return resultobj;
19966 fail:
19967 return NULL;
19968 }
19969
19970
19971 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19972 PyObject *obj;
19973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19974 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19975 return SWIG_Py_Void();
19976 }
19977
19978 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19979 return SWIG_Python_InitShadowInstance(args);
19980 }
19981
19982 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19983 PyObject *resultobj = 0;
19984 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19985 int arg2 = (int) 0 ;
19986 wxNotifyEvent *result = 0 ;
19987 int val1 ;
19988 int ecode1 = 0 ;
19989 int val2 ;
19990 int ecode2 = 0 ;
19991 PyObject * obj0 = 0 ;
19992 PyObject * obj1 = 0 ;
19993 char * kwnames[] = {
19994 (char *) "commandType",(char *) "winid", NULL
19995 };
19996
19997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19998 if (obj0) {
19999 ecode1 = SWIG_AsVal_int(obj0, &val1);
20000 if (!SWIG_IsOK(ecode1)) {
20001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20002 }
20003 arg1 = static_cast< wxEventType >(val1);
20004 }
20005 if (obj1) {
20006 ecode2 = SWIG_AsVal_int(obj1, &val2);
20007 if (!SWIG_IsOK(ecode2)) {
20008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20009 }
20010 arg2 = static_cast< int >(val2);
20011 }
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20019 return resultobj;
20020 fail:
20021 return NULL;
20022 }
20023
20024
20025 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20026 PyObject *resultobj = 0;
20027 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20028 void *argp1 = 0 ;
20029 int res1 = 0 ;
20030 PyObject *swig_obj[1] ;
20031
20032 if (!args) SWIG_fail;
20033 swig_obj[0] = args;
20034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20035 if (!SWIG_IsOK(res1)) {
20036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20037 }
20038 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20039 {
20040 PyThreadState* __tstate = wxPyBeginAllowThreads();
20041 (arg1)->Veto();
20042 wxPyEndAllowThreads(__tstate);
20043 if (PyErr_Occurred()) SWIG_fail;
20044 }
20045 resultobj = SWIG_Py_Void();
20046 return resultobj;
20047 fail:
20048 return NULL;
20049 }
20050
20051
20052 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20053 PyObject *resultobj = 0;
20054 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20055 void *argp1 = 0 ;
20056 int res1 = 0 ;
20057 PyObject *swig_obj[1] ;
20058
20059 if (!args) SWIG_fail;
20060 swig_obj[0] = args;
20061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20062 if (!SWIG_IsOK(res1)) {
20063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20064 }
20065 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20066 {
20067 PyThreadState* __tstate = wxPyBeginAllowThreads();
20068 (arg1)->Allow();
20069 wxPyEndAllowThreads(__tstate);
20070 if (PyErr_Occurred()) SWIG_fail;
20071 }
20072 resultobj = SWIG_Py_Void();
20073 return resultobj;
20074 fail:
20075 return NULL;
20076 }
20077
20078
20079 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20080 PyObject *resultobj = 0;
20081 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20082 bool result;
20083 void *argp1 = 0 ;
20084 int res1 = 0 ;
20085 PyObject *swig_obj[1] ;
20086
20087 if (!args) SWIG_fail;
20088 swig_obj[0] = args;
20089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20090 if (!SWIG_IsOK(res1)) {
20091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20092 }
20093 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20094 {
20095 PyThreadState* __tstate = wxPyBeginAllowThreads();
20096 result = (bool)(arg1)->IsAllowed();
20097 wxPyEndAllowThreads(__tstate);
20098 if (PyErr_Occurred()) SWIG_fail;
20099 }
20100 {
20101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20102 }
20103 return resultobj;
20104 fail:
20105 return NULL;
20106 }
20107
20108
20109 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20110 PyObject *obj;
20111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20112 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20113 return SWIG_Py_Void();
20114 }
20115
20116 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20117 return SWIG_Python_InitShadowInstance(args);
20118 }
20119
20120 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20121 PyObject *resultobj = 0;
20122 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20123 int arg2 = (int) 0 ;
20124 int arg3 = (int) 0 ;
20125 int arg4 = (int) 0 ;
20126 wxScrollEvent *result = 0 ;
20127 int val1 ;
20128 int ecode1 = 0 ;
20129 int val2 ;
20130 int ecode2 = 0 ;
20131 int val3 ;
20132 int ecode3 = 0 ;
20133 int val4 ;
20134 int ecode4 = 0 ;
20135 PyObject * obj0 = 0 ;
20136 PyObject * obj1 = 0 ;
20137 PyObject * obj2 = 0 ;
20138 PyObject * obj3 = 0 ;
20139 char * kwnames[] = {
20140 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20141 };
20142
20143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20144 if (obj0) {
20145 ecode1 = SWIG_AsVal_int(obj0, &val1);
20146 if (!SWIG_IsOK(ecode1)) {
20147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20148 }
20149 arg1 = static_cast< wxEventType >(val1);
20150 }
20151 if (obj1) {
20152 ecode2 = SWIG_AsVal_int(obj1, &val2);
20153 if (!SWIG_IsOK(ecode2)) {
20154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20155 }
20156 arg2 = static_cast< int >(val2);
20157 }
20158 if (obj2) {
20159 ecode3 = SWIG_AsVal_int(obj2, &val3);
20160 if (!SWIG_IsOK(ecode3)) {
20161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20162 }
20163 arg3 = static_cast< int >(val3);
20164 }
20165 if (obj3) {
20166 ecode4 = SWIG_AsVal_int(obj3, &val4);
20167 if (!SWIG_IsOK(ecode4)) {
20168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20169 }
20170 arg4 = static_cast< int >(val4);
20171 }
20172 {
20173 PyThreadState* __tstate = wxPyBeginAllowThreads();
20174 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20175 wxPyEndAllowThreads(__tstate);
20176 if (PyErr_Occurred()) SWIG_fail;
20177 }
20178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20179 return resultobj;
20180 fail:
20181 return NULL;
20182 }
20183
20184
20185 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20186 PyObject *resultobj = 0;
20187 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20188 int result;
20189 void *argp1 = 0 ;
20190 int res1 = 0 ;
20191 PyObject *swig_obj[1] ;
20192
20193 if (!args) SWIG_fail;
20194 swig_obj[0] = args;
20195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20196 if (!SWIG_IsOK(res1)) {
20197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20198 }
20199 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20200 {
20201 PyThreadState* __tstate = wxPyBeginAllowThreads();
20202 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20203 wxPyEndAllowThreads(__tstate);
20204 if (PyErr_Occurred()) SWIG_fail;
20205 }
20206 resultobj = SWIG_From_int(static_cast< int >(result));
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20214 PyObject *resultobj = 0;
20215 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20216 int result;
20217 void *argp1 = 0 ;
20218 int res1 = 0 ;
20219 PyObject *swig_obj[1] ;
20220
20221 if (!args) SWIG_fail;
20222 swig_obj[0] = args;
20223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20224 if (!SWIG_IsOK(res1)) {
20225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20226 }
20227 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20228 {
20229 PyThreadState* __tstate = wxPyBeginAllowThreads();
20230 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20231 wxPyEndAllowThreads(__tstate);
20232 if (PyErr_Occurred()) SWIG_fail;
20233 }
20234 resultobj = SWIG_From_int(static_cast< int >(result));
20235 return resultobj;
20236 fail:
20237 return NULL;
20238 }
20239
20240
20241 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20242 PyObject *resultobj = 0;
20243 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20244 int arg2 ;
20245 void *argp1 = 0 ;
20246 int res1 = 0 ;
20247 int val2 ;
20248 int ecode2 = 0 ;
20249 PyObject * obj0 = 0 ;
20250 PyObject * obj1 = 0 ;
20251 char * kwnames[] = {
20252 (char *) "self",(char *) "orient", NULL
20253 };
20254
20255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20257 if (!SWIG_IsOK(res1)) {
20258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20259 }
20260 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20261 ecode2 = SWIG_AsVal_int(obj1, &val2);
20262 if (!SWIG_IsOK(ecode2)) {
20263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20264 }
20265 arg2 = static_cast< int >(val2);
20266 {
20267 PyThreadState* __tstate = wxPyBeginAllowThreads();
20268 (arg1)->SetOrientation(arg2);
20269 wxPyEndAllowThreads(__tstate);
20270 if (PyErr_Occurred()) SWIG_fail;
20271 }
20272 resultobj = SWIG_Py_Void();
20273 return resultobj;
20274 fail:
20275 return NULL;
20276 }
20277
20278
20279 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20280 PyObject *resultobj = 0;
20281 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20282 int arg2 ;
20283 void *argp1 = 0 ;
20284 int res1 = 0 ;
20285 int val2 ;
20286 int ecode2 = 0 ;
20287 PyObject * obj0 = 0 ;
20288 PyObject * obj1 = 0 ;
20289 char * kwnames[] = {
20290 (char *) "self",(char *) "pos", NULL
20291 };
20292
20293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20295 if (!SWIG_IsOK(res1)) {
20296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20297 }
20298 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20299 ecode2 = SWIG_AsVal_int(obj1, &val2);
20300 if (!SWIG_IsOK(ecode2)) {
20301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20302 }
20303 arg2 = static_cast< int >(val2);
20304 {
20305 PyThreadState* __tstate = wxPyBeginAllowThreads();
20306 (arg1)->SetPosition(arg2);
20307 wxPyEndAllowThreads(__tstate);
20308 if (PyErr_Occurred()) SWIG_fail;
20309 }
20310 resultobj = SWIG_Py_Void();
20311 return resultobj;
20312 fail:
20313 return NULL;
20314 }
20315
20316
20317 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20318 PyObject *obj;
20319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20320 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20321 return SWIG_Py_Void();
20322 }
20323
20324 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20325 return SWIG_Python_InitShadowInstance(args);
20326 }
20327
20328 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20329 PyObject *resultobj = 0;
20330 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20331 int arg2 = (int) 0 ;
20332 int arg3 = (int) 0 ;
20333 wxScrollWinEvent *result = 0 ;
20334 int val1 ;
20335 int ecode1 = 0 ;
20336 int val2 ;
20337 int ecode2 = 0 ;
20338 int val3 ;
20339 int ecode3 = 0 ;
20340 PyObject * obj0 = 0 ;
20341 PyObject * obj1 = 0 ;
20342 PyObject * obj2 = 0 ;
20343 char * kwnames[] = {
20344 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20345 };
20346
20347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20348 if (obj0) {
20349 ecode1 = SWIG_AsVal_int(obj0, &val1);
20350 if (!SWIG_IsOK(ecode1)) {
20351 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20352 }
20353 arg1 = static_cast< wxEventType >(val1);
20354 }
20355 if (obj1) {
20356 ecode2 = SWIG_AsVal_int(obj1, &val2);
20357 if (!SWIG_IsOK(ecode2)) {
20358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20359 }
20360 arg2 = static_cast< int >(val2);
20361 }
20362 if (obj2) {
20363 ecode3 = SWIG_AsVal_int(obj2, &val3);
20364 if (!SWIG_IsOK(ecode3)) {
20365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20366 }
20367 arg3 = static_cast< int >(val3);
20368 }
20369 {
20370 PyThreadState* __tstate = wxPyBeginAllowThreads();
20371 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20372 wxPyEndAllowThreads(__tstate);
20373 if (PyErr_Occurred()) SWIG_fail;
20374 }
20375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20376 return resultobj;
20377 fail:
20378 return NULL;
20379 }
20380
20381
20382 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20383 PyObject *resultobj = 0;
20384 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20385 int result;
20386 void *argp1 = 0 ;
20387 int res1 = 0 ;
20388 PyObject *swig_obj[1] ;
20389
20390 if (!args) SWIG_fail;
20391 swig_obj[0] = args;
20392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20393 if (!SWIG_IsOK(res1)) {
20394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20395 }
20396 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20397 {
20398 PyThreadState* __tstate = wxPyBeginAllowThreads();
20399 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20400 wxPyEndAllowThreads(__tstate);
20401 if (PyErr_Occurred()) SWIG_fail;
20402 }
20403 resultobj = SWIG_From_int(static_cast< int >(result));
20404 return resultobj;
20405 fail:
20406 return NULL;
20407 }
20408
20409
20410 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20411 PyObject *resultobj = 0;
20412 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20413 int result;
20414 void *argp1 = 0 ;
20415 int res1 = 0 ;
20416 PyObject *swig_obj[1] ;
20417
20418 if (!args) SWIG_fail;
20419 swig_obj[0] = args;
20420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20421 if (!SWIG_IsOK(res1)) {
20422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20423 }
20424 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20425 {
20426 PyThreadState* __tstate = wxPyBeginAllowThreads();
20427 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20428 wxPyEndAllowThreads(__tstate);
20429 if (PyErr_Occurred()) SWIG_fail;
20430 }
20431 resultobj = SWIG_From_int(static_cast< int >(result));
20432 return resultobj;
20433 fail:
20434 return NULL;
20435 }
20436
20437
20438 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20439 PyObject *resultobj = 0;
20440 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20441 int arg2 ;
20442 void *argp1 = 0 ;
20443 int res1 = 0 ;
20444 int val2 ;
20445 int ecode2 = 0 ;
20446 PyObject * obj0 = 0 ;
20447 PyObject * obj1 = 0 ;
20448 char * kwnames[] = {
20449 (char *) "self",(char *) "orient", NULL
20450 };
20451
20452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20454 if (!SWIG_IsOK(res1)) {
20455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20456 }
20457 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20458 ecode2 = SWIG_AsVal_int(obj1, &val2);
20459 if (!SWIG_IsOK(ecode2)) {
20460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20461 }
20462 arg2 = static_cast< int >(val2);
20463 {
20464 PyThreadState* __tstate = wxPyBeginAllowThreads();
20465 (arg1)->SetOrientation(arg2);
20466 wxPyEndAllowThreads(__tstate);
20467 if (PyErr_Occurred()) SWIG_fail;
20468 }
20469 resultobj = SWIG_Py_Void();
20470 return resultobj;
20471 fail:
20472 return NULL;
20473 }
20474
20475
20476 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20477 PyObject *resultobj = 0;
20478 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20479 int arg2 ;
20480 void *argp1 = 0 ;
20481 int res1 = 0 ;
20482 int val2 ;
20483 int ecode2 = 0 ;
20484 PyObject * obj0 = 0 ;
20485 PyObject * obj1 = 0 ;
20486 char * kwnames[] = {
20487 (char *) "self",(char *) "pos", NULL
20488 };
20489
20490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20492 if (!SWIG_IsOK(res1)) {
20493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20494 }
20495 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20496 ecode2 = SWIG_AsVal_int(obj1, &val2);
20497 if (!SWIG_IsOK(ecode2)) {
20498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20499 }
20500 arg2 = static_cast< int >(val2);
20501 {
20502 PyThreadState* __tstate = wxPyBeginAllowThreads();
20503 (arg1)->SetPosition(arg2);
20504 wxPyEndAllowThreads(__tstate);
20505 if (PyErr_Occurred()) SWIG_fail;
20506 }
20507 resultobj = SWIG_Py_Void();
20508 return resultobj;
20509 fail:
20510 return NULL;
20511 }
20512
20513
20514 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20515 PyObject *obj;
20516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20517 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20518 return SWIG_Py_Void();
20519 }
20520
20521 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20522 return SWIG_Python_InitShadowInstance(args);
20523 }
20524
20525 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj = 0;
20527 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20528 wxMouseEvent *result = 0 ;
20529 int val1 ;
20530 int ecode1 = 0 ;
20531 PyObject * obj0 = 0 ;
20532 char * kwnames[] = {
20533 (char *) "mouseType", NULL
20534 };
20535
20536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20537 if (obj0) {
20538 ecode1 = SWIG_AsVal_int(obj0, &val1);
20539 if (!SWIG_IsOK(ecode1)) {
20540 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20541 }
20542 arg1 = static_cast< wxEventType >(val1);
20543 }
20544 {
20545 PyThreadState* __tstate = wxPyBeginAllowThreads();
20546 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20547 wxPyEndAllowThreads(__tstate);
20548 if (PyErr_Occurred()) SWIG_fail;
20549 }
20550 {
20551 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20552 }
20553 return resultobj;
20554 fail:
20555 return NULL;
20556 }
20557
20558
20559 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20560 PyObject *resultobj = 0;
20561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20562 bool result;
20563 void *argp1 = 0 ;
20564 int res1 = 0 ;
20565 PyObject *swig_obj[1] ;
20566
20567 if (!args) SWIG_fail;
20568 swig_obj[0] = args;
20569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20570 if (!SWIG_IsOK(res1)) {
20571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20572 }
20573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20574 {
20575 PyThreadState* __tstate = wxPyBeginAllowThreads();
20576 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20577 wxPyEndAllowThreads(__tstate);
20578 if (PyErr_Occurred()) SWIG_fail;
20579 }
20580 {
20581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20582 }
20583 return resultobj;
20584 fail:
20585 return NULL;
20586 }
20587
20588
20589 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20590 PyObject *resultobj = 0;
20591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20592 int arg2 = (int) wxMOUSE_BTN_ANY ;
20593 bool result;
20594 void *argp1 = 0 ;
20595 int res1 = 0 ;
20596 int val2 ;
20597 int ecode2 = 0 ;
20598 PyObject * obj0 = 0 ;
20599 PyObject * obj1 = 0 ;
20600 char * kwnames[] = {
20601 (char *) "self",(char *) "but", NULL
20602 };
20603
20604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20608 }
20609 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20610 if (obj1) {
20611 ecode2 = SWIG_AsVal_int(obj1, &val2);
20612 if (!SWIG_IsOK(ecode2)) {
20613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20614 }
20615 arg2 = static_cast< int >(val2);
20616 }
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20620 wxPyEndAllowThreads(__tstate);
20621 if (PyErr_Occurred()) SWIG_fail;
20622 }
20623 {
20624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20625 }
20626 return resultobj;
20627 fail:
20628 return NULL;
20629 }
20630
20631
20632 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20633 PyObject *resultobj = 0;
20634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20635 int arg2 = (int) wxMOUSE_BTN_ANY ;
20636 bool result;
20637 void *argp1 = 0 ;
20638 int res1 = 0 ;
20639 int val2 ;
20640 int ecode2 = 0 ;
20641 PyObject * obj0 = 0 ;
20642 PyObject * obj1 = 0 ;
20643 char * kwnames[] = {
20644 (char *) "self",(char *) "but", NULL
20645 };
20646
20647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20649 if (!SWIG_IsOK(res1)) {
20650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20651 }
20652 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20653 if (obj1) {
20654 ecode2 = SWIG_AsVal_int(obj1, &val2);
20655 if (!SWIG_IsOK(ecode2)) {
20656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20657 }
20658 arg2 = static_cast< int >(val2);
20659 }
20660 {
20661 PyThreadState* __tstate = wxPyBeginAllowThreads();
20662 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20663 wxPyEndAllowThreads(__tstate);
20664 if (PyErr_Occurred()) SWIG_fail;
20665 }
20666 {
20667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20668 }
20669 return resultobj;
20670 fail:
20671 return NULL;
20672 }
20673
20674
20675 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20676 PyObject *resultobj = 0;
20677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20678 int arg2 = (int) wxMOUSE_BTN_ANY ;
20679 bool result;
20680 void *argp1 = 0 ;
20681 int res1 = 0 ;
20682 int val2 ;
20683 int ecode2 = 0 ;
20684 PyObject * obj0 = 0 ;
20685 PyObject * obj1 = 0 ;
20686 char * kwnames[] = {
20687 (char *) "self",(char *) "but", NULL
20688 };
20689
20690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20692 if (!SWIG_IsOK(res1)) {
20693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20694 }
20695 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20696 if (obj1) {
20697 ecode2 = SWIG_AsVal_int(obj1, &val2);
20698 if (!SWIG_IsOK(ecode2)) {
20699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20700 }
20701 arg2 = static_cast< int >(val2);
20702 }
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 {
20710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20711 }
20712 return resultobj;
20713 fail:
20714 return NULL;
20715 }
20716
20717
20718 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20719 PyObject *resultobj = 0;
20720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20721 int arg2 ;
20722 bool result;
20723 void *argp1 = 0 ;
20724 int res1 = 0 ;
20725 int val2 ;
20726 int ecode2 = 0 ;
20727 PyObject * obj0 = 0 ;
20728 PyObject * obj1 = 0 ;
20729 char * kwnames[] = {
20730 (char *) "self",(char *) "button", NULL
20731 };
20732
20733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20735 if (!SWIG_IsOK(res1)) {
20736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20737 }
20738 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20739 ecode2 = SWIG_AsVal_int(obj1, &val2);
20740 if (!SWIG_IsOK(ecode2)) {
20741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20742 }
20743 arg2 = static_cast< int >(val2);
20744 {
20745 PyThreadState* __tstate = wxPyBeginAllowThreads();
20746 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20747 wxPyEndAllowThreads(__tstate);
20748 if (PyErr_Occurred()) SWIG_fail;
20749 }
20750 {
20751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20752 }
20753 return resultobj;
20754 fail:
20755 return NULL;
20756 }
20757
20758
20759 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20760 PyObject *resultobj = 0;
20761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20762 int arg2 ;
20763 bool result;
20764 void *argp1 = 0 ;
20765 int res1 = 0 ;
20766 int val2 ;
20767 int ecode2 = 0 ;
20768 PyObject * obj0 = 0 ;
20769 PyObject * obj1 = 0 ;
20770 char * kwnames[] = {
20771 (char *) "self",(char *) "but", NULL
20772 };
20773
20774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20776 if (!SWIG_IsOK(res1)) {
20777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20778 }
20779 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20780 ecode2 = SWIG_AsVal_int(obj1, &val2);
20781 if (!SWIG_IsOK(ecode2)) {
20782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20783 }
20784 arg2 = static_cast< int >(val2);
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 {
20792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20793 }
20794 return resultobj;
20795 fail:
20796 return NULL;
20797 }
20798
20799
20800 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20801 PyObject *resultobj = 0;
20802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20803 int result;
20804 void *argp1 = 0 ;
20805 int res1 = 0 ;
20806 PyObject *swig_obj[1] ;
20807
20808 if (!args) SWIG_fail;
20809 swig_obj[0] = args;
20810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20811 if (!SWIG_IsOK(res1)) {
20812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20813 }
20814 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 resultobj = SWIG_From_int(static_cast< int >(result));
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20829 PyObject *resultobj = 0;
20830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20831 bool result;
20832 void *argp1 = 0 ;
20833 int res1 = 0 ;
20834 PyObject *swig_obj[1] ;
20835
20836 if (!args) SWIG_fail;
20837 swig_obj[0] = args;
20838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20839 if (!SWIG_IsOK(res1)) {
20840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20841 }
20842 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20843 {
20844 PyThreadState* __tstate = wxPyBeginAllowThreads();
20845 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20846 wxPyEndAllowThreads(__tstate);
20847 if (PyErr_Occurred()) SWIG_fail;
20848 }
20849 {
20850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20851 }
20852 return resultobj;
20853 fail:
20854 return NULL;
20855 }
20856
20857
20858 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20859 PyObject *resultobj = 0;
20860 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20861 bool result;
20862 void *argp1 = 0 ;
20863 int res1 = 0 ;
20864 PyObject *swig_obj[1] ;
20865
20866 if (!args) SWIG_fail;
20867 swig_obj[0] = args;
20868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20869 if (!SWIG_IsOK(res1)) {
20870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20871 }
20872 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 {
20880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20881 }
20882 return resultobj;
20883 fail:
20884 return NULL;
20885 }
20886
20887
20888 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20889 PyObject *resultobj = 0;
20890 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20891 bool result;
20892 void *argp1 = 0 ;
20893 int res1 = 0 ;
20894 PyObject *swig_obj[1] ;
20895
20896 if (!args) SWIG_fail;
20897 swig_obj[0] = args;
20898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20899 if (!SWIG_IsOK(res1)) {
20900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20901 }
20902 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20903 {
20904 PyThreadState* __tstate = wxPyBeginAllowThreads();
20905 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20906 wxPyEndAllowThreads(__tstate);
20907 if (PyErr_Occurred()) SWIG_fail;
20908 }
20909 {
20910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20911 }
20912 return resultobj;
20913 fail:
20914 return NULL;
20915 }
20916
20917
20918 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20919 PyObject *resultobj = 0;
20920 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20921 bool result;
20922 void *argp1 = 0 ;
20923 int res1 = 0 ;
20924 PyObject *swig_obj[1] ;
20925
20926 if (!args) SWIG_fail;
20927 swig_obj[0] = args;
20928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20929 if (!SWIG_IsOK(res1)) {
20930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20931 }
20932 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20936 wxPyEndAllowThreads(__tstate);
20937 if (PyErr_Occurred()) SWIG_fail;
20938 }
20939 {
20940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20941 }
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 PyObject *resultobj = 0;
20950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20951 bool result;
20952 void *argp1 = 0 ;
20953 int res1 = 0 ;
20954 PyObject *swig_obj[1] ;
20955
20956 if (!args) SWIG_fail;
20957 swig_obj[0] = args;
20958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20959 if (!SWIG_IsOK(res1)) {
20960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20961 }
20962 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 {
20970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20971 }
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 PyObject *resultobj = 0;
20980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20981 bool 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_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20991 }
20992 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 {
21000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21001 }
21002 return resultobj;
21003 fail:
21004 return NULL;
21005 }
21006
21007
21008 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21009 PyObject *resultobj = 0;
21010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21011 bool result;
21012 void *argp1 = 0 ;
21013 int res1 = 0 ;
21014 PyObject *swig_obj[1] ;
21015
21016 if (!args) SWIG_fail;
21017 swig_obj[0] = args;
21018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21019 if (!SWIG_IsOK(res1)) {
21020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21021 }
21022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21023 {
21024 PyThreadState* __tstate = wxPyBeginAllowThreads();
21025 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21026 wxPyEndAllowThreads(__tstate);
21027 if (PyErr_Occurred()) SWIG_fail;
21028 }
21029 {
21030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21031 }
21032 return resultobj;
21033 fail:
21034 return NULL;
21035 }
21036
21037
21038 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21039 PyObject *resultobj = 0;
21040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21041 bool result;
21042 void *argp1 = 0 ;
21043 int res1 = 0 ;
21044 PyObject *swig_obj[1] ;
21045
21046 if (!args) SWIG_fail;
21047 swig_obj[0] = args;
21048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21049 if (!SWIG_IsOK(res1)) {
21050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21051 }
21052 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21053 {
21054 PyThreadState* __tstate = wxPyBeginAllowThreads();
21055 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21056 wxPyEndAllowThreads(__tstate);
21057 if (PyErr_Occurred()) SWIG_fail;
21058 }
21059 {
21060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21061 }
21062 return resultobj;
21063 fail:
21064 return NULL;
21065 }
21066
21067
21068 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21069 PyObject *resultobj = 0;
21070 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21071 bool result;
21072 void *argp1 = 0 ;
21073 int res1 = 0 ;
21074 PyObject *swig_obj[1] ;
21075
21076 if (!args) SWIG_fail;
21077 swig_obj[0] = args;
21078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21079 if (!SWIG_IsOK(res1)) {
21080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21081 }
21082 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21083 {
21084 PyThreadState* __tstate = wxPyBeginAllowThreads();
21085 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 {
21090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21091 }
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21099 PyObject *resultobj = 0;
21100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21101 bool result;
21102 void *argp1 = 0 ;
21103 int res1 = 0 ;
21104 PyObject *swig_obj[1] ;
21105
21106 if (!args) SWIG_fail;
21107 swig_obj[0] = args;
21108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21109 if (!SWIG_IsOK(res1)) {
21110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21111 }
21112 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21113 {
21114 PyThreadState* __tstate = wxPyBeginAllowThreads();
21115 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21116 wxPyEndAllowThreads(__tstate);
21117 if (PyErr_Occurred()) SWIG_fail;
21118 }
21119 {
21120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21121 }
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21129 PyObject *resultobj = 0;
21130 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21131 bool result;
21132 void *argp1 = 0 ;
21133 int res1 = 0 ;
21134 PyObject *swig_obj[1] ;
21135
21136 if (!args) SWIG_fail;
21137 swig_obj[0] = args;
21138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21139 if (!SWIG_IsOK(res1)) {
21140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21141 }
21142 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21143 {
21144 PyThreadState* __tstate = wxPyBeginAllowThreads();
21145 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21146 wxPyEndAllowThreads(__tstate);
21147 if (PyErr_Occurred()) SWIG_fail;
21148 }
21149 {
21150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21151 }
21152 return resultobj;
21153 fail:
21154 return NULL;
21155 }
21156
21157
21158 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21159 PyObject *resultobj = 0;
21160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21161 bool result;
21162 void *argp1 = 0 ;
21163 int res1 = 0 ;
21164 PyObject *swig_obj[1] ;
21165
21166 if (!args) SWIG_fail;
21167 swig_obj[0] = args;
21168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21169 if (!SWIG_IsOK(res1)) {
21170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21171 }
21172 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21173 {
21174 PyThreadState* __tstate = wxPyBeginAllowThreads();
21175 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21176 wxPyEndAllowThreads(__tstate);
21177 if (PyErr_Occurred()) SWIG_fail;
21178 }
21179 {
21180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21181 }
21182 return resultobj;
21183 fail:
21184 return NULL;
21185 }
21186
21187
21188 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21189 PyObject *resultobj = 0;
21190 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21191 bool result;
21192 void *argp1 = 0 ;
21193 int res1 = 0 ;
21194 PyObject *swig_obj[1] ;
21195
21196 if (!args) SWIG_fail;
21197 swig_obj[0] = args;
21198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21199 if (!SWIG_IsOK(res1)) {
21200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21201 }
21202 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21203 {
21204 PyThreadState* __tstate = wxPyBeginAllowThreads();
21205 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 {
21210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21211 }
21212 return resultobj;
21213 fail:
21214 return NULL;
21215 }
21216
21217
21218 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21219 PyObject *resultobj = 0;
21220 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21221 bool result;
21222 void *argp1 = 0 ;
21223 int res1 = 0 ;
21224 PyObject *swig_obj[1] ;
21225
21226 if (!args) SWIG_fail;
21227 swig_obj[0] = args;
21228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21229 if (!SWIG_IsOK(res1)) {
21230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21231 }
21232 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21233 {
21234 PyThreadState* __tstate = wxPyBeginAllowThreads();
21235 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21236 wxPyEndAllowThreads(__tstate);
21237 if (PyErr_Occurred()) SWIG_fail;
21238 }
21239 {
21240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21241 }
21242 return resultobj;
21243 fail:
21244 return NULL;
21245 }
21246
21247
21248 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21249 PyObject *resultobj = 0;
21250 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21251 bool result;
21252 void *argp1 = 0 ;
21253 int res1 = 0 ;
21254 PyObject *swig_obj[1] ;
21255
21256 if (!args) SWIG_fail;
21257 swig_obj[0] = args;
21258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21259 if (!SWIG_IsOK(res1)) {
21260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21261 }
21262 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21263 {
21264 PyThreadState* __tstate = wxPyBeginAllowThreads();
21265 result = (bool)(arg1)->LeftIsDown();
21266 wxPyEndAllowThreads(__tstate);
21267 if (PyErr_Occurred()) SWIG_fail;
21268 }
21269 {
21270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21271 }
21272 return resultobj;
21273 fail:
21274 return NULL;
21275 }
21276
21277
21278 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21279 PyObject *resultobj = 0;
21280 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21281 bool result;
21282 void *argp1 = 0 ;
21283 int res1 = 0 ;
21284 PyObject *swig_obj[1] ;
21285
21286 if (!args) SWIG_fail;
21287 swig_obj[0] = args;
21288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21289 if (!SWIG_IsOK(res1)) {
21290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21291 }
21292 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21293 {
21294 PyThreadState* __tstate = wxPyBeginAllowThreads();
21295 result = (bool)(arg1)->MiddleIsDown();
21296 wxPyEndAllowThreads(__tstate);
21297 if (PyErr_Occurred()) SWIG_fail;
21298 }
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_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21309 PyObject *resultobj = 0;
21310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21311 bool result;
21312 void *argp1 = 0 ;
21313 int res1 = 0 ;
21314 PyObject *swig_obj[1] ;
21315
21316 if (!args) SWIG_fail;
21317 swig_obj[0] = args;
21318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21319 if (!SWIG_IsOK(res1)) {
21320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21321 }
21322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21323 {
21324 PyThreadState* __tstate = wxPyBeginAllowThreads();
21325 result = (bool)(arg1)->RightIsDown();
21326 wxPyEndAllowThreads(__tstate);
21327 if (PyErr_Occurred()) SWIG_fail;
21328 }
21329 {
21330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21331 }
21332 return resultobj;
21333 fail:
21334 return NULL;
21335 }
21336
21337
21338 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(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_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21351 }
21352 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21353 {
21354 PyThreadState* __tstate = wxPyBeginAllowThreads();
21355 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21356 wxPyEndAllowThreads(__tstate);
21357 if (PyErr_Occurred()) SWIG_fail;
21358 }
21359 {
21360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21361 }
21362 return resultobj;
21363 fail:
21364 return NULL;
21365 }
21366
21367
21368 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21369 PyObject *resultobj = 0;
21370 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21371 bool result;
21372 void *argp1 = 0 ;
21373 int res1 = 0 ;
21374 PyObject *swig_obj[1] ;
21375
21376 if (!args) SWIG_fail;
21377 swig_obj[0] = args;
21378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21379 if (!SWIG_IsOK(res1)) {
21380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21381 }
21382 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21383 {
21384 PyThreadState* __tstate = wxPyBeginAllowThreads();
21385 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21386 wxPyEndAllowThreads(__tstate);
21387 if (PyErr_Occurred()) SWIG_fail;
21388 }
21389 {
21390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21391 }
21392 return resultobj;
21393 fail:
21394 return NULL;
21395 }
21396
21397
21398 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21399 PyObject *resultobj = 0;
21400 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21401 bool result;
21402 void *argp1 = 0 ;
21403 int res1 = 0 ;
21404 PyObject *swig_obj[1] ;
21405
21406 if (!args) SWIG_fail;
21407 swig_obj[0] = args;
21408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21409 if (!SWIG_IsOK(res1)) {
21410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21411 }
21412 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21413 {
21414 PyThreadState* __tstate = wxPyBeginAllowThreads();
21415 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21416 wxPyEndAllowThreads(__tstate);
21417 if (PyErr_Occurred()) SWIG_fail;
21418 }
21419 {
21420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21421 }
21422 return resultobj;
21423 fail:
21424 return NULL;
21425 }
21426
21427
21428 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21429 PyObject *resultobj = 0;
21430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21431 bool result;
21432 void *argp1 = 0 ;
21433 int res1 = 0 ;
21434 PyObject *swig_obj[1] ;
21435
21436 if (!args) SWIG_fail;
21437 swig_obj[0] = args;
21438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21439 if (!SWIG_IsOK(res1)) {
21440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21441 }
21442 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21443 {
21444 PyThreadState* __tstate = wxPyBeginAllowThreads();
21445 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21446 wxPyEndAllowThreads(__tstate);
21447 if (PyErr_Occurred()) SWIG_fail;
21448 }
21449 {
21450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21451 }
21452 return resultobj;
21453 fail:
21454 return NULL;
21455 }
21456
21457
21458 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21459 PyObject *resultobj = 0;
21460 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21461 wxPoint result;
21462 void *argp1 = 0 ;
21463 int res1 = 0 ;
21464 PyObject *swig_obj[1] ;
21465
21466 if (!args) SWIG_fail;
21467 swig_obj[0] = args;
21468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21469 if (!SWIG_IsOK(res1)) {
21470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21471 }
21472 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21473 {
21474 PyThreadState* __tstate = wxPyBeginAllowThreads();
21475 result = (arg1)->GetPosition();
21476 wxPyEndAllowThreads(__tstate);
21477 if (PyErr_Occurred()) SWIG_fail;
21478 }
21479 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21480 return resultobj;
21481 fail:
21482 return NULL;
21483 }
21484
21485
21486 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21487 PyObject *resultobj = 0;
21488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21489 long *arg2 = (long *) 0 ;
21490 long *arg3 = (long *) 0 ;
21491 void *argp1 = 0 ;
21492 int res1 = 0 ;
21493 long temp2 ;
21494 int res2 = SWIG_TMPOBJ ;
21495 long temp3 ;
21496 int res3 = SWIG_TMPOBJ ;
21497 PyObject *swig_obj[1] ;
21498
21499 arg2 = &temp2;
21500 arg3 = &temp3;
21501 if (!args) SWIG_fail;
21502 swig_obj[0] = args;
21503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21504 if (!SWIG_IsOK(res1)) {
21505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21506 }
21507 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21508 {
21509 PyThreadState* __tstate = wxPyBeginAllowThreads();
21510 (arg1)->GetPosition(arg2,arg3);
21511 wxPyEndAllowThreads(__tstate);
21512 if (PyErr_Occurred()) SWIG_fail;
21513 }
21514 resultobj = SWIG_Py_Void();
21515 if (SWIG_IsTmpObj(res2)) {
21516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21517 } else {
21518 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21520 }
21521 if (SWIG_IsTmpObj(res3)) {
21522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21523 } else {
21524 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21526 }
21527 return resultobj;
21528 fail:
21529 return NULL;
21530 }
21531
21532
21533 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21534 PyObject *resultobj = 0;
21535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21536 wxDC *arg2 = 0 ;
21537 wxPoint result;
21538 void *argp1 = 0 ;
21539 int res1 = 0 ;
21540 void *argp2 = 0 ;
21541 int res2 = 0 ;
21542 PyObject * obj0 = 0 ;
21543 PyObject * obj1 = 0 ;
21544 char * kwnames[] = {
21545 (char *) "self",(char *) "dc", NULL
21546 };
21547
21548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21550 if (!SWIG_IsOK(res1)) {
21551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21552 }
21553 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21554 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21555 if (!SWIG_IsOK(res2)) {
21556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21557 }
21558 if (!argp2) {
21559 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21560 }
21561 arg2 = reinterpret_cast< wxDC * >(argp2);
21562 {
21563 PyThreadState* __tstate = wxPyBeginAllowThreads();
21564 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21569 return resultobj;
21570 fail:
21571 return NULL;
21572 }
21573
21574
21575 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21576 PyObject *resultobj = 0;
21577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21578 int result;
21579 void *argp1 = 0 ;
21580 int res1 = 0 ;
21581 PyObject *swig_obj[1] ;
21582
21583 if (!args) SWIG_fail;
21584 swig_obj[0] = args;
21585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21586 if (!SWIG_IsOK(res1)) {
21587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21588 }
21589 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21590 {
21591 PyThreadState* __tstate = wxPyBeginAllowThreads();
21592 result = (int)((wxMouseEvent const *)arg1)->GetX();
21593 wxPyEndAllowThreads(__tstate);
21594 if (PyErr_Occurred()) SWIG_fail;
21595 }
21596 resultobj = SWIG_From_int(static_cast< int >(result));
21597 return resultobj;
21598 fail:
21599 return NULL;
21600 }
21601
21602
21603 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21604 PyObject *resultobj = 0;
21605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21606 int result;
21607 void *argp1 = 0 ;
21608 int res1 = 0 ;
21609 PyObject *swig_obj[1] ;
21610
21611 if (!args) SWIG_fail;
21612 swig_obj[0] = args;
21613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21614 if (!SWIG_IsOK(res1)) {
21615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21616 }
21617 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21618 {
21619 PyThreadState* __tstate = wxPyBeginAllowThreads();
21620 result = (int)((wxMouseEvent const *)arg1)->GetY();
21621 wxPyEndAllowThreads(__tstate);
21622 if (PyErr_Occurred()) SWIG_fail;
21623 }
21624 resultobj = SWIG_From_int(static_cast< int >(result));
21625 return resultobj;
21626 fail:
21627 return NULL;
21628 }
21629
21630
21631 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21632 PyObject *resultobj = 0;
21633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21634 int result;
21635 void *argp1 = 0 ;
21636 int res1 = 0 ;
21637 PyObject *swig_obj[1] ;
21638
21639 if (!args) SWIG_fail;
21640 swig_obj[0] = args;
21641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21642 if (!SWIG_IsOK(res1)) {
21643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21644 }
21645 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21646 {
21647 PyThreadState* __tstate = wxPyBeginAllowThreads();
21648 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21649 wxPyEndAllowThreads(__tstate);
21650 if (PyErr_Occurred()) SWIG_fail;
21651 }
21652 resultobj = SWIG_From_int(static_cast< int >(result));
21653 return resultobj;
21654 fail:
21655 return NULL;
21656 }
21657
21658
21659 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21660 PyObject *resultobj = 0;
21661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21662 int result;
21663 void *argp1 = 0 ;
21664 int res1 = 0 ;
21665 PyObject *swig_obj[1] ;
21666
21667 if (!args) SWIG_fail;
21668 swig_obj[0] = args;
21669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21670 if (!SWIG_IsOK(res1)) {
21671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21672 }
21673 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21674 {
21675 PyThreadState* __tstate = wxPyBeginAllowThreads();
21676 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 resultobj = SWIG_From_int(static_cast< int >(result));
21681 return resultobj;
21682 fail:
21683 return NULL;
21684 }
21685
21686
21687 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21688 PyObject *resultobj = 0;
21689 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21690 int result;
21691 void *argp1 = 0 ;
21692 int res1 = 0 ;
21693 PyObject *swig_obj[1] ;
21694
21695 if (!args) SWIG_fail;
21696 swig_obj[0] = args;
21697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21698 if (!SWIG_IsOK(res1)) {
21699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21700 }
21701 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21705 wxPyEndAllowThreads(__tstate);
21706 if (PyErr_Occurred()) SWIG_fail;
21707 }
21708 resultobj = SWIG_From_int(static_cast< int >(result));
21709 return resultobj;
21710 fail:
21711 return NULL;
21712 }
21713
21714
21715 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21716 PyObject *resultobj = 0;
21717 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21718 bool result;
21719 void *argp1 = 0 ;
21720 int res1 = 0 ;
21721 PyObject *swig_obj[1] ;
21722
21723 if (!args) SWIG_fail;
21724 swig_obj[0] = args;
21725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21726 if (!SWIG_IsOK(res1)) {
21727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21728 }
21729 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21730 {
21731 PyThreadState* __tstate = wxPyBeginAllowThreads();
21732 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21733 wxPyEndAllowThreads(__tstate);
21734 if (PyErr_Occurred()) SWIG_fail;
21735 }
21736 {
21737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21738 }
21739 return resultobj;
21740 fail:
21741 return NULL;
21742 }
21743
21744
21745 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21746 PyObject *resultobj = 0;
21747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21748 int arg2 ;
21749 void *argp1 = 0 ;
21750 int res1 = 0 ;
21751 int val2 ;
21752 int ecode2 = 0 ;
21753 PyObject *swig_obj[2] ;
21754
21755 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21757 if (!SWIG_IsOK(res1)) {
21758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21759 }
21760 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21761 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21762 if (!SWIG_IsOK(ecode2)) {
21763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21764 }
21765 arg2 = static_cast< int >(val2);
21766 if (arg1) (arg1)->m_x = arg2;
21767
21768 resultobj = SWIG_Py_Void();
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21776 PyObject *resultobj = 0;
21777 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21778 int result;
21779 void *argp1 = 0 ;
21780 int res1 = 0 ;
21781 PyObject *swig_obj[1] ;
21782
21783 if (!args) SWIG_fail;
21784 swig_obj[0] = args;
21785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21786 if (!SWIG_IsOK(res1)) {
21787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21788 }
21789 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21790 result = (int) ((arg1)->m_x);
21791 resultobj = SWIG_From_int(static_cast< int >(result));
21792 return resultobj;
21793 fail:
21794 return NULL;
21795 }
21796
21797
21798 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21799 PyObject *resultobj = 0;
21800 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21801 int arg2 ;
21802 void *argp1 = 0 ;
21803 int res1 = 0 ;
21804 int val2 ;
21805 int ecode2 = 0 ;
21806 PyObject *swig_obj[2] ;
21807
21808 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21810 if (!SWIG_IsOK(res1)) {
21811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21812 }
21813 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21814 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21815 if (!SWIG_IsOK(ecode2)) {
21816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21817 }
21818 arg2 = static_cast< int >(val2);
21819 if (arg1) (arg1)->m_y = arg2;
21820
21821 resultobj = SWIG_Py_Void();
21822 return resultobj;
21823 fail:
21824 return NULL;
21825 }
21826
21827
21828 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21829 PyObject *resultobj = 0;
21830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21831 int result;
21832 void *argp1 = 0 ;
21833 int res1 = 0 ;
21834 PyObject *swig_obj[1] ;
21835
21836 if (!args) SWIG_fail;
21837 swig_obj[0] = args;
21838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21839 if (!SWIG_IsOK(res1)) {
21840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21841 }
21842 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21843 result = (int) ((arg1)->m_y);
21844 resultobj = SWIG_From_int(static_cast< int >(result));
21845 return resultobj;
21846 fail:
21847 return NULL;
21848 }
21849
21850
21851 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21852 PyObject *resultobj = 0;
21853 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21854 bool arg2 ;
21855 void *argp1 = 0 ;
21856 int res1 = 0 ;
21857 bool val2 ;
21858 int ecode2 = 0 ;
21859 PyObject *swig_obj[2] ;
21860
21861 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21863 if (!SWIG_IsOK(res1)) {
21864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21865 }
21866 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21867 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21868 if (!SWIG_IsOK(ecode2)) {
21869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21870 }
21871 arg2 = static_cast< bool >(val2);
21872 if (arg1) (arg1)->m_leftDown = arg2;
21873
21874 resultobj = SWIG_Py_Void();
21875 return resultobj;
21876 fail:
21877 return NULL;
21878 }
21879
21880
21881 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21882 PyObject *resultobj = 0;
21883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21884 bool result;
21885 void *argp1 = 0 ;
21886 int res1 = 0 ;
21887 PyObject *swig_obj[1] ;
21888
21889 if (!args) SWIG_fail;
21890 swig_obj[0] = args;
21891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21892 if (!SWIG_IsOK(res1)) {
21893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21894 }
21895 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21896 result = (bool) ((arg1)->m_leftDown);
21897 {
21898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21899 }
21900 return resultobj;
21901 fail:
21902 return NULL;
21903 }
21904
21905
21906 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21907 PyObject *resultobj = 0;
21908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21909 bool arg2 ;
21910 void *argp1 = 0 ;
21911 int res1 = 0 ;
21912 bool val2 ;
21913 int ecode2 = 0 ;
21914 PyObject *swig_obj[2] ;
21915
21916 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21918 if (!SWIG_IsOK(res1)) {
21919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21920 }
21921 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21922 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21923 if (!SWIG_IsOK(ecode2)) {
21924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21925 }
21926 arg2 = static_cast< bool >(val2);
21927 if (arg1) (arg1)->m_middleDown = arg2;
21928
21929 resultobj = SWIG_Py_Void();
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21937 PyObject *resultobj = 0;
21938 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21939 bool result;
21940 void *argp1 = 0 ;
21941 int res1 = 0 ;
21942 PyObject *swig_obj[1] ;
21943
21944 if (!args) SWIG_fail;
21945 swig_obj[0] = args;
21946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21947 if (!SWIG_IsOK(res1)) {
21948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21949 }
21950 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21951 result = (bool) ((arg1)->m_middleDown);
21952 {
21953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21954 }
21955 return resultobj;
21956 fail:
21957 return NULL;
21958 }
21959
21960
21961 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21962 PyObject *resultobj = 0;
21963 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21964 bool arg2 ;
21965 void *argp1 = 0 ;
21966 int res1 = 0 ;
21967 bool val2 ;
21968 int ecode2 = 0 ;
21969 PyObject *swig_obj[2] ;
21970
21971 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21973 if (!SWIG_IsOK(res1)) {
21974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21975 }
21976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21977 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21978 if (!SWIG_IsOK(ecode2)) {
21979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21980 }
21981 arg2 = static_cast< bool >(val2);
21982 if (arg1) (arg1)->m_rightDown = arg2;
21983
21984 resultobj = SWIG_Py_Void();
21985 return resultobj;
21986 fail:
21987 return NULL;
21988 }
21989
21990
21991 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21992 PyObject *resultobj = 0;
21993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21994 bool result;
21995 void *argp1 = 0 ;
21996 int res1 = 0 ;
21997 PyObject *swig_obj[1] ;
21998
21999 if (!args) SWIG_fail;
22000 swig_obj[0] = args;
22001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22002 if (!SWIG_IsOK(res1)) {
22003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22004 }
22005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22006 result = (bool) ((arg1)->m_rightDown);
22007 {
22008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22009 }
22010 return resultobj;
22011 fail:
22012 return NULL;
22013 }
22014
22015
22016 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22017 PyObject *resultobj = 0;
22018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22019 bool arg2 ;
22020 void *argp1 = 0 ;
22021 int res1 = 0 ;
22022 bool val2 ;
22023 int ecode2 = 0 ;
22024 PyObject *swig_obj[2] ;
22025
22026 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22028 if (!SWIG_IsOK(res1)) {
22029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22030 }
22031 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22032 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22033 if (!SWIG_IsOK(ecode2)) {
22034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22035 }
22036 arg2 = static_cast< bool >(val2);
22037 if (arg1) (arg1)->m_controlDown = arg2;
22038
22039 resultobj = SWIG_Py_Void();
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22047 PyObject *resultobj = 0;
22048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22049 bool result;
22050 void *argp1 = 0 ;
22051 int res1 = 0 ;
22052 PyObject *swig_obj[1] ;
22053
22054 if (!args) SWIG_fail;
22055 swig_obj[0] = args;
22056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22057 if (!SWIG_IsOK(res1)) {
22058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22059 }
22060 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22061 result = (bool) ((arg1)->m_controlDown);
22062 {
22063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22064 }
22065 return resultobj;
22066 fail:
22067 return NULL;
22068 }
22069
22070
22071 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22072 PyObject *resultobj = 0;
22073 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22074 bool arg2 ;
22075 void *argp1 = 0 ;
22076 int res1 = 0 ;
22077 bool val2 ;
22078 int ecode2 = 0 ;
22079 PyObject *swig_obj[2] ;
22080
22081 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22083 if (!SWIG_IsOK(res1)) {
22084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22085 }
22086 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22087 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22088 if (!SWIG_IsOK(ecode2)) {
22089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22090 }
22091 arg2 = static_cast< bool >(val2);
22092 if (arg1) (arg1)->m_shiftDown = arg2;
22093
22094 resultobj = SWIG_Py_Void();
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22102 PyObject *resultobj = 0;
22103 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22104 bool result;
22105 void *argp1 = 0 ;
22106 int res1 = 0 ;
22107 PyObject *swig_obj[1] ;
22108
22109 if (!args) SWIG_fail;
22110 swig_obj[0] = args;
22111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22112 if (!SWIG_IsOK(res1)) {
22113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22114 }
22115 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22116 result = (bool) ((arg1)->m_shiftDown);
22117 {
22118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22119 }
22120 return resultobj;
22121 fail:
22122 return NULL;
22123 }
22124
22125
22126 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22127 PyObject *resultobj = 0;
22128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22129 bool arg2 ;
22130 void *argp1 = 0 ;
22131 int res1 = 0 ;
22132 bool val2 ;
22133 int ecode2 = 0 ;
22134 PyObject *swig_obj[2] ;
22135
22136 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22138 if (!SWIG_IsOK(res1)) {
22139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22140 }
22141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22142 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22143 if (!SWIG_IsOK(ecode2)) {
22144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22145 }
22146 arg2 = static_cast< bool >(val2);
22147 if (arg1) (arg1)->m_altDown = arg2;
22148
22149 resultobj = SWIG_Py_Void();
22150 return resultobj;
22151 fail:
22152 return NULL;
22153 }
22154
22155
22156 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22157 PyObject *resultobj = 0;
22158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22159 bool result;
22160 void *argp1 = 0 ;
22161 int res1 = 0 ;
22162 PyObject *swig_obj[1] ;
22163
22164 if (!args) SWIG_fail;
22165 swig_obj[0] = args;
22166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22167 if (!SWIG_IsOK(res1)) {
22168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22169 }
22170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22171 result = (bool) ((arg1)->m_altDown);
22172 {
22173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22174 }
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *resultobj = 0;
22183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22184 bool arg2 ;
22185 void *argp1 = 0 ;
22186 int res1 = 0 ;
22187 bool val2 ;
22188 int ecode2 = 0 ;
22189 PyObject *swig_obj[2] ;
22190
22191 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22193 if (!SWIG_IsOK(res1)) {
22194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22195 }
22196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22197 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22198 if (!SWIG_IsOK(ecode2)) {
22199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22200 }
22201 arg2 = static_cast< bool >(val2);
22202 if (arg1) (arg1)->m_metaDown = arg2;
22203
22204 resultobj = SWIG_Py_Void();
22205 return resultobj;
22206 fail:
22207 return NULL;
22208 }
22209
22210
22211 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22212 PyObject *resultobj = 0;
22213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22214 bool result;
22215 void *argp1 = 0 ;
22216 int res1 = 0 ;
22217 PyObject *swig_obj[1] ;
22218
22219 if (!args) SWIG_fail;
22220 swig_obj[0] = args;
22221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22222 if (!SWIG_IsOK(res1)) {
22223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22224 }
22225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22226 result = (bool) ((arg1)->m_metaDown);
22227 {
22228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22229 }
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22237 PyObject *resultobj = 0;
22238 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22239 int arg2 ;
22240 void *argp1 = 0 ;
22241 int res1 = 0 ;
22242 int val2 ;
22243 int ecode2 = 0 ;
22244 PyObject *swig_obj[2] ;
22245
22246 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22248 if (!SWIG_IsOK(res1)) {
22249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22250 }
22251 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22252 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22253 if (!SWIG_IsOK(ecode2)) {
22254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22255 }
22256 arg2 = static_cast< int >(val2);
22257 if (arg1) (arg1)->m_wheelRotation = arg2;
22258
22259 resultobj = SWIG_Py_Void();
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22267 PyObject *resultobj = 0;
22268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22269 int result;
22270 void *argp1 = 0 ;
22271 int res1 = 0 ;
22272 PyObject *swig_obj[1] ;
22273
22274 if (!args) SWIG_fail;
22275 swig_obj[0] = args;
22276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22277 if (!SWIG_IsOK(res1)) {
22278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22279 }
22280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22281 result = (int) ((arg1)->m_wheelRotation);
22282 resultobj = SWIG_From_int(static_cast< int >(result));
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22290 PyObject *resultobj = 0;
22291 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22292 int arg2 ;
22293 void *argp1 = 0 ;
22294 int res1 = 0 ;
22295 int val2 ;
22296 int ecode2 = 0 ;
22297 PyObject *swig_obj[2] ;
22298
22299 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22301 if (!SWIG_IsOK(res1)) {
22302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22303 }
22304 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22305 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22306 if (!SWIG_IsOK(ecode2)) {
22307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22308 }
22309 arg2 = static_cast< int >(val2);
22310 if (arg1) (arg1)->m_wheelDelta = arg2;
22311
22312 resultobj = SWIG_Py_Void();
22313 return resultobj;
22314 fail:
22315 return NULL;
22316 }
22317
22318
22319 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22320 PyObject *resultobj = 0;
22321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22322 int result;
22323 void *argp1 = 0 ;
22324 int res1 = 0 ;
22325 PyObject *swig_obj[1] ;
22326
22327 if (!args) SWIG_fail;
22328 swig_obj[0] = args;
22329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22330 if (!SWIG_IsOK(res1)) {
22331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22332 }
22333 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22334 result = (int) ((arg1)->m_wheelDelta);
22335 resultobj = SWIG_From_int(static_cast< int >(result));
22336 return resultobj;
22337 fail:
22338 return NULL;
22339 }
22340
22341
22342 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22343 PyObject *resultobj = 0;
22344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22345 int arg2 ;
22346 void *argp1 = 0 ;
22347 int res1 = 0 ;
22348 int val2 ;
22349 int ecode2 = 0 ;
22350 PyObject *swig_obj[2] ;
22351
22352 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22354 if (!SWIG_IsOK(res1)) {
22355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22356 }
22357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22358 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22359 if (!SWIG_IsOK(ecode2)) {
22360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22361 }
22362 arg2 = static_cast< int >(val2);
22363 if (arg1) (arg1)->m_linesPerAction = arg2;
22364
22365 resultobj = SWIG_Py_Void();
22366 return resultobj;
22367 fail:
22368 return NULL;
22369 }
22370
22371
22372 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22373 PyObject *resultobj = 0;
22374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22375 int result;
22376 void *argp1 = 0 ;
22377 int res1 = 0 ;
22378 PyObject *swig_obj[1] ;
22379
22380 if (!args) SWIG_fail;
22381 swig_obj[0] = args;
22382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22383 if (!SWIG_IsOK(res1)) {
22384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22385 }
22386 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22387 result = (int) ((arg1)->m_linesPerAction);
22388 resultobj = SWIG_From_int(static_cast< int >(result));
22389 return resultobj;
22390 fail:
22391 return NULL;
22392 }
22393
22394
22395 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22396 PyObject *obj;
22397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22398 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22399 return SWIG_Py_Void();
22400 }
22401
22402 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22403 return SWIG_Python_InitShadowInstance(args);
22404 }
22405
22406 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22407 PyObject *resultobj = 0;
22408 int arg1 = (int) 0 ;
22409 int arg2 = (int) 0 ;
22410 wxSetCursorEvent *result = 0 ;
22411 int val1 ;
22412 int ecode1 = 0 ;
22413 int val2 ;
22414 int ecode2 = 0 ;
22415 PyObject * obj0 = 0 ;
22416 PyObject * obj1 = 0 ;
22417 char * kwnames[] = {
22418 (char *) "x",(char *) "y", NULL
22419 };
22420
22421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22422 if (obj0) {
22423 ecode1 = SWIG_AsVal_int(obj0, &val1);
22424 if (!SWIG_IsOK(ecode1)) {
22425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22426 }
22427 arg1 = static_cast< int >(val1);
22428 }
22429 if (obj1) {
22430 ecode2 = SWIG_AsVal_int(obj1, &val2);
22431 if (!SWIG_IsOK(ecode2)) {
22432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22433 }
22434 arg2 = static_cast< int >(val2);
22435 }
22436 {
22437 PyThreadState* __tstate = wxPyBeginAllowThreads();
22438 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22439 wxPyEndAllowThreads(__tstate);
22440 if (PyErr_Occurred()) SWIG_fail;
22441 }
22442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22443 return resultobj;
22444 fail:
22445 return NULL;
22446 }
22447
22448
22449 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22450 PyObject *resultobj = 0;
22451 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22452 int result;
22453 void *argp1 = 0 ;
22454 int res1 = 0 ;
22455 PyObject *swig_obj[1] ;
22456
22457 if (!args) SWIG_fail;
22458 swig_obj[0] = args;
22459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22460 if (!SWIG_IsOK(res1)) {
22461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22462 }
22463 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22464 {
22465 PyThreadState* __tstate = wxPyBeginAllowThreads();
22466 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22467 wxPyEndAllowThreads(__tstate);
22468 if (PyErr_Occurred()) SWIG_fail;
22469 }
22470 resultobj = SWIG_From_int(static_cast< int >(result));
22471 return resultobj;
22472 fail:
22473 return NULL;
22474 }
22475
22476
22477 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22478 PyObject *resultobj = 0;
22479 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22480 int result;
22481 void *argp1 = 0 ;
22482 int res1 = 0 ;
22483 PyObject *swig_obj[1] ;
22484
22485 if (!args) SWIG_fail;
22486 swig_obj[0] = args;
22487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22488 if (!SWIG_IsOK(res1)) {
22489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22490 }
22491 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22492 {
22493 PyThreadState* __tstate = wxPyBeginAllowThreads();
22494 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22495 wxPyEndAllowThreads(__tstate);
22496 if (PyErr_Occurred()) SWIG_fail;
22497 }
22498 resultobj = SWIG_From_int(static_cast< int >(result));
22499 return resultobj;
22500 fail:
22501 return NULL;
22502 }
22503
22504
22505 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22506 PyObject *resultobj = 0;
22507 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22508 wxCursor *arg2 = 0 ;
22509 void *argp1 = 0 ;
22510 int res1 = 0 ;
22511 void *argp2 = 0 ;
22512 int res2 = 0 ;
22513 PyObject * obj0 = 0 ;
22514 PyObject * obj1 = 0 ;
22515 char * kwnames[] = {
22516 (char *) "self",(char *) "cursor", NULL
22517 };
22518
22519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22521 if (!SWIG_IsOK(res1)) {
22522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22523 }
22524 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22525 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22526 if (!SWIG_IsOK(res2)) {
22527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22528 }
22529 if (!argp2) {
22530 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22531 }
22532 arg2 = reinterpret_cast< wxCursor * >(argp2);
22533 {
22534 PyThreadState* __tstate = wxPyBeginAllowThreads();
22535 (arg1)->SetCursor((wxCursor const &)*arg2);
22536 wxPyEndAllowThreads(__tstate);
22537 if (PyErr_Occurred()) SWIG_fail;
22538 }
22539 resultobj = SWIG_Py_Void();
22540 return resultobj;
22541 fail:
22542 return NULL;
22543 }
22544
22545
22546 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22547 PyObject *resultobj = 0;
22548 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22549 wxCursor *result = 0 ;
22550 void *argp1 = 0 ;
22551 int res1 = 0 ;
22552 PyObject *swig_obj[1] ;
22553
22554 if (!args) SWIG_fail;
22555 swig_obj[0] = args;
22556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22557 if (!SWIG_IsOK(res1)) {
22558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22559 }
22560 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22561 {
22562 PyThreadState* __tstate = wxPyBeginAllowThreads();
22563 {
22564 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22565 result = (wxCursor *) &_result_ref;
22566 }
22567 wxPyEndAllowThreads(__tstate);
22568 if (PyErr_Occurred()) SWIG_fail;
22569 }
22570 {
22571 wxCursor* resultptr = new wxCursor(*result);
22572 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22573 }
22574 return resultobj;
22575 fail:
22576 return NULL;
22577 }
22578
22579
22580 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22581 PyObject *resultobj = 0;
22582 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22583 bool result;
22584 void *argp1 = 0 ;
22585 int res1 = 0 ;
22586 PyObject *swig_obj[1] ;
22587
22588 if (!args) SWIG_fail;
22589 swig_obj[0] = args;
22590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22591 if (!SWIG_IsOK(res1)) {
22592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22593 }
22594 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22595 {
22596 PyThreadState* __tstate = wxPyBeginAllowThreads();
22597 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22598 wxPyEndAllowThreads(__tstate);
22599 if (PyErr_Occurred()) SWIG_fail;
22600 }
22601 {
22602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22603 }
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22611 PyObject *obj;
22612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22613 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22614 return SWIG_Py_Void();
22615 }
22616
22617 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22618 return SWIG_Python_InitShadowInstance(args);
22619 }
22620
22621 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22622 PyObject *resultobj = 0;
22623 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22624 wxKeyEvent *result = 0 ;
22625 int val1 ;
22626 int ecode1 = 0 ;
22627 PyObject * obj0 = 0 ;
22628 char * kwnames[] = {
22629 (char *) "eventType", NULL
22630 };
22631
22632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22633 if (obj0) {
22634 ecode1 = SWIG_AsVal_int(obj0, &val1);
22635 if (!SWIG_IsOK(ecode1)) {
22636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22637 }
22638 arg1 = static_cast< wxEventType >(val1);
22639 }
22640 {
22641 PyThreadState* __tstate = wxPyBeginAllowThreads();
22642 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22643 wxPyEndAllowThreads(__tstate);
22644 if (PyErr_Occurred()) SWIG_fail;
22645 }
22646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22647 return resultobj;
22648 fail:
22649 return NULL;
22650 }
22651
22652
22653 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22654 PyObject *resultobj = 0;
22655 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22656 int result;
22657 void *argp1 = 0 ;
22658 int res1 = 0 ;
22659 PyObject *swig_obj[1] ;
22660
22661 if (!args) SWIG_fail;
22662 swig_obj[0] = args;
22663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22664 if (!SWIG_IsOK(res1)) {
22665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22666 }
22667 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22668 {
22669 PyThreadState* __tstate = wxPyBeginAllowThreads();
22670 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22671 wxPyEndAllowThreads(__tstate);
22672 if (PyErr_Occurred()) SWIG_fail;
22673 }
22674 resultobj = SWIG_From_int(static_cast< int >(result));
22675 return resultobj;
22676 fail:
22677 return NULL;
22678 }
22679
22680
22681 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22682 PyObject *resultobj = 0;
22683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22684 bool result;
22685 void *argp1 = 0 ;
22686 int res1 = 0 ;
22687 PyObject *swig_obj[1] ;
22688
22689 if (!args) SWIG_fail;
22690 swig_obj[0] = args;
22691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22692 if (!SWIG_IsOK(res1)) {
22693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22694 }
22695 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22696 {
22697 PyThreadState* __tstate = wxPyBeginAllowThreads();
22698 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22699 wxPyEndAllowThreads(__tstate);
22700 if (PyErr_Occurred()) SWIG_fail;
22701 }
22702 {
22703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22704 }
22705 return resultobj;
22706 fail:
22707 return NULL;
22708 }
22709
22710
22711 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22712 PyObject *resultobj = 0;
22713 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22714 bool result;
22715 void *argp1 = 0 ;
22716 int res1 = 0 ;
22717 PyObject *swig_obj[1] ;
22718
22719 if (!args) SWIG_fail;
22720 swig_obj[0] = args;
22721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22722 if (!SWIG_IsOK(res1)) {
22723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22724 }
22725 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22726 {
22727 PyThreadState* __tstate = wxPyBeginAllowThreads();
22728 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22729 wxPyEndAllowThreads(__tstate);
22730 if (PyErr_Occurred()) SWIG_fail;
22731 }
22732 {
22733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22734 }
22735 return resultobj;
22736 fail:
22737 return NULL;
22738 }
22739
22740
22741 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22742 PyObject *resultobj = 0;
22743 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22744 bool result;
22745 void *argp1 = 0 ;
22746 int res1 = 0 ;
22747 PyObject *swig_obj[1] ;
22748
22749 if (!args) SWIG_fail;
22750 swig_obj[0] = args;
22751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22752 if (!SWIG_IsOK(res1)) {
22753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22754 }
22755 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22756 {
22757 PyThreadState* __tstate = wxPyBeginAllowThreads();
22758 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 {
22763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22764 }
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22772 PyObject *resultobj = 0;
22773 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22774 bool result;
22775 void *argp1 = 0 ;
22776 int res1 = 0 ;
22777 PyObject *swig_obj[1] ;
22778
22779 if (!args) SWIG_fail;
22780 swig_obj[0] = args;
22781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22782 if (!SWIG_IsOK(res1)) {
22783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22784 }
22785 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22786 {
22787 PyThreadState* __tstate = wxPyBeginAllowThreads();
22788 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22789 wxPyEndAllowThreads(__tstate);
22790 if (PyErr_Occurred()) SWIG_fail;
22791 }
22792 {
22793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22794 }
22795 return resultobj;
22796 fail:
22797 return NULL;
22798 }
22799
22800
22801 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802 PyObject *resultobj = 0;
22803 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22804 bool result;
22805 void *argp1 = 0 ;
22806 int res1 = 0 ;
22807 PyObject *swig_obj[1] ;
22808
22809 if (!args) SWIG_fail;
22810 swig_obj[0] = args;
22811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22812 if (!SWIG_IsOK(res1)) {
22813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22814 }
22815 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22816 {
22817 PyThreadState* __tstate = wxPyBeginAllowThreads();
22818 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22819 wxPyEndAllowThreads(__tstate);
22820 if (PyErr_Occurred()) SWIG_fail;
22821 }
22822 {
22823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22824 }
22825 return resultobj;
22826 fail:
22827 return NULL;
22828 }
22829
22830
22831 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22832 PyObject *resultobj = 0;
22833 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22834 bool result;
22835 void *argp1 = 0 ;
22836 int res1 = 0 ;
22837 PyObject *swig_obj[1] ;
22838
22839 if (!args) SWIG_fail;
22840 swig_obj[0] = args;
22841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22842 if (!SWIG_IsOK(res1)) {
22843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22844 }
22845 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22846 {
22847 PyThreadState* __tstate = wxPyBeginAllowThreads();
22848 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22849 wxPyEndAllowThreads(__tstate);
22850 if (PyErr_Occurred()) SWIG_fail;
22851 }
22852 {
22853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22854 }
22855 return resultobj;
22856 fail:
22857 return NULL;
22858 }
22859
22860
22861 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22862 PyObject *resultobj = 0;
22863 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22864 int result;
22865 void *argp1 = 0 ;
22866 int res1 = 0 ;
22867 PyObject *swig_obj[1] ;
22868
22869 if (!args) SWIG_fail;
22870 swig_obj[0] = args;
22871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22872 if (!SWIG_IsOK(res1)) {
22873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22874 }
22875 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22876 {
22877 PyThreadState* __tstate = wxPyBeginAllowThreads();
22878 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22879 wxPyEndAllowThreads(__tstate);
22880 if (PyErr_Occurred()) SWIG_fail;
22881 }
22882 resultobj = SWIG_From_int(static_cast< int >(result));
22883 return resultobj;
22884 fail:
22885 return NULL;
22886 }
22887
22888
22889 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22890 PyObject *resultobj = 0;
22891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22892 int result;
22893 void *argp1 = 0 ;
22894 int res1 = 0 ;
22895 PyObject *swig_obj[1] ;
22896
22897 if (!args) SWIG_fail;
22898 swig_obj[0] = args;
22899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22900 if (!SWIG_IsOK(res1)) {
22901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22902 }
22903 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22904 {
22905 PyThreadState* __tstate = wxPyBeginAllowThreads();
22906 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22907 wxPyEndAllowThreads(__tstate);
22908 if (PyErr_Occurred()) SWIG_fail;
22909 }
22910 resultobj = SWIG_From_int(static_cast< int >(result));
22911 return resultobj;
22912 fail:
22913 return NULL;
22914 }
22915
22916
22917 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22918 PyObject *resultobj = 0;
22919 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22920 int arg2 ;
22921 void *argp1 = 0 ;
22922 int res1 = 0 ;
22923 int val2 ;
22924 int ecode2 = 0 ;
22925 PyObject * obj0 = 0 ;
22926 PyObject * obj1 = 0 ;
22927 char * kwnames[] = {
22928 (char *) "self",(char *) "uniChar", NULL
22929 };
22930
22931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22933 if (!SWIG_IsOK(res1)) {
22934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22935 }
22936 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22937 ecode2 = SWIG_AsVal_int(obj1, &val2);
22938 if (!SWIG_IsOK(ecode2)) {
22939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22940 }
22941 arg2 = static_cast< int >(val2);
22942 {
22943 PyThreadState* __tstate = wxPyBeginAllowThreads();
22944 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22945 wxPyEndAllowThreads(__tstate);
22946 if (PyErr_Occurred()) SWIG_fail;
22947 }
22948 resultobj = SWIG_Py_Void();
22949 return resultobj;
22950 fail:
22951 return NULL;
22952 }
22953
22954
22955 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22956 PyObject *resultobj = 0;
22957 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22958 unsigned int result;
22959 void *argp1 = 0 ;
22960 int res1 = 0 ;
22961 PyObject *swig_obj[1] ;
22962
22963 if (!args) SWIG_fail;
22964 swig_obj[0] = args;
22965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22966 if (!SWIG_IsOK(res1)) {
22967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22968 }
22969 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22970 {
22971 PyThreadState* __tstate = wxPyBeginAllowThreads();
22972 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22973 wxPyEndAllowThreads(__tstate);
22974 if (PyErr_Occurred()) SWIG_fail;
22975 }
22976 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22977 return resultobj;
22978 fail:
22979 return NULL;
22980 }
22981
22982
22983 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22984 PyObject *resultobj = 0;
22985 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22986 unsigned int result;
22987 void *argp1 = 0 ;
22988 int res1 = 0 ;
22989 PyObject *swig_obj[1] ;
22990
22991 if (!args) SWIG_fail;
22992 swig_obj[0] = args;
22993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22994 if (!SWIG_IsOK(res1)) {
22995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22996 }
22997 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22998 {
22999 PyThreadState* __tstate = wxPyBeginAllowThreads();
23000 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23001 wxPyEndAllowThreads(__tstate);
23002 if (PyErr_Occurred()) SWIG_fail;
23003 }
23004 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23005 return resultobj;
23006 fail:
23007 return NULL;
23008 }
23009
23010
23011 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23012 PyObject *resultobj = 0;
23013 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23014 wxPoint result;
23015 void *argp1 = 0 ;
23016 int res1 = 0 ;
23017 PyObject *swig_obj[1] ;
23018
23019 if (!args) SWIG_fail;
23020 swig_obj[0] = args;
23021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23022 if (!SWIG_IsOK(res1)) {
23023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23024 }
23025 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23026 {
23027 PyThreadState* __tstate = wxPyBeginAllowThreads();
23028 result = (arg1)->GetPosition();
23029 wxPyEndAllowThreads(__tstate);
23030 if (PyErr_Occurred()) SWIG_fail;
23031 }
23032 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23040 PyObject *resultobj = 0;
23041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23042 long *arg2 = (long *) 0 ;
23043 long *arg3 = (long *) 0 ;
23044 void *argp1 = 0 ;
23045 int res1 = 0 ;
23046 long temp2 ;
23047 int res2 = SWIG_TMPOBJ ;
23048 long temp3 ;
23049 int res3 = SWIG_TMPOBJ ;
23050 PyObject *swig_obj[1] ;
23051
23052 arg2 = &temp2;
23053 arg3 = &temp3;
23054 if (!args) SWIG_fail;
23055 swig_obj[0] = args;
23056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23057 if (!SWIG_IsOK(res1)) {
23058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23059 }
23060 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23061 {
23062 PyThreadState* __tstate = wxPyBeginAllowThreads();
23063 (arg1)->GetPosition(arg2,arg3);
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 resultobj = SWIG_Py_Void();
23068 if (SWIG_IsTmpObj(res2)) {
23069 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23070 } else {
23071 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23072 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23073 }
23074 if (SWIG_IsTmpObj(res3)) {
23075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23076 } else {
23077 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23079 }
23080 return resultobj;
23081 fail:
23082 return NULL;
23083 }
23084
23085
23086 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23087 PyObject *resultobj = 0;
23088 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23089 int result;
23090 void *argp1 = 0 ;
23091 int res1 = 0 ;
23092 PyObject *swig_obj[1] ;
23093
23094 if (!args) SWIG_fail;
23095 swig_obj[0] = args;
23096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23097 if (!SWIG_IsOK(res1)) {
23098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23099 }
23100 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23101 {
23102 PyThreadState* __tstate = wxPyBeginAllowThreads();
23103 result = (int)((wxKeyEvent const *)arg1)->GetX();
23104 wxPyEndAllowThreads(__tstate);
23105 if (PyErr_Occurred()) SWIG_fail;
23106 }
23107 resultobj = SWIG_From_int(static_cast< int >(result));
23108 return resultobj;
23109 fail:
23110 return NULL;
23111 }
23112
23113
23114 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23115 PyObject *resultobj = 0;
23116 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23117 int result;
23118 void *argp1 = 0 ;
23119 int res1 = 0 ;
23120 PyObject *swig_obj[1] ;
23121
23122 if (!args) SWIG_fail;
23123 swig_obj[0] = args;
23124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23125 if (!SWIG_IsOK(res1)) {
23126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23127 }
23128 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23129 {
23130 PyThreadState* __tstate = wxPyBeginAllowThreads();
23131 result = (int)((wxKeyEvent const *)arg1)->GetY();
23132 wxPyEndAllowThreads(__tstate);
23133 if (PyErr_Occurred()) SWIG_fail;
23134 }
23135 resultobj = SWIG_From_int(static_cast< int >(result));
23136 return resultobj;
23137 fail:
23138 return NULL;
23139 }
23140
23141
23142 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23143 PyObject *resultobj = 0;
23144 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23145 int arg2 ;
23146 void *argp1 = 0 ;
23147 int res1 = 0 ;
23148 int val2 ;
23149 int ecode2 = 0 ;
23150 PyObject *swig_obj[2] ;
23151
23152 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23154 if (!SWIG_IsOK(res1)) {
23155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23156 }
23157 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23158 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23159 if (!SWIG_IsOK(ecode2)) {
23160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23161 }
23162 arg2 = static_cast< int >(val2);
23163 if (arg1) (arg1)->m_x = arg2;
23164
23165 resultobj = SWIG_Py_Void();
23166 return resultobj;
23167 fail:
23168 return NULL;
23169 }
23170
23171
23172 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23173 PyObject *resultobj = 0;
23174 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23175 int result;
23176 void *argp1 = 0 ;
23177 int res1 = 0 ;
23178 PyObject *swig_obj[1] ;
23179
23180 if (!args) SWIG_fail;
23181 swig_obj[0] = args;
23182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23183 if (!SWIG_IsOK(res1)) {
23184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23185 }
23186 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23187 result = (int) ((arg1)->m_x);
23188 resultobj = SWIG_From_int(static_cast< int >(result));
23189 return resultobj;
23190 fail:
23191 return NULL;
23192 }
23193
23194
23195 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23196 PyObject *resultobj = 0;
23197 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23198 int arg2 ;
23199 void *argp1 = 0 ;
23200 int res1 = 0 ;
23201 int val2 ;
23202 int ecode2 = 0 ;
23203 PyObject *swig_obj[2] ;
23204
23205 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23207 if (!SWIG_IsOK(res1)) {
23208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23209 }
23210 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23211 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23212 if (!SWIG_IsOK(ecode2)) {
23213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23214 }
23215 arg2 = static_cast< int >(val2);
23216 if (arg1) (arg1)->m_y = arg2;
23217
23218 resultobj = SWIG_Py_Void();
23219 return resultobj;
23220 fail:
23221 return NULL;
23222 }
23223
23224
23225 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23226 PyObject *resultobj = 0;
23227 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23228 int result;
23229 void *argp1 = 0 ;
23230 int res1 = 0 ;
23231 PyObject *swig_obj[1] ;
23232
23233 if (!args) SWIG_fail;
23234 swig_obj[0] = args;
23235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23236 if (!SWIG_IsOK(res1)) {
23237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23238 }
23239 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23240 result = (int) ((arg1)->m_y);
23241 resultobj = SWIG_From_int(static_cast< int >(result));
23242 return resultobj;
23243 fail:
23244 return NULL;
23245 }
23246
23247
23248 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23249 PyObject *resultobj = 0;
23250 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23251 long arg2 ;
23252 void *argp1 = 0 ;
23253 int res1 = 0 ;
23254 long val2 ;
23255 int ecode2 = 0 ;
23256 PyObject *swig_obj[2] ;
23257
23258 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23260 if (!SWIG_IsOK(res1)) {
23261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23262 }
23263 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23264 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23265 if (!SWIG_IsOK(ecode2)) {
23266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23267 }
23268 arg2 = static_cast< long >(val2);
23269 if (arg1) (arg1)->m_keyCode = arg2;
23270
23271 resultobj = SWIG_Py_Void();
23272 return resultobj;
23273 fail:
23274 return NULL;
23275 }
23276
23277
23278 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23279 PyObject *resultobj = 0;
23280 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23281 long result;
23282 void *argp1 = 0 ;
23283 int res1 = 0 ;
23284 PyObject *swig_obj[1] ;
23285
23286 if (!args) SWIG_fail;
23287 swig_obj[0] = args;
23288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23289 if (!SWIG_IsOK(res1)) {
23290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23291 }
23292 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23293 result = (long) ((arg1)->m_keyCode);
23294 resultobj = SWIG_From_long(static_cast< long >(result));
23295 return resultobj;
23296 fail:
23297 return NULL;
23298 }
23299
23300
23301 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23302 PyObject *resultobj = 0;
23303 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23304 bool arg2 ;
23305 void *argp1 = 0 ;
23306 int res1 = 0 ;
23307 bool val2 ;
23308 int ecode2 = 0 ;
23309 PyObject *swig_obj[2] ;
23310
23311 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23313 if (!SWIG_IsOK(res1)) {
23314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23315 }
23316 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23317 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23318 if (!SWIG_IsOK(ecode2)) {
23319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23320 }
23321 arg2 = static_cast< bool >(val2);
23322 if (arg1) (arg1)->m_controlDown = arg2;
23323
23324 resultobj = SWIG_Py_Void();
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23332 PyObject *resultobj = 0;
23333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23334 bool result;
23335 void *argp1 = 0 ;
23336 int res1 = 0 ;
23337 PyObject *swig_obj[1] ;
23338
23339 if (!args) SWIG_fail;
23340 swig_obj[0] = args;
23341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23342 if (!SWIG_IsOK(res1)) {
23343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23344 }
23345 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23346 result = (bool) ((arg1)->m_controlDown);
23347 {
23348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23349 }
23350 return resultobj;
23351 fail:
23352 return NULL;
23353 }
23354
23355
23356 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23357 PyObject *resultobj = 0;
23358 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23359 bool arg2 ;
23360 void *argp1 = 0 ;
23361 int res1 = 0 ;
23362 bool val2 ;
23363 int ecode2 = 0 ;
23364 PyObject *swig_obj[2] ;
23365
23366 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23368 if (!SWIG_IsOK(res1)) {
23369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23370 }
23371 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23372 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23373 if (!SWIG_IsOK(ecode2)) {
23374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23375 }
23376 arg2 = static_cast< bool >(val2);
23377 if (arg1) (arg1)->m_shiftDown = arg2;
23378
23379 resultobj = SWIG_Py_Void();
23380 return resultobj;
23381 fail:
23382 return NULL;
23383 }
23384
23385
23386 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23387 PyObject *resultobj = 0;
23388 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23389 bool result;
23390 void *argp1 = 0 ;
23391 int res1 = 0 ;
23392 PyObject *swig_obj[1] ;
23393
23394 if (!args) SWIG_fail;
23395 swig_obj[0] = args;
23396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23397 if (!SWIG_IsOK(res1)) {
23398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23399 }
23400 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23401 result = (bool) ((arg1)->m_shiftDown);
23402 {
23403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23404 }
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412 PyObject *resultobj = 0;
23413 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23414 bool arg2 ;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 bool val2 ;
23418 int ecode2 = 0 ;
23419 PyObject *swig_obj[2] ;
23420
23421 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23423 if (!SWIG_IsOK(res1)) {
23424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23425 }
23426 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23427 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23428 if (!SWIG_IsOK(ecode2)) {
23429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23430 }
23431 arg2 = static_cast< bool >(val2);
23432 if (arg1) (arg1)->m_altDown = arg2;
23433
23434 resultobj = SWIG_Py_Void();
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *resultobj = 0;
23443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23444 bool result;
23445 void *argp1 = 0 ;
23446 int res1 = 0 ;
23447 PyObject *swig_obj[1] ;
23448
23449 if (!args) SWIG_fail;
23450 swig_obj[0] = args;
23451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23452 if (!SWIG_IsOK(res1)) {
23453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23454 }
23455 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23456 result = (bool) ((arg1)->m_altDown);
23457 {
23458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23459 }
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23467 PyObject *resultobj = 0;
23468 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23469 bool arg2 ;
23470 void *argp1 = 0 ;
23471 int res1 = 0 ;
23472 bool val2 ;
23473 int ecode2 = 0 ;
23474 PyObject *swig_obj[2] ;
23475
23476 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23478 if (!SWIG_IsOK(res1)) {
23479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23480 }
23481 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23482 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23483 if (!SWIG_IsOK(ecode2)) {
23484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23485 }
23486 arg2 = static_cast< bool >(val2);
23487 if (arg1) (arg1)->m_metaDown = arg2;
23488
23489 resultobj = SWIG_Py_Void();
23490 return resultobj;
23491 fail:
23492 return NULL;
23493 }
23494
23495
23496 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23497 PyObject *resultobj = 0;
23498 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23499 bool result;
23500 void *argp1 = 0 ;
23501 int res1 = 0 ;
23502 PyObject *swig_obj[1] ;
23503
23504 if (!args) SWIG_fail;
23505 swig_obj[0] = args;
23506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23507 if (!SWIG_IsOK(res1)) {
23508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23509 }
23510 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23511 result = (bool) ((arg1)->m_metaDown);
23512 {
23513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23514 }
23515 return resultobj;
23516 fail:
23517 return NULL;
23518 }
23519
23520
23521 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23522 PyObject *resultobj = 0;
23523 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23524 bool arg2 ;
23525 void *argp1 = 0 ;
23526 int res1 = 0 ;
23527 bool val2 ;
23528 int ecode2 = 0 ;
23529 PyObject *swig_obj[2] ;
23530
23531 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23533 if (!SWIG_IsOK(res1)) {
23534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23535 }
23536 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23537 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23538 if (!SWIG_IsOK(ecode2)) {
23539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23540 }
23541 arg2 = static_cast< bool >(val2);
23542 if (arg1) (arg1)->m_scanCode = arg2;
23543
23544 resultobj = SWIG_Py_Void();
23545 return resultobj;
23546 fail:
23547 return NULL;
23548 }
23549
23550
23551 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23552 PyObject *resultobj = 0;
23553 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23554 bool result;
23555 void *argp1 = 0 ;
23556 int res1 = 0 ;
23557 PyObject *swig_obj[1] ;
23558
23559 if (!args) SWIG_fail;
23560 swig_obj[0] = args;
23561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23562 if (!SWIG_IsOK(res1)) {
23563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23564 }
23565 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23566 result = (bool) ((arg1)->m_scanCode);
23567 {
23568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23569 }
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23577 PyObject *resultobj = 0;
23578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23579 unsigned int arg2 ;
23580 void *argp1 = 0 ;
23581 int res1 = 0 ;
23582 unsigned int val2 ;
23583 int ecode2 = 0 ;
23584 PyObject *swig_obj[2] ;
23585
23586 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23588 if (!SWIG_IsOK(res1)) {
23589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23590 }
23591 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23592 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23593 if (!SWIG_IsOK(ecode2)) {
23594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23595 }
23596 arg2 = static_cast< unsigned int >(val2);
23597 if (arg1) (arg1)->m_rawCode = arg2;
23598
23599 resultobj = SWIG_Py_Void();
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23607 PyObject *resultobj = 0;
23608 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23609 unsigned int result;
23610 void *argp1 = 0 ;
23611 int res1 = 0 ;
23612 PyObject *swig_obj[1] ;
23613
23614 if (!args) SWIG_fail;
23615 swig_obj[0] = args;
23616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23617 if (!SWIG_IsOK(res1)) {
23618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23619 }
23620 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23621 result = (unsigned int) ((arg1)->m_rawCode);
23622 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23623 return resultobj;
23624 fail:
23625 return NULL;
23626 }
23627
23628
23629 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23630 PyObject *resultobj = 0;
23631 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23632 unsigned int arg2 ;
23633 void *argp1 = 0 ;
23634 int res1 = 0 ;
23635 unsigned int val2 ;
23636 int ecode2 = 0 ;
23637 PyObject *swig_obj[2] ;
23638
23639 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23641 if (!SWIG_IsOK(res1)) {
23642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23643 }
23644 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23645 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23646 if (!SWIG_IsOK(ecode2)) {
23647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23648 }
23649 arg2 = static_cast< unsigned int >(val2);
23650 if (arg1) (arg1)->m_rawFlags = arg2;
23651
23652 resultobj = SWIG_Py_Void();
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23660 PyObject *resultobj = 0;
23661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23662 unsigned int result;
23663 void *argp1 = 0 ;
23664 int res1 = 0 ;
23665 PyObject *swig_obj[1] ;
23666
23667 if (!args) SWIG_fail;
23668 swig_obj[0] = args;
23669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23670 if (!SWIG_IsOK(res1)) {
23671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23672 }
23673 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23674 result = (unsigned int) ((arg1)->m_rawFlags);
23675 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23676 return resultobj;
23677 fail:
23678 return NULL;
23679 }
23680
23681
23682 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23683 PyObject *obj;
23684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23685 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23686 return SWIG_Py_Void();
23687 }
23688
23689 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23690 return SWIG_Python_InitShadowInstance(args);
23691 }
23692
23693 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23694 PyObject *resultobj = 0;
23695 wxSize const &arg1_defvalue = wxDefaultSize ;
23696 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23697 int arg2 = (int) 0 ;
23698 wxSizeEvent *result = 0 ;
23699 wxSize temp1 ;
23700 int val2 ;
23701 int ecode2 = 0 ;
23702 PyObject * obj0 = 0 ;
23703 PyObject * obj1 = 0 ;
23704 char * kwnames[] = {
23705 (char *) "sz",(char *) "winid", NULL
23706 };
23707
23708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23709 if (obj0) {
23710 {
23711 arg1 = &temp1;
23712 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23713 }
23714 }
23715 if (obj1) {
23716 ecode2 = SWIG_AsVal_int(obj1, &val2);
23717 if (!SWIG_IsOK(ecode2)) {
23718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23719 }
23720 arg2 = static_cast< int >(val2);
23721 }
23722 {
23723 PyThreadState* __tstate = wxPyBeginAllowThreads();
23724 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23725 wxPyEndAllowThreads(__tstate);
23726 if (PyErr_Occurred()) SWIG_fail;
23727 }
23728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23729 return resultobj;
23730 fail:
23731 return NULL;
23732 }
23733
23734
23735 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23736 PyObject *resultobj = 0;
23737 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23738 wxSize result;
23739 void *argp1 = 0 ;
23740 int res1 = 0 ;
23741 PyObject *swig_obj[1] ;
23742
23743 if (!args) SWIG_fail;
23744 swig_obj[0] = args;
23745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23746 if (!SWIG_IsOK(res1)) {
23747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23748 }
23749 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23750 {
23751 PyThreadState* __tstate = wxPyBeginAllowThreads();
23752 result = ((wxSizeEvent const *)arg1)->GetSize();
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23757 return resultobj;
23758 fail:
23759 return NULL;
23760 }
23761
23762
23763 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23764 PyObject *resultobj = 0;
23765 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23766 wxRect result;
23767 void *argp1 = 0 ;
23768 int res1 = 0 ;
23769 PyObject *swig_obj[1] ;
23770
23771 if (!args) SWIG_fail;
23772 swig_obj[0] = args;
23773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23774 if (!SWIG_IsOK(res1)) {
23775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23776 }
23777 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23778 {
23779 PyThreadState* __tstate = wxPyBeginAllowThreads();
23780 result = ((wxSizeEvent const *)arg1)->GetRect();
23781 wxPyEndAllowThreads(__tstate);
23782 if (PyErr_Occurred()) SWIG_fail;
23783 }
23784 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23785 return resultobj;
23786 fail:
23787 return NULL;
23788 }
23789
23790
23791 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23792 PyObject *resultobj = 0;
23793 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23794 wxRect arg2 ;
23795 void *argp1 = 0 ;
23796 int res1 = 0 ;
23797 void *argp2 ;
23798 int res2 = 0 ;
23799 PyObject * obj0 = 0 ;
23800 PyObject * obj1 = 0 ;
23801 char * kwnames[] = {
23802 (char *) "self",(char *) "rect", NULL
23803 };
23804
23805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23807 if (!SWIG_IsOK(res1)) {
23808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23809 }
23810 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23811 {
23812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23813 if (!SWIG_IsOK(res2)) {
23814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23815 }
23816 if (!argp2) {
23817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23818 } else {
23819 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23820 arg2 = *temp;
23821 if (SWIG_IsNewObj(res2)) delete temp;
23822 }
23823 }
23824 {
23825 PyThreadState* __tstate = wxPyBeginAllowThreads();
23826 (arg1)->SetRect(arg2);
23827 wxPyEndAllowThreads(__tstate);
23828 if (PyErr_Occurred()) SWIG_fail;
23829 }
23830 resultobj = SWIG_Py_Void();
23831 return resultobj;
23832 fail:
23833 return NULL;
23834 }
23835
23836
23837 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23838 PyObject *resultobj = 0;
23839 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23840 wxSize arg2 ;
23841 void *argp1 = 0 ;
23842 int res1 = 0 ;
23843 void *argp2 ;
23844 int res2 = 0 ;
23845 PyObject * obj0 = 0 ;
23846 PyObject * obj1 = 0 ;
23847 char * kwnames[] = {
23848 (char *) "self",(char *) "size", NULL
23849 };
23850
23851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23853 if (!SWIG_IsOK(res1)) {
23854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23855 }
23856 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23857 {
23858 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23859 if (!SWIG_IsOK(res2)) {
23860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23861 }
23862 if (!argp2) {
23863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23864 } else {
23865 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23866 arg2 = *temp;
23867 if (SWIG_IsNewObj(res2)) delete temp;
23868 }
23869 }
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 wxSizeEvent_SetSize(arg1,arg2);
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_Py_Void();
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *resultobj = 0;
23885 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23886 wxSize *arg2 = (wxSize *) 0 ;
23887 void *argp1 = 0 ;
23888 int res1 = 0 ;
23889 void *argp2 = 0 ;
23890 int res2 = 0 ;
23891 PyObject *swig_obj[2] ;
23892
23893 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23895 if (!SWIG_IsOK(res1)) {
23896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23897 }
23898 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23899 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23900 if (!SWIG_IsOK(res2)) {
23901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23902 }
23903 arg2 = reinterpret_cast< wxSize * >(argp2);
23904 if (arg1) (arg1)->m_size = *arg2;
23905
23906 resultobj = SWIG_Py_Void();
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23914 PyObject *resultobj = 0;
23915 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23916 wxSize *result = 0 ;
23917 void *argp1 = 0 ;
23918 int res1 = 0 ;
23919 PyObject *swig_obj[1] ;
23920
23921 if (!args) SWIG_fail;
23922 swig_obj[0] = args;
23923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23924 if (!SWIG_IsOK(res1)) {
23925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23926 }
23927 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23928 result = (wxSize *)& ((arg1)->m_size);
23929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23930 return resultobj;
23931 fail:
23932 return NULL;
23933 }
23934
23935
23936 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23937 PyObject *resultobj = 0;
23938 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23939 wxRect *arg2 = (wxRect *) 0 ;
23940 void *argp1 = 0 ;
23941 int res1 = 0 ;
23942 void *argp2 = 0 ;
23943 int res2 = 0 ;
23944 PyObject *swig_obj[2] ;
23945
23946 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23948 if (!SWIG_IsOK(res1)) {
23949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23950 }
23951 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23952 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23953 if (!SWIG_IsOK(res2)) {
23954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23955 }
23956 arg2 = reinterpret_cast< wxRect * >(argp2);
23957 if (arg1) (arg1)->m_rect = *arg2;
23958
23959 resultobj = SWIG_Py_Void();
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23967 PyObject *resultobj = 0;
23968 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23969 wxRect *result = 0 ;
23970 void *argp1 = 0 ;
23971 int res1 = 0 ;
23972 PyObject *swig_obj[1] ;
23973
23974 if (!args) SWIG_fail;
23975 swig_obj[0] = args;
23976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23977 if (!SWIG_IsOK(res1)) {
23978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23979 }
23980 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23981 result = (wxRect *)& ((arg1)->m_rect);
23982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23990 PyObject *obj;
23991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23992 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23993 return SWIG_Py_Void();
23994 }
23995
23996 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23997 return SWIG_Python_InitShadowInstance(args);
23998 }
23999
24000 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24001 PyObject *resultobj = 0;
24002 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24003 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24004 int arg2 = (int) 0 ;
24005 wxMoveEvent *result = 0 ;
24006 wxPoint temp1 ;
24007 int val2 ;
24008 int ecode2 = 0 ;
24009 PyObject * obj0 = 0 ;
24010 PyObject * obj1 = 0 ;
24011 char * kwnames[] = {
24012 (char *) "pos",(char *) "winid", NULL
24013 };
24014
24015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24016 if (obj0) {
24017 {
24018 arg1 = &temp1;
24019 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24020 }
24021 }
24022 if (obj1) {
24023 ecode2 = SWIG_AsVal_int(obj1, &val2);
24024 if (!SWIG_IsOK(ecode2)) {
24025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24026 }
24027 arg2 = static_cast< int >(val2);
24028 }
24029 {
24030 PyThreadState* __tstate = wxPyBeginAllowThreads();
24031 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24032 wxPyEndAllowThreads(__tstate);
24033 if (PyErr_Occurred()) SWIG_fail;
24034 }
24035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24036 return resultobj;
24037 fail:
24038 return NULL;
24039 }
24040
24041
24042 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24043 PyObject *resultobj = 0;
24044 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24045 wxPoint result;
24046 void *argp1 = 0 ;
24047 int res1 = 0 ;
24048 PyObject *swig_obj[1] ;
24049
24050 if (!args) SWIG_fail;
24051 swig_obj[0] = args;
24052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24053 if (!SWIG_IsOK(res1)) {
24054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24055 }
24056 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24057 {
24058 PyThreadState* __tstate = wxPyBeginAllowThreads();
24059 result = ((wxMoveEvent const *)arg1)->GetPosition();
24060 wxPyEndAllowThreads(__tstate);
24061 if (PyErr_Occurred()) SWIG_fail;
24062 }
24063 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24064 return resultobj;
24065 fail:
24066 return NULL;
24067 }
24068
24069
24070 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24071 PyObject *resultobj = 0;
24072 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24073 wxRect result;
24074 void *argp1 = 0 ;
24075 int res1 = 0 ;
24076 PyObject *swig_obj[1] ;
24077
24078 if (!args) SWIG_fail;
24079 swig_obj[0] = args;
24080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24081 if (!SWIG_IsOK(res1)) {
24082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24083 }
24084 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24085 {
24086 PyThreadState* __tstate = wxPyBeginAllowThreads();
24087 result = ((wxMoveEvent const *)arg1)->GetRect();
24088 wxPyEndAllowThreads(__tstate);
24089 if (PyErr_Occurred()) SWIG_fail;
24090 }
24091 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24092 return resultobj;
24093 fail:
24094 return NULL;
24095 }
24096
24097
24098 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24099 PyObject *resultobj = 0;
24100 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24101 wxRect *arg2 = 0 ;
24102 void *argp1 = 0 ;
24103 int res1 = 0 ;
24104 wxRect temp2 ;
24105 PyObject * obj0 = 0 ;
24106 PyObject * obj1 = 0 ;
24107 char * kwnames[] = {
24108 (char *) "self",(char *) "rect", NULL
24109 };
24110
24111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24113 if (!SWIG_IsOK(res1)) {
24114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24115 }
24116 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24117 {
24118 arg2 = &temp2;
24119 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24120 }
24121 {
24122 PyThreadState* __tstate = wxPyBeginAllowThreads();
24123 (arg1)->SetRect((wxRect const &)*arg2);
24124 wxPyEndAllowThreads(__tstate);
24125 if (PyErr_Occurred()) SWIG_fail;
24126 }
24127 resultobj = SWIG_Py_Void();
24128 return resultobj;
24129 fail:
24130 return NULL;
24131 }
24132
24133
24134 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24135 PyObject *resultobj = 0;
24136 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24137 wxPoint *arg2 = 0 ;
24138 void *argp1 = 0 ;
24139 int res1 = 0 ;
24140 wxPoint temp2 ;
24141 PyObject * obj0 = 0 ;
24142 PyObject * obj1 = 0 ;
24143 char * kwnames[] = {
24144 (char *) "self",(char *) "pos", NULL
24145 };
24146
24147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24149 if (!SWIG_IsOK(res1)) {
24150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24151 }
24152 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24153 {
24154 arg2 = &temp2;
24155 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24156 }
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 (arg1)->SetPosition((wxPoint const &)*arg2);
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 resultobj = SWIG_Py_Void();
24164 return resultobj;
24165 fail:
24166 return NULL;
24167 }
24168
24169
24170 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24171 PyObject *obj;
24172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24173 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24174 return SWIG_Py_Void();
24175 }
24176
24177 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24178 return SWIG_Python_InitShadowInstance(args);
24179 }
24180
24181 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24182 PyObject *resultobj = 0;
24183 int arg1 = (int) 0 ;
24184 wxPaintEvent *result = 0 ;
24185 int val1 ;
24186 int ecode1 = 0 ;
24187 PyObject * obj0 = 0 ;
24188 char * kwnames[] = {
24189 (char *) "Id", NULL
24190 };
24191
24192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24193 if (obj0) {
24194 ecode1 = SWIG_AsVal_int(obj0, &val1);
24195 if (!SWIG_IsOK(ecode1)) {
24196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24197 }
24198 arg1 = static_cast< int >(val1);
24199 }
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24214 PyObject *obj;
24215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24216 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24217 return SWIG_Py_Void();
24218 }
24219
24220 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24221 return SWIG_Python_InitShadowInstance(args);
24222 }
24223
24224 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj = 0;
24226 int arg1 = (int) 0 ;
24227 wxNcPaintEvent *result = 0 ;
24228 int val1 ;
24229 int ecode1 = 0 ;
24230 PyObject * obj0 = 0 ;
24231 char * kwnames[] = {
24232 (char *) "winid", NULL
24233 };
24234
24235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24236 if (obj0) {
24237 ecode1 = SWIG_AsVal_int(obj0, &val1);
24238 if (!SWIG_IsOK(ecode1)) {
24239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24240 }
24241 arg1 = static_cast< int >(val1);
24242 }
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24246 wxPyEndAllowThreads(__tstate);
24247 if (PyErr_Occurred()) SWIG_fail;
24248 }
24249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24250 return resultobj;
24251 fail:
24252 return NULL;
24253 }
24254
24255
24256 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24257 PyObject *obj;
24258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24259 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24260 return SWIG_Py_Void();
24261 }
24262
24263 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24264 return SWIG_Python_InitShadowInstance(args);
24265 }
24266
24267 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24268 PyObject *resultobj = 0;
24269 int arg1 = (int) 0 ;
24270 wxDC *arg2 = (wxDC *) NULL ;
24271 wxEraseEvent *result = 0 ;
24272 int val1 ;
24273 int ecode1 = 0 ;
24274 void *argp2 = 0 ;
24275 int res2 = 0 ;
24276 PyObject * obj0 = 0 ;
24277 PyObject * obj1 = 0 ;
24278 char * kwnames[] = {
24279 (char *) "Id",(char *) "dc", NULL
24280 };
24281
24282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24283 if (obj0) {
24284 ecode1 = SWIG_AsVal_int(obj0, &val1);
24285 if (!SWIG_IsOK(ecode1)) {
24286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24287 }
24288 arg1 = static_cast< int >(val1);
24289 }
24290 if (obj1) {
24291 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24292 if (!SWIG_IsOK(res2)) {
24293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24294 }
24295 arg2 = reinterpret_cast< wxDC * >(argp2);
24296 }
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24311 PyObject *resultobj = 0;
24312 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24313 wxDC *result = 0 ;
24314 void *argp1 = 0 ;
24315 int res1 = 0 ;
24316 PyObject *swig_obj[1] ;
24317
24318 if (!args) SWIG_fail;
24319 swig_obj[0] = args;
24320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24321 if (!SWIG_IsOK(res1)) {
24322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24323 }
24324 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24325 {
24326 PyThreadState* __tstate = wxPyBeginAllowThreads();
24327 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 {
24332 resultobj = wxPyMake_wxObject(result, (bool)0);
24333 }
24334 return resultobj;
24335 fail:
24336 return NULL;
24337 }
24338
24339
24340 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24341 PyObject *obj;
24342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24343 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24344 return SWIG_Py_Void();
24345 }
24346
24347 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24348 return SWIG_Python_InitShadowInstance(args);
24349 }
24350
24351 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24352 PyObject *resultobj = 0;
24353 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24354 int arg2 = (int) 0 ;
24355 wxFocusEvent *result = 0 ;
24356 int val1 ;
24357 int ecode1 = 0 ;
24358 int val2 ;
24359 int ecode2 = 0 ;
24360 PyObject * obj0 = 0 ;
24361 PyObject * obj1 = 0 ;
24362 char * kwnames[] = {
24363 (char *) "type",(char *) "winid", NULL
24364 };
24365
24366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24367 if (obj0) {
24368 ecode1 = SWIG_AsVal_int(obj0, &val1);
24369 if (!SWIG_IsOK(ecode1)) {
24370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24371 }
24372 arg1 = static_cast< wxEventType >(val1);
24373 }
24374 if (obj1) {
24375 ecode2 = SWIG_AsVal_int(obj1, &val2);
24376 if (!SWIG_IsOK(ecode2)) {
24377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24378 }
24379 arg2 = static_cast< int >(val2);
24380 }
24381 {
24382 PyThreadState* __tstate = wxPyBeginAllowThreads();
24383 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24384 wxPyEndAllowThreads(__tstate);
24385 if (PyErr_Occurred()) SWIG_fail;
24386 }
24387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24388 return resultobj;
24389 fail:
24390 return NULL;
24391 }
24392
24393
24394 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24395 PyObject *resultobj = 0;
24396 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24397 wxWindow *result = 0 ;
24398 void *argp1 = 0 ;
24399 int res1 = 0 ;
24400 PyObject *swig_obj[1] ;
24401
24402 if (!args) SWIG_fail;
24403 swig_obj[0] = args;
24404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24405 if (!SWIG_IsOK(res1)) {
24406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24407 }
24408 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24409 {
24410 PyThreadState* __tstate = wxPyBeginAllowThreads();
24411 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24412 wxPyEndAllowThreads(__tstate);
24413 if (PyErr_Occurred()) SWIG_fail;
24414 }
24415 {
24416 resultobj = wxPyMake_wxObject(result, (bool)0);
24417 }
24418 return resultobj;
24419 fail:
24420 return NULL;
24421 }
24422
24423
24424 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24425 PyObject *resultobj = 0;
24426 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24427 wxWindow *arg2 = (wxWindow *) 0 ;
24428 void *argp1 = 0 ;
24429 int res1 = 0 ;
24430 void *argp2 = 0 ;
24431 int res2 = 0 ;
24432 PyObject * obj0 = 0 ;
24433 PyObject * obj1 = 0 ;
24434 char * kwnames[] = {
24435 (char *) "self",(char *) "win", NULL
24436 };
24437
24438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24440 if (!SWIG_IsOK(res1)) {
24441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24442 }
24443 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24444 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24445 if (!SWIG_IsOK(res2)) {
24446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24447 }
24448 arg2 = reinterpret_cast< wxWindow * >(argp2);
24449 {
24450 PyThreadState* __tstate = wxPyBeginAllowThreads();
24451 (arg1)->SetWindow(arg2);
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 resultobj = SWIG_Py_Void();
24456 return resultobj;
24457 fail:
24458 return NULL;
24459 }
24460
24461
24462 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24463 PyObject *obj;
24464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24465 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24466 return SWIG_Py_Void();
24467 }
24468
24469 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24470 return SWIG_Python_InitShadowInstance(args);
24471 }
24472
24473 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24474 PyObject *resultobj = 0;
24475 wxWindow *arg1 = (wxWindow *) NULL ;
24476 wxChildFocusEvent *result = 0 ;
24477 void *argp1 = 0 ;
24478 int res1 = 0 ;
24479 PyObject * obj0 = 0 ;
24480 char * kwnames[] = {
24481 (char *) "win", NULL
24482 };
24483
24484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24485 if (obj0) {
24486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24487 if (!SWIG_IsOK(res1)) {
24488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24489 }
24490 arg1 = reinterpret_cast< wxWindow * >(argp1);
24491 }
24492 {
24493 PyThreadState* __tstate = wxPyBeginAllowThreads();
24494 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24506 PyObject *resultobj = 0;
24507 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24508 wxWindow *result = 0 ;
24509 void *argp1 = 0 ;
24510 int res1 = 0 ;
24511 PyObject *swig_obj[1] ;
24512
24513 if (!args) SWIG_fail;
24514 swig_obj[0] = args;
24515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24516 if (!SWIG_IsOK(res1)) {
24517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24518 }
24519 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24520 {
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24523 wxPyEndAllowThreads(__tstate);
24524 if (PyErr_Occurred()) SWIG_fail;
24525 }
24526 {
24527 resultobj = wxPyMake_wxObject(result, (bool)0);
24528 }
24529 return resultobj;
24530 fail:
24531 return NULL;
24532 }
24533
24534
24535 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24536 PyObject *obj;
24537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24538 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24539 return SWIG_Py_Void();
24540 }
24541
24542 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24543 return SWIG_Python_InitShadowInstance(args);
24544 }
24545
24546 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24547 PyObject *resultobj = 0;
24548 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24549 bool arg2 = (bool) true ;
24550 int arg3 = (int) 0 ;
24551 wxActivateEvent *result = 0 ;
24552 int val1 ;
24553 int ecode1 = 0 ;
24554 bool val2 ;
24555 int ecode2 = 0 ;
24556 int val3 ;
24557 int ecode3 = 0 ;
24558 PyObject * obj0 = 0 ;
24559 PyObject * obj1 = 0 ;
24560 PyObject * obj2 = 0 ;
24561 char * kwnames[] = {
24562 (char *) "type",(char *) "active",(char *) "Id", NULL
24563 };
24564
24565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24566 if (obj0) {
24567 ecode1 = SWIG_AsVal_int(obj0, &val1);
24568 if (!SWIG_IsOK(ecode1)) {
24569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24570 }
24571 arg1 = static_cast< wxEventType >(val1);
24572 }
24573 if (obj1) {
24574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24575 if (!SWIG_IsOK(ecode2)) {
24576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24577 }
24578 arg2 = static_cast< bool >(val2);
24579 }
24580 if (obj2) {
24581 ecode3 = SWIG_AsVal_int(obj2, &val3);
24582 if (!SWIG_IsOK(ecode3)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24584 }
24585 arg3 = static_cast< int >(val3);
24586 }
24587 {
24588 PyThreadState* __tstate = wxPyBeginAllowThreads();
24589 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24590 wxPyEndAllowThreads(__tstate);
24591 if (PyErr_Occurred()) SWIG_fail;
24592 }
24593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24594 return resultobj;
24595 fail:
24596 return NULL;
24597 }
24598
24599
24600 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24601 PyObject *resultobj = 0;
24602 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24603 bool result;
24604 void *argp1 = 0 ;
24605 int res1 = 0 ;
24606 PyObject *swig_obj[1] ;
24607
24608 if (!args) SWIG_fail;
24609 swig_obj[0] = args;
24610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24611 if (!SWIG_IsOK(res1)) {
24612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24613 }
24614 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24615 {
24616 PyThreadState* __tstate = wxPyBeginAllowThreads();
24617 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24618 wxPyEndAllowThreads(__tstate);
24619 if (PyErr_Occurred()) SWIG_fail;
24620 }
24621 {
24622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24623 }
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 PyObject *obj;
24632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24633 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24634 return SWIG_Py_Void();
24635 }
24636
24637 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24638 return SWIG_Python_InitShadowInstance(args);
24639 }
24640
24641 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj = 0;
24643 int arg1 = (int) 0 ;
24644 wxInitDialogEvent *result = 0 ;
24645 int val1 ;
24646 int ecode1 = 0 ;
24647 PyObject * obj0 = 0 ;
24648 char * kwnames[] = {
24649 (char *) "Id", NULL
24650 };
24651
24652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24653 if (obj0) {
24654 ecode1 = SWIG_AsVal_int(obj0, &val1);
24655 if (!SWIG_IsOK(ecode1)) {
24656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24657 }
24658 arg1 = static_cast< int >(val1);
24659 }
24660 {
24661 PyThreadState* __tstate = wxPyBeginAllowThreads();
24662 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24663 wxPyEndAllowThreads(__tstate);
24664 if (PyErr_Occurred()) SWIG_fail;
24665 }
24666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24667 return resultobj;
24668 fail:
24669 return NULL;
24670 }
24671
24672
24673 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24674 PyObject *obj;
24675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24676 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24677 return SWIG_Py_Void();
24678 }
24679
24680 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24681 return SWIG_Python_InitShadowInstance(args);
24682 }
24683
24684 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24685 PyObject *resultobj = 0;
24686 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24687 int arg2 = (int) 0 ;
24688 wxMenu *arg3 = (wxMenu *) NULL ;
24689 wxMenuEvent *result = 0 ;
24690 int val1 ;
24691 int ecode1 = 0 ;
24692 int val2 ;
24693 int ecode2 = 0 ;
24694 void *argp3 = 0 ;
24695 int res3 = 0 ;
24696 PyObject * obj0 = 0 ;
24697 PyObject * obj1 = 0 ;
24698 PyObject * obj2 = 0 ;
24699 char * kwnames[] = {
24700 (char *) "type",(char *) "winid",(char *) "menu", NULL
24701 };
24702
24703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24704 if (obj0) {
24705 ecode1 = SWIG_AsVal_int(obj0, &val1);
24706 if (!SWIG_IsOK(ecode1)) {
24707 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24708 }
24709 arg1 = static_cast< wxEventType >(val1);
24710 }
24711 if (obj1) {
24712 ecode2 = SWIG_AsVal_int(obj1, &val2);
24713 if (!SWIG_IsOK(ecode2)) {
24714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24715 }
24716 arg2 = static_cast< int >(val2);
24717 }
24718 if (obj2) {
24719 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24720 if (!SWIG_IsOK(res3)) {
24721 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24722 }
24723 arg3 = reinterpret_cast< wxMenu * >(argp3);
24724 }
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24732 return resultobj;
24733 fail:
24734 return NULL;
24735 }
24736
24737
24738 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24739 PyObject *resultobj = 0;
24740 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24741 int result;
24742 void *argp1 = 0 ;
24743 int res1 = 0 ;
24744 PyObject *swig_obj[1] ;
24745
24746 if (!args) SWIG_fail;
24747 swig_obj[0] = args;
24748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24749 if (!SWIG_IsOK(res1)) {
24750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24751 }
24752 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24753 {
24754 PyThreadState* __tstate = wxPyBeginAllowThreads();
24755 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24756 wxPyEndAllowThreads(__tstate);
24757 if (PyErr_Occurred()) SWIG_fail;
24758 }
24759 resultobj = SWIG_From_int(static_cast< int >(result));
24760 return resultobj;
24761 fail:
24762 return NULL;
24763 }
24764
24765
24766 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24767 PyObject *resultobj = 0;
24768 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24769 bool result;
24770 void *argp1 = 0 ;
24771 int res1 = 0 ;
24772 PyObject *swig_obj[1] ;
24773
24774 if (!args) SWIG_fail;
24775 swig_obj[0] = args;
24776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24777 if (!SWIG_IsOK(res1)) {
24778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24779 }
24780 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24781 {
24782 PyThreadState* __tstate = wxPyBeginAllowThreads();
24783 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24784 wxPyEndAllowThreads(__tstate);
24785 if (PyErr_Occurred()) SWIG_fail;
24786 }
24787 {
24788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24789 }
24790 return resultobj;
24791 fail:
24792 return NULL;
24793 }
24794
24795
24796 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24797 PyObject *resultobj = 0;
24798 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24799 wxMenu *result = 0 ;
24800 void *argp1 = 0 ;
24801 int res1 = 0 ;
24802 PyObject *swig_obj[1] ;
24803
24804 if (!args) SWIG_fail;
24805 swig_obj[0] = args;
24806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24807 if (!SWIG_IsOK(res1)) {
24808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24809 }
24810 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24811 {
24812 PyThreadState* __tstate = wxPyBeginAllowThreads();
24813 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24814 wxPyEndAllowThreads(__tstate);
24815 if (PyErr_Occurred()) SWIG_fail;
24816 }
24817 {
24818 resultobj = wxPyMake_wxObject(result, (bool)0);
24819 }
24820 return resultobj;
24821 fail:
24822 return NULL;
24823 }
24824
24825
24826 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24827 PyObject *obj;
24828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24829 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24830 return SWIG_Py_Void();
24831 }
24832
24833 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24834 return SWIG_Python_InitShadowInstance(args);
24835 }
24836
24837 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24838 PyObject *resultobj = 0;
24839 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24840 int arg2 = (int) 0 ;
24841 wxCloseEvent *result = 0 ;
24842 int val1 ;
24843 int ecode1 = 0 ;
24844 int val2 ;
24845 int ecode2 = 0 ;
24846 PyObject * obj0 = 0 ;
24847 PyObject * obj1 = 0 ;
24848 char * kwnames[] = {
24849 (char *) "type",(char *) "winid", NULL
24850 };
24851
24852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24853 if (obj0) {
24854 ecode1 = SWIG_AsVal_int(obj0, &val1);
24855 if (!SWIG_IsOK(ecode1)) {
24856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24857 }
24858 arg1 = static_cast< wxEventType >(val1);
24859 }
24860 if (obj1) {
24861 ecode2 = SWIG_AsVal_int(obj1, &val2);
24862 if (!SWIG_IsOK(ecode2)) {
24863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24864 }
24865 arg2 = static_cast< int >(val2);
24866 }
24867 {
24868 PyThreadState* __tstate = wxPyBeginAllowThreads();
24869 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj = 0;
24882 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24883 bool arg2 ;
24884 void *argp1 = 0 ;
24885 int res1 = 0 ;
24886 bool val2 ;
24887 int ecode2 = 0 ;
24888 PyObject * obj0 = 0 ;
24889 PyObject * obj1 = 0 ;
24890 char * kwnames[] = {
24891 (char *) "self",(char *) "logOff", NULL
24892 };
24893
24894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24896 if (!SWIG_IsOK(res1)) {
24897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24898 }
24899 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24900 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24901 if (!SWIG_IsOK(ecode2)) {
24902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24903 }
24904 arg2 = static_cast< bool >(val2);
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 (arg1)->SetLoggingOff(arg2);
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 resultobj = SWIG_Py_Void();
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24919 PyObject *resultobj = 0;
24920 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24921 bool result;
24922 void *argp1 = 0 ;
24923 int res1 = 0 ;
24924 PyObject *swig_obj[1] ;
24925
24926 if (!args) SWIG_fail;
24927 swig_obj[0] = args;
24928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24929 if (!SWIG_IsOK(res1)) {
24930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24931 }
24932 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24933 {
24934 PyThreadState* __tstate = wxPyBeginAllowThreads();
24935 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 {
24940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24941 }
24942 return resultobj;
24943 fail:
24944 return NULL;
24945 }
24946
24947
24948 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24949 PyObject *resultobj = 0;
24950 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24951 bool arg2 = (bool) true ;
24952 void *argp1 = 0 ;
24953 int res1 = 0 ;
24954 bool val2 ;
24955 int ecode2 = 0 ;
24956 PyObject * obj0 = 0 ;
24957 PyObject * obj1 = 0 ;
24958 char * kwnames[] = {
24959 (char *) "self",(char *) "veto", NULL
24960 };
24961
24962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24964 if (!SWIG_IsOK(res1)) {
24965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24966 }
24967 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24968 if (obj1) {
24969 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24970 if (!SWIG_IsOK(ecode2)) {
24971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24972 }
24973 arg2 = static_cast< bool >(val2);
24974 }
24975 {
24976 PyThreadState* __tstate = wxPyBeginAllowThreads();
24977 (arg1)->Veto(arg2);
24978 wxPyEndAllowThreads(__tstate);
24979 if (PyErr_Occurred()) SWIG_fail;
24980 }
24981 resultobj = SWIG_Py_Void();
24982 return resultobj;
24983 fail:
24984 return NULL;
24985 }
24986
24987
24988 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24989 PyObject *resultobj = 0;
24990 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24991 bool result;
24992 void *argp1 = 0 ;
24993 int res1 = 0 ;
24994 PyObject *swig_obj[1] ;
24995
24996 if (!args) SWIG_fail;
24997 swig_obj[0] = args;
24998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24999 if (!SWIG_IsOK(res1)) {
25000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25001 }
25002 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25003 {
25004 PyThreadState* __tstate = wxPyBeginAllowThreads();
25005 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25006 wxPyEndAllowThreads(__tstate);
25007 if (PyErr_Occurred()) SWIG_fail;
25008 }
25009 {
25010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25011 }
25012 return resultobj;
25013 fail:
25014 return NULL;
25015 }
25016
25017
25018 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25019 PyObject *resultobj = 0;
25020 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25021 bool arg2 ;
25022 void *argp1 = 0 ;
25023 int res1 = 0 ;
25024 bool val2 ;
25025 int ecode2 = 0 ;
25026 PyObject * obj0 = 0 ;
25027 PyObject * obj1 = 0 ;
25028 char * kwnames[] = {
25029 (char *) "self",(char *) "canVeto", NULL
25030 };
25031
25032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25034 if (!SWIG_IsOK(res1)) {
25035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25036 }
25037 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25038 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25039 if (!SWIG_IsOK(ecode2)) {
25040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25041 }
25042 arg2 = static_cast< bool >(val2);
25043 {
25044 PyThreadState* __tstate = wxPyBeginAllowThreads();
25045 (arg1)->SetCanVeto(arg2);
25046 wxPyEndAllowThreads(__tstate);
25047 if (PyErr_Occurred()) SWIG_fail;
25048 }
25049 resultobj = SWIG_Py_Void();
25050 return resultobj;
25051 fail:
25052 return NULL;
25053 }
25054
25055
25056 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25057 PyObject *resultobj = 0;
25058 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25059 bool result;
25060 void *argp1 = 0 ;
25061 int res1 = 0 ;
25062 PyObject *swig_obj[1] ;
25063
25064 if (!args) SWIG_fail;
25065 swig_obj[0] = args;
25066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25067 if (!SWIG_IsOK(res1)) {
25068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25069 }
25070 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25071 {
25072 PyThreadState* __tstate = wxPyBeginAllowThreads();
25073 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25074 wxPyEndAllowThreads(__tstate);
25075 if (PyErr_Occurred()) SWIG_fail;
25076 }
25077 {
25078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25079 }
25080 return resultobj;
25081 fail:
25082 return NULL;
25083 }
25084
25085
25086 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25087 PyObject *obj;
25088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25089 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25090 return SWIG_Py_Void();
25091 }
25092
25093 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25094 return SWIG_Python_InitShadowInstance(args);
25095 }
25096
25097 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj = 0;
25099 int arg1 = (int) 0 ;
25100 bool arg2 = (bool) false ;
25101 wxShowEvent *result = 0 ;
25102 int val1 ;
25103 int ecode1 = 0 ;
25104 bool val2 ;
25105 int ecode2 = 0 ;
25106 PyObject * obj0 = 0 ;
25107 PyObject * obj1 = 0 ;
25108 char * kwnames[] = {
25109 (char *) "winid",(char *) "show", NULL
25110 };
25111
25112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25113 if (obj0) {
25114 ecode1 = SWIG_AsVal_int(obj0, &val1);
25115 if (!SWIG_IsOK(ecode1)) {
25116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25117 }
25118 arg1 = static_cast< int >(val1);
25119 }
25120 if (obj1) {
25121 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25122 if (!SWIG_IsOK(ecode2)) {
25123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25124 }
25125 arg2 = static_cast< bool >(val2);
25126 }
25127 {
25128 PyThreadState* __tstate = wxPyBeginAllowThreads();
25129 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25134 return resultobj;
25135 fail:
25136 return NULL;
25137 }
25138
25139
25140 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25141 PyObject *resultobj = 0;
25142 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25143 bool arg2 ;
25144 void *argp1 = 0 ;
25145 int res1 = 0 ;
25146 bool val2 ;
25147 int ecode2 = 0 ;
25148 PyObject * obj0 = 0 ;
25149 PyObject * obj1 = 0 ;
25150 char * kwnames[] = {
25151 (char *) "self",(char *) "show", NULL
25152 };
25153
25154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25156 if (!SWIG_IsOK(res1)) {
25157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25158 }
25159 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25160 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25161 if (!SWIG_IsOK(ecode2)) {
25162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25163 }
25164 arg2 = static_cast< bool >(val2);
25165 {
25166 PyThreadState* __tstate = wxPyBeginAllowThreads();
25167 (arg1)->SetShow(arg2);
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 resultobj = SWIG_Py_Void();
25172 return resultobj;
25173 fail:
25174 return NULL;
25175 }
25176
25177
25178 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25179 PyObject *resultobj = 0;
25180 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25181 bool result;
25182 void *argp1 = 0 ;
25183 int res1 = 0 ;
25184 PyObject *swig_obj[1] ;
25185
25186 if (!args) SWIG_fail;
25187 swig_obj[0] = args;
25188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25189 if (!SWIG_IsOK(res1)) {
25190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25191 }
25192 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25193 {
25194 PyThreadState* __tstate = wxPyBeginAllowThreads();
25195 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25196 wxPyEndAllowThreads(__tstate);
25197 if (PyErr_Occurred()) SWIG_fail;
25198 }
25199 {
25200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25201 }
25202 return resultobj;
25203 fail:
25204 return NULL;
25205 }
25206
25207
25208 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25209 PyObject *obj;
25210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25211 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25212 return SWIG_Py_Void();
25213 }
25214
25215 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25216 return SWIG_Python_InitShadowInstance(args);
25217 }
25218
25219 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25220 PyObject *resultobj = 0;
25221 int arg1 = (int) 0 ;
25222 bool arg2 = (bool) true ;
25223 wxIconizeEvent *result = 0 ;
25224 int val1 ;
25225 int ecode1 = 0 ;
25226 bool val2 ;
25227 int ecode2 = 0 ;
25228 PyObject * obj0 = 0 ;
25229 PyObject * obj1 = 0 ;
25230 char * kwnames[] = {
25231 (char *) "id",(char *) "iconized", NULL
25232 };
25233
25234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25235 if (obj0) {
25236 ecode1 = SWIG_AsVal_int(obj0, &val1);
25237 if (!SWIG_IsOK(ecode1)) {
25238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25239 }
25240 arg1 = static_cast< int >(val1);
25241 }
25242 if (obj1) {
25243 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25244 if (!SWIG_IsOK(ecode2)) {
25245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25246 }
25247 arg2 = static_cast< bool >(val2);
25248 }
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25252 wxPyEndAllowThreads(__tstate);
25253 if (PyErr_Occurred()) SWIG_fail;
25254 }
25255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25256 return resultobj;
25257 fail:
25258 return NULL;
25259 }
25260
25261
25262 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25263 PyObject *resultobj = 0;
25264 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25265 bool result;
25266 void *argp1 = 0 ;
25267 int res1 = 0 ;
25268 PyObject *swig_obj[1] ;
25269
25270 if (!args) SWIG_fail;
25271 swig_obj[0] = args;
25272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25273 if (!SWIG_IsOK(res1)) {
25274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25275 }
25276 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25277 {
25278 PyThreadState* __tstate = wxPyBeginAllowThreads();
25279 result = (bool)(arg1)->Iconized();
25280 wxPyEndAllowThreads(__tstate);
25281 if (PyErr_Occurred()) SWIG_fail;
25282 }
25283 {
25284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25285 }
25286 return resultobj;
25287 fail:
25288 return NULL;
25289 }
25290
25291
25292 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25293 PyObject *obj;
25294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25295 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25296 return SWIG_Py_Void();
25297 }
25298
25299 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25300 return SWIG_Python_InitShadowInstance(args);
25301 }
25302
25303 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25304 PyObject *resultobj = 0;
25305 int arg1 = (int) 0 ;
25306 wxMaximizeEvent *result = 0 ;
25307 int val1 ;
25308 int ecode1 = 0 ;
25309 PyObject * obj0 = 0 ;
25310 char * kwnames[] = {
25311 (char *) "id", NULL
25312 };
25313
25314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25315 if (obj0) {
25316 ecode1 = SWIG_AsVal_int(obj0, &val1);
25317 if (!SWIG_IsOK(ecode1)) {
25318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25319 }
25320 arg1 = static_cast< int >(val1);
25321 }
25322 {
25323 PyThreadState* __tstate = wxPyBeginAllowThreads();
25324 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25329 return resultobj;
25330 fail:
25331 return NULL;
25332 }
25333
25334
25335 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25336 PyObject *obj;
25337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25338 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25339 return SWIG_Py_Void();
25340 }
25341
25342 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25343 return SWIG_Python_InitShadowInstance(args);
25344 }
25345
25346 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25347 PyObject *resultobj = 0;
25348 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25349 wxPoint result;
25350 void *argp1 = 0 ;
25351 int res1 = 0 ;
25352 PyObject *swig_obj[1] ;
25353
25354 if (!args) SWIG_fail;
25355 swig_obj[0] = args;
25356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25357 if (!SWIG_IsOK(res1)) {
25358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25359 }
25360 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25361 {
25362 PyThreadState* __tstate = wxPyBeginAllowThreads();
25363 result = (arg1)->GetPosition();
25364 wxPyEndAllowThreads(__tstate);
25365 if (PyErr_Occurred()) SWIG_fail;
25366 }
25367 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25368 return resultobj;
25369 fail:
25370 return NULL;
25371 }
25372
25373
25374 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25375 PyObject *resultobj = 0;
25376 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25377 int result;
25378 void *argp1 = 0 ;
25379 int res1 = 0 ;
25380 PyObject *swig_obj[1] ;
25381
25382 if (!args) SWIG_fail;
25383 swig_obj[0] = args;
25384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25385 if (!SWIG_IsOK(res1)) {
25386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25387 }
25388 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25389 {
25390 PyThreadState* __tstate = wxPyBeginAllowThreads();
25391 result = (int)(arg1)->GetNumberOfFiles();
25392 wxPyEndAllowThreads(__tstate);
25393 if (PyErr_Occurred()) SWIG_fail;
25394 }
25395 resultobj = SWIG_From_int(static_cast< int >(result));
25396 return resultobj;
25397 fail:
25398 return NULL;
25399 }
25400
25401
25402 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25403 PyObject *resultobj = 0;
25404 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25405 PyObject *result = 0 ;
25406 void *argp1 = 0 ;
25407 int res1 = 0 ;
25408 PyObject *swig_obj[1] ;
25409
25410 if (!args) SWIG_fail;
25411 swig_obj[0] = args;
25412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25413 if (!SWIG_IsOK(res1)) {
25414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25415 }
25416 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25417 {
25418 PyThreadState* __tstate = wxPyBeginAllowThreads();
25419 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25420 wxPyEndAllowThreads(__tstate);
25421 if (PyErr_Occurred()) SWIG_fail;
25422 }
25423 resultobj = result;
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25431 PyObject *obj;
25432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25433 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25434 return SWIG_Py_Void();
25435 }
25436
25437 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25438 PyObject *resultobj = 0;
25439 int arg1 = (int) 0 ;
25440 wxUpdateUIEvent *result = 0 ;
25441 int val1 ;
25442 int ecode1 = 0 ;
25443 PyObject * obj0 = 0 ;
25444 char * kwnames[] = {
25445 (char *) "commandId", NULL
25446 };
25447
25448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25449 if (obj0) {
25450 ecode1 = SWIG_AsVal_int(obj0, &val1);
25451 if (!SWIG_IsOK(ecode1)) {
25452 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25453 }
25454 arg1 = static_cast< int >(val1);
25455 }
25456 {
25457 PyThreadState* __tstate = wxPyBeginAllowThreads();
25458 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25459 wxPyEndAllowThreads(__tstate);
25460 if (PyErr_Occurred()) SWIG_fail;
25461 }
25462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25463 return resultobj;
25464 fail:
25465 return NULL;
25466 }
25467
25468
25469 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25470 PyObject *resultobj = 0;
25471 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25472 bool result;
25473 void *argp1 = 0 ;
25474 int res1 = 0 ;
25475 PyObject *swig_obj[1] ;
25476
25477 if (!args) SWIG_fail;
25478 swig_obj[0] = args;
25479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25480 if (!SWIG_IsOK(res1)) {
25481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25482 }
25483 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25484 {
25485 PyThreadState* __tstate = wxPyBeginAllowThreads();
25486 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25487 wxPyEndAllowThreads(__tstate);
25488 if (PyErr_Occurred()) SWIG_fail;
25489 }
25490 {
25491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25492 }
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25500 PyObject *resultobj = 0;
25501 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25502 bool result;
25503 void *argp1 = 0 ;
25504 int res1 = 0 ;
25505 PyObject *swig_obj[1] ;
25506
25507 if (!args) SWIG_fail;
25508 swig_obj[0] = args;
25509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25510 if (!SWIG_IsOK(res1)) {
25511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25512 }
25513 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25514 {
25515 PyThreadState* __tstate = wxPyBeginAllowThreads();
25516 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25517 wxPyEndAllowThreads(__tstate);
25518 if (PyErr_Occurred()) SWIG_fail;
25519 }
25520 {
25521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25522 }
25523 return resultobj;
25524 fail:
25525 return NULL;
25526 }
25527
25528
25529 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25530 PyObject *resultobj = 0;
25531 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25532 bool result;
25533 void *argp1 = 0 ;
25534 int res1 = 0 ;
25535 PyObject *swig_obj[1] ;
25536
25537 if (!args) SWIG_fail;
25538 swig_obj[0] = args;
25539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25540 if (!SWIG_IsOK(res1)) {
25541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25542 }
25543 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25544 {
25545 PyThreadState* __tstate = wxPyBeginAllowThreads();
25546 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25547 wxPyEndAllowThreads(__tstate);
25548 if (PyErr_Occurred()) SWIG_fail;
25549 }
25550 {
25551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25552 }
25553 return resultobj;
25554 fail:
25555 return NULL;
25556 }
25557
25558
25559 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25560 PyObject *resultobj = 0;
25561 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25562 wxString result;
25563 void *argp1 = 0 ;
25564 int res1 = 0 ;
25565 PyObject *swig_obj[1] ;
25566
25567 if (!args) SWIG_fail;
25568 swig_obj[0] = args;
25569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25570 if (!SWIG_IsOK(res1)) {
25571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25572 }
25573 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 {
25581 #if wxUSE_UNICODE
25582 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25583 #else
25584 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25585 #endif
25586 }
25587 return resultobj;
25588 fail:
25589 return NULL;
25590 }
25591
25592
25593 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25594 PyObject *resultobj = 0;
25595 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25596 bool result;
25597 void *argp1 = 0 ;
25598 int res1 = 0 ;
25599 PyObject *swig_obj[1] ;
25600
25601 if (!args) SWIG_fail;
25602 swig_obj[0] = args;
25603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25604 if (!SWIG_IsOK(res1)) {
25605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25606 }
25607 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25608 {
25609 PyThreadState* __tstate = wxPyBeginAllowThreads();
25610 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25611 wxPyEndAllowThreads(__tstate);
25612 if (PyErr_Occurred()) SWIG_fail;
25613 }
25614 {
25615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25616 }
25617 return resultobj;
25618 fail:
25619 return NULL;
25620 }
25621
25622
25623 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25624 PyObject *resultobj = 0;
25625 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25626 bool result;
25627 void *argp1 = 0 ;
25628 int res1 = 0 ;
25629 PyObject *swig_obj[1] ;
25630
25631 if (!args) SWIG_fail;
25632 swig_obj[0] = args;
25633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25634 if (!SWIG_IsOK(res1)) {
25635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25636 }
25637 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25638 {
25639 PyThreadState* __tstate = wxPyBeginAllowThreads();
25640 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25641 wxPyEndAllowThreads(__tstate);
25642 if (PyErr_Occurred()) SWIG_fail;
25643 }
25644 {
25645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25646 }
25647 return resultobj;
25648 fail:
25649 return NULL;
25650 }
25651
25652
25653 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25654 PyObject *resultobj = 0;
25655 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25656 bool result;
25657 void *argp1 = 0 ;
25658 int res1 = 0 ;
25659 PyObject *swig_obj[1] ;
25660
25661 if (!args) SWIG_fail;
25662 swig_obj[0] = args;
25663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25664 if (!SWIG_IsOK(res1)) {
25665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25666 }
25667 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25668 {
25669 PyThreadState* __tstate = wxPyBeginAllowThreads();
25670 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25671 wxPyEndAllowThreads(__tstate);
25672 if (PyErr_Occurred()) SWIG_fail;
25673 }
25674 {
25675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25676 }
25677 return resultobj;
25678 fail:
25679 return NULL;
25680 }
25681
25682
25683 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25684 PyObject *resultobj = 0;
25685 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25686 bool result;
25687 void *argp1 = 0 ;
25688 int res1 = 0 ;
25689 PyObject *swig_obj[1] ;
25690
25691 if (!args) SWIG_fail;
25692 swig_obj[0] = args;
25693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25694 if (!SWIG_IsOK(res1)) {
25695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25696 }
25697 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25698 {
25699 PyThreadState* __tstate = wxPyBeginAllowThreads();
25700 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25701 wxPyEndAllowThreads(__tstate);
25702 if (PyErr_Occurred()) SWIG_fail;
25703 }
25704 {
25705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25706 }
25707 return resultobj;
25708 fail:
25709 return NULL;
25710 }
25711
25712
25713 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25714 PyObject *resultobj = 0;
25715 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25716 bool arg2 ;
25717 void *argp1 = 0 ;
25718 int res1 = 0 ;
25719 bool val2 ;
25720 int ecode2 = 0 ;
25721 PyObject * obj0 = 0 ;
25722 PyObject * obj1 = 0 ;
25723 char * kwnames[] = {
25724 (char *) "self",(char *) "check", NULL
25725 };
25726
25727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25729 if (!SWIG_IsOK(res1)) {
25730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25731 }
25732 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25733 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25734 if (!SWIG_IsOK(ecode2)) {
25735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25736 }
25737 arg2 = static_cast< bool >(val2);
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 (arg1)->Check(arg2);
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 resultobj = SWIG_Py_Void();
25745 return resultobj;
25746 fail:
25747 return NULL;
25748 }
25749
25750
25751 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25752 PyObject *resultobj = 0;
25753 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25754 bool arg2 ;
25755 void *argp1 = 0 ;
25756 int res1 = 0 ;
25757 bool val2 ;
25758 int ecode2 = 0 ;
25759 PyObject * obj0 = 0 ;
25760 PyObject * obj1 = 0 ;
25761 char * kwnames[] = {
25762 (char *) "self",(char *) "enable", NULL
25763 };
25764
25765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25767 if (!SWIG_IsOK(res1)) {
25768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25769 }
25770 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25772 if (!SWIG_IsOK(ecode2)) {
25773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25774 }
25775 arg2 = static_cast< bool >(val2);
25776 {
25777 PyThreadState* __tstate = wxPyBeginAllowThreads();
25778 (arg1)->Enable(arg2);
25779 wxPyEndAllowThreads(__tstate);
25780 if (PyErr_Occurred()) SWIG_fail;
25781 }
25782 resultobj = SWIG_Py_Void();
25783 return resultobj;
25784 fail:
25785 return NULL;
25786 }
25787
25788
25789 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25790 PyObject *resultobj = 0;
25791 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25792 bool arg2 ;
25793 void *argp1 = 0 ;
25794 int res1 = 0 ;
25795 bool val2 ;
25796 int ecode2 = 0 ;
25797 PyObject * obj0 = 0 ;
25798 PyObject * obj1 = 0 ;
25799 char * kwnames[] = {
25800 (char *) "self",(char *) "show", NULL
25801 };
25802
25803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25805 if (!SWIG_IsOK(res1)) {
25806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25807 }
25808 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25810 if (!SWIG_IsOK(ecode2)) {
25811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25812 }
25813 arg2 = static_cast< bool >(val2);
25814 {
25815 PyThreadState* __tstate = wxPyBeginAllowThreads();
25816 (arg1)->Show(arg2);
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 resultobj = SWIG_Py_Void();
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj = 0;
25829 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25830 wxString *arg2 = 0 ;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 bool temp2 = false ;
25834 PyObject * obj0 = 0 ;
25835 PyObject * obj1 = 0 ;
25836 char * kwnames[] = {
25837 (char *) "self",(char *) "text", NULL
25838 };
25839
25840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25842 if (!SWIG_IsOK(res1)) {
25843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25844 }
25845 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25846 {
25847 arg2 = wxString_in_helper(obj1);
25848 if (arg2 == NULL) SWIG_fail;
25849 temp2 = true;
25850 }
25851 {
25852 PyThreadState* __tstate = wxPyBeginAllowThreads();
25853 (arg1)->SetText((wxString const &)*arg2);
25854 wxPyEndAllowThreads(__tstate);
25855 if (PyErr_Occurred()) SWIG_fail;
25856 }
25857 resultobj = SWIG_Py_Void();
25858 {
25859 if (temp2)
25860 delete arg2;
25861 }
25862 return resultobj;
25863 fail:
25864 {
25865 if (temp2)
25866 delete arg2;
25867 }
25868 return NULL;
25869 }
25870
25871
25872 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj = 0;
25874 long arg1 ;
25875 long val1 ;
25876 int ecode1 = 0 ;
25877 PyObject * obj0 = 0 ;
25878 char * kwnames[] = {
25879 (char *) "updateInterval", NULL
25880 };
25881
25882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25883 ecode1 = SWIG_AsVal_long(obj0, &val1);
25884 if (!SWIG_IsOK(ecode1)) {
25885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25886 }
25887 arg1 = static_cast< long >(val1);
25888 {
25889 PyThreadState* __tstate = wxPyBeginAllowThreads();
25890 wxUpdateUIEvent::SetUpdateInterval(arg1);
25891 wxPyEndAllowThreads(__tstate);
25892 if (PyErr_Occurred()) SWIG_fail;
25893 }
25894 resultobj = SWIG_Py_Void();
25895 return resultobj;
25896 fail:
25897 return NULL;
25898 }
25899
25900
25901 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25902 PyObject *resultobj = 0;
25903 long result;
25904
25905 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 resultobj = SWIG_From_long(static_cast< long >(result));
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25920 PyObject *resultobj = 0;
25921 wxWindow *arg1 = (wxWindow *) 0 ;
25922 bool result;
25923 void *argp1 = 0 ;
25924 int res1 = 0 ;
25925 PyObject * obj0 = 0 ;
25926 char * kwnames[] = {
25927 (char *) "win", NULL
25928 };
25929
25930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25932 if (!SWIG_IsOK(res1)) {
25933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25934 }
25935 arg1 = reinterpret_cast< wxWindow * >(argp1);
25936 {
25937 PyThreadState* __tstate = wxPyBeginAllowThreads();
25938 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25939 wxPyEndAllowThreads(__tstate);
25940 if (PyErr_Occurred()) SWIG_fail;
25941 }
25942 {
25943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25944 }
25945 return resultobj;
25946 fail:
25947 return NULL;
25948 }
25949
25950
25951 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25952 PyObject *resultobj = 0;
25953
25954 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25955 {
25956 PyThreadState* __tstate = wxPyBeginAllowThreads();
25957 wxUpdateUIEvent::ResetUpdateTime();
25958 wxPyEndAllowThreads(__tstate);
25959 if (PyErr_Occurred()) SWIG_fail;
25960 }
25961 resultobj = SWIG_Py_Void();
25962 return resultobj;
25963 fail:
25964 return NULL;
25965 }
25966
25967
25968 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25969 PyObject *resultobj = 0;
25970 wxUpdateUIMode arg1 ;
25971 int val1 ;
25972 int ecode1 = 0 ;
25973 PyObject * obj0 = 0 ;
25974 char * kwnames[] = {
25975 (char *) "mode", NULL
25976 };
25977
25978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25979 ecode1 = SWIG_AsVal_int(obj0, &val1);
25980 if (!SWIG_IsOK(ecode1)) {
25981 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25982 }
25983 arg1 = static_cast< wxUpdateUIMode >(val1);
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 wxUpdateUIEvent::SetMode(arg1);
25987 wxPyEndAllowThreads(__tstate);
25988 if (PyErr_Occurred()) SWIG_fail;
25989 }
25990 resultobj = SWIG_Py_Void();
25991 return resultobj;
25992 fail:
25993 return NULL;
25994 }
25995
25996
25997 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25998 PyObject *resultobj = 0;
25999 wxUpdateUIMode result;
26000
26001 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26005 wxPyEndAllowThreads(__tstate);
26006 if (PyErr_Occurred()) SWIG_fail;
26007 }
26008 resultobj = SWIG_From_int(static_cast< int >(result));
26009 return resultobj;
26010 fail:
26011 return NULL;
26012 }
26013
26014
26015 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26016 PyObject *obj;
26017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26018 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26019 return SWIG_Py_Void();
26020 }
26021
26022 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26023 return SWIG_Python_InitShadowInstance(args);
26024 }
26025
26026 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26027 PyObject *resultobj = 0;
26028 wxSysColourChangedEvent *result = 0 ;
26029
26030 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26045 PyObject *obj;
26046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26047 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26048 return SWIG_Py_Void();
26049 }
26050
26051 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26052 return SWIG_Python_InitShadowInstance(args);
26053 }
26054
26055 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26056 PyObject *resultobj = 0;
26057 int arg1 = (int) 0 ;
26058 wxWindow *arg2 = (wxWindow *) NULL ;
26059 wxMouseCaptureChangedEvent *result = 0 ;
26060 int val1 ;
26061 int ecode1 = 0 ;
26062 void *argp2 = 0 ;
26063 int res2 = 0 ;
26064 PyObject * obj0 = 0 ;
26065 PyObject * obj1 = 0 ;
26066 char * kwnames[] = {
26067 (char *) "winid",(char *) "gainedCapture", NULL
26068 };
26069
26070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26071 if (obj0) {
26072 ecode1 = SWIG_AsVal_int(obj0, &val1);
26073 if (!SWIG_IsOK(ecode1)) {
26074 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26075 }
26076 arg1 = static_cast< int >(val1);
26077 }
26078 if (obj1) {
26079 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26080 if (!SWIG_IsOK(res2)) {
26081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26082 }
26083 arg2 = reinterpret_cast< wxWindow * >(argp2);
26084 }
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26092 return resultobj;
26093 fail:
26094 return NULL;
26095 }
26096
26097
26098 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26099 PyObject *resultobj = 0;
26100 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26101 wxWindow *result = 0 ;
26102 void *argp1 = 0 ;
26103 int res1 = 0 ;
26104 PyObject *swig_obj[1] ;
26105
26106 if (!args) SWIG_fail;
26107 swig_obj[0] = args;
26108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26109 if (!SWIG_IsOK(res1)) {
26110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26111 }
26112 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26113 {
26114 PyThreadState* __tstate = wxPyBeginAllowThreads();
26115 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26116 wxPyEndAllowThreads(__tstate);
26117 if (PyErr_Occurred()) SWIG_fail;
26118 }
26119 {
26120 resultobj = wxPyMake_wxObject(result, (bool)0);
26121 }
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26129 PyObject *obj;
26130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26131 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26132 return SWIG_Py_Void();
26133 }
26134
26135 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26136 return SWIG_Python_InitShadowInstance(args);
26137 }
26138
26139 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26140 PyObject *resultobj = 0;
26141 int arg1 = (int) 0 ;
26142 wxMouseCaptureLostEvent *result = 0 ;
26143 int val1 ;
26144 int ecode1 = 0 ;
26145 PyObject * obj0 = 0 ;
26146 char * kwnames[] = {
26147 (char *) "winid", NULL
26148 };
26149
26150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26151 if (obj0) {
26152 ecode1 = SWIG_AsVal_int(obj0, &val1);
26153 if (!SWIG_IsOK(ecode1)) {
26154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26155 }
26156 arg1 = static_cast< int >(val1);
26157 }
26158 {
26159 PyThreadState* __tstate = wxPyBeginAllowThreads();
26160 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26161 wxPyEndAllowThreads(__tstate);
26162 if (PyErr_Occurred()) SWIG_fail;
26163 }
26164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26165 return resultobj;
26166 fail:
26167 return NULL;
26168 }
26169
26170
26171 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26172 PyObject *obj;
26173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26174 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26175 return SWIG_Py_Void();
26176 }
26177
26178 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26179 return SWIG_Python_InitShadowInstance(args);
26180 }
26181
26182 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26183 PyObject *resultobj = 0;
26184 wxDisplayChangedEvent *result = 0 ;
26185
26186 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26187 {
26188 PyThreadState* __tstate = wxPyBeginAllowThreads();
26189 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26190 wxPyEndAllowThreads(__tstate);
26191 if (PyErr_Occurred()) SWIG_fail;
26192 }
26193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26201 PyObject *obj;
26202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26203 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26204 return SWIG_Py_Void();
26205 }
26206
26207 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26208 return SWIG_Python_InitShadowInstance(args);
26209 }
26210
26211 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26212 PyObject *resultobj = 0;
26213 int arg1 = (int) 0 ;
26214 wxPaletteChangedEvent *result = 0 ;
26215 int val1 ;
26216 int ecode1 = 0 ;
26217 PyObject * obj0 = 0 ;
26218 char * kwnames[] = {
26219 (char *) "id", NULL
26220 };
26221
26222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26223 if (obj0) {
26224 ecode1 = SWIG_AsVal_int(obj0, &val1);
26225 if (!SWIG_IsOK(ecode1)) {
26226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26227 }
26228 arg1 = static_cast< int >(val1);
26229 }
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26233 wxPyEndAllowThreads(__tstate);
26234 if (PyErr_Occurred()) SWIG_fail;
26235 }
26236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26237 return resultobj;
26238 fail:
26239 return NULL;
26240 }
26241
26242
26243 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26244 PyObject *resultobj = 0;
26245 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26246 wxWindow *arg2 = (wxWindow *) 0 ;
26247 void *argp1 = 0 ;
26248 int res1 = 0 ;
26249 void *argp2 = 0 ;
26250 int res2 = 0 ;
26251 PyObject * obj0 = 0 ;
26252 PyObject * obj1 = 0 ;
26253 char * kwnames[] = {
26254 (char *) "self",(char *) "win", NULL
26255 };
26256
26257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26259 if (!SWIG_IsOK(res1)) {
26260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26261 }
26262 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26263 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26264 if (!SWIG_IsOK(res2)) {
26265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26266 }
26267 arg2 = reinterpret_cast< wxWindow * >(argp2);
26268 {
26269 PyThreadState* __tstate = wxPyBeginAllowThreads();
26270 (arg1)->SetChangedWindow(arg2);
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 resultobj = SWIG_Py_Void();
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26282 PyObject *resultobj = 0;
26283 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26284 wxWindow *result = 0 ;
26285 void *argp1 = 0 ;
26286 int res1 = 0 ;
26287 PyObject *swig_obj[1] ;
26288
26289 if (!args) SWIG_fail;
26290 swig_obj[0] = args;
26291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26292 if (!SWIG_IsOK(res1)) {
26293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26294 }
26295 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26296 {
26297 PyThreadState* __tstate = wxPyBeginAllowThreads();
26298 result = (wxWindow *)(arg1)->GetChangedWindow();
26299 wxPyEndAllowThreads(__tstate);
26300 if (PyErr_Occurred()) SWIG_fail;
26301 }
26302 {
26303 resultobj = wxPyMake_wxObject(result, (bool)0);
26304 }
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26312 PyObject *obj;
26313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26314 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26315 return SWIG_Py_Void();
26316 }
26317
26318 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26319 return SWIG_Python_InitShadowInstance(args);
26320 }
26321
26322 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26323 PyObject *resultobj = 0;
26324 int arg1 = (int) 0 ;
26325 wxQueryNewPaletteEvent *result = 0 ;
26326 int val1 ;
26327 int ecode1 = 0 ;
26328 PyObject * obj0 = 0 ;
26329 char * kwnames[] = {
26330 (char *) "winid", NULL
26331 };
26332
26333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26334 if (obj0) {
26335 ecode1 = SWIG_AsVal_int(obj0, &val1);
26336 if (!SWIG_IsOK(ecode1)) {
26337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26338 }
26339 arg1 = static_cast< int >(val1);
26340 }
26341 {
26342 PyThreadState* __tstate = wxPyBeginAllowThreads();
26343 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26355 PyObject *resultobj = 0;
26356 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26357 bool arg2 ;
26358 void *argp1 = 0 ;
26359 int res1 = 0 ;
26360 bool val2 ;
26361 int ecode2 = 0 ;
26362 PyObject * obj0 = 0 ;
26363 PyObject * obj1 = 0 ;
26364 char * kwnames[] = {
26365 (char *) "self",(char *) "realized", NULL
26366 };
26367
26368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26370 if (!SWIG_IsOK(res1)) {
26371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26372 }
26373 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26374 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26375 if (!SWIG_IsOK(ecode2)) {
26376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26377 }
26378 arg2 = static_cast< bool >(val2);
26379 {
26380 PyThreadState* __tstate = wxPyBeginAllowThreads();
26381 (arg1)->SetPaletteRealized(arg2);
26382 wxPyEndAllowThreads(__tstate);
26383 if (PyErr_Occurred()) SWIG_fail;
26384 }
26385 resultobj = SWIG_Py_Void();
26386 return resultobj;
26387 fail:
26388 return NULL;
26389 }
26390
26391
26392 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26393 PyObject *resultobj = 0;
26394 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26395 bool result;
26396 void *argp1 = 0 ;
26397 int res1 = 0 ;
26398 PyObject *swig_obj[1] ;
26399
26400 if (!args) SWIG_fail;
26401 swig_obj[0] = args;
26402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26403 if (!SWIG_IsOK(res1)) {
26404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26405 }
26406 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 {
26414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26415 }
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26423 PyObject *obj;
26424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26425 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26426 return SWIG_Py_Void();
26427 }
26428
26429 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26430 return SWIG_Python_InitShadowInstance(args);
26431 }
26432
26433 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26434 PyObject *resultobj = 0;
26435 wxNavigationKeyEvent *result = 0 ;
26436
26437 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26438 {
26439 PyThreadState* __tstate = wxPyBeginAllowThreads();
26440 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26441 wxPyEndAllowThreads(__tstate);
26442 if (PyErr_Occurred()) SWIG_fail;
26443 }
26444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26445 return resultobj;
26446 fail:
26447 return NULL;
26448 }
26449
26450
26451 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26452 PyObject *resultobj = 0;
26453 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26454 bool result;
26455 void *argp1 = 0 ;
26456 int res1 = 0 ;
26457 PyObject *swig_obj[1] ;
26458
26459 if (!args) SWIG_fail;
26460 swig_obj[0] = args;
26461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26462 if (!SWIG_IsOK(res1)) {
26463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26464 }
26465 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26466 {
26467 PyThreadState* __tstate = wxPyBeginAllowThreads();
26468 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26469 wxPyEndAllowThreads(__tstate);
26470 if (PyErr_Occurred()) SWIG_fail;
26471 }
26472 {
26473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26474 }
26475 return resultobj;
26476 fail:
26477 return NULL;
26478 }
26479
26480
26481 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26482 PyObject *resultobj = 0;
26483 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26484 bool arg2 ;
26485 void *argp1 = 0 ;
26486 int res1 = 0 ;
26487 bool val2 ;
26488 int ecode2 = 0 ;
26489 PyObject * obj0 = 0 ;
26490 PyObject * obj1 = 0 ;
26491 char * kwnames[] = {
26492 (char *) "self",(char *) "forward", NULL
26493 };
26494
26495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26497 if (!SWIG_IsOK(res1)) {
26498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26499 }
26500 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26501 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26502 if (!SWIG_IsOK(ecode2)) {
26503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26504 }
26505 arg2 = static_cast< bool >(val2);
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 (arg1)->SetDirection(arg2);
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 resultobj = SWIG_Py_Void();
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26520 PyObject *resultobj = 0;
26521 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26522 bool result;
26523 void *argp1 = 0 ;
26524 int res1 = 0 ;
26525 PyObject *swig_obj[1] ;
26526
26527 if (!args) SWIG_fail;
26528 swig_obj[0] = args;
26529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26530 if (!SWIG_IsOK(res1)) {
26531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26532 }
26533 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 {
26541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26542 }
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26550 PyObject *resultobj = 0;
26551 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26552 bool arg2 ;
26553 void *argp1 = 0 ;
26554 int res1 = 0 ;
26555 bool val2 ;
26556 int ecode2 = 0 ;
26557 PyObject * obj0 = 0 ;
26558 PyObject * obj1 = 0 ;
26559 char * kwnames[] = {
26560 (char *) "self",(char *) "ischange", NULL
26561 };
26562
26563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26565 if (!SWIG_IsOK(res1)) {
26566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26567 }
26568 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26569 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26570 if (!SWIG_IsOK(ecode2)) {
26571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26572 }
26573 arg2 = static_cast< bool >(val2);
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 (arg1)->SetWindowChange(arg2);
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 resultobj = SWIG_Py_Void();
26581 return resultobj;
26582 fail:
26583 return NULL;
26584 }
26585
26586
26587 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26588 PyObject *resultobj = 0;
26589 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26590 bool result;
26591 void *argp1 = 0 ;
26592 int res1 = 0 ;
26593 PyObject *swig_obj[1] ;
26594
26595 if (!args) SWIG_fail;
26596 swig_obj[0] = args;
26597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26598 if (!SWIG_IsOK(res1)) {
26599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26600 }
26601 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26605 wxPyEndAllowThreads(__tstate);
26606 if (PyErr_Occurred()) SWIG_fail;
26607 }
26608 {
26609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26610 }
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26618 PyObject *resultobj = 0;
26619 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26620 bool arg2 ;
26621 void *argp1 = 0 ;
26622 int res1 = 0 ;
26623 bool val2 ;
26624 int ecode2 = 0 ;
26625 PyObject * obj0 = 0 ;
26626 PyObject * obj1 = 0 ;
26627 char * kwnames[] = {
26628 (char *) "self",(char *) "bIs", NULL
26629 };
26630
26631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26635 }
26636 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26637 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26638 if (!SWIG_IsOK(ecode2)) {
26639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26640 }
26641 arg2 = static_cast< bool >(val2);
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 (arg1)->SetFromTab(arg2);
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 resultobj = SWIG_Py_Void();
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26656 PyObject *resultobj = 0;
26657 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26658 long arg2 ;
26659 void *argp1 = 0 ;
26660 int res1 = 0 ;
26661 long val2 ;
26662 int ecode2 = 0 ;
26663 PyObject * obj0 = 0 ;
26664 PyObject * obj1 = 0 ;
26665 char * kwnames[] = {
26666 (char *) "self",(char *) "flags", NULL
26667 };
26668
26669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26671 if (!SWIG_IsOK(res1)) {
26672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26673 }
26674 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26675 ecode2 = SWIG_AsVal_long(obj1, &val2);
26676 if (!SWIG_IsOK(ecode2)) {
26677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26678 }
26679 arg2 = static_cast< long >(val2);
26680 {
26681 PyThreadState* __tstate = wxPyBeginAllowThreads();
26682 (arg1)->SetFlags(arg2);
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 resultobj = SWIG_Py_Void();
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26694 PyObject *resultobj = 0;
26695 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26696 wxWindow *result = 0 ;
26697 void *argp1 = 0 ;
26698 int res1 = 0 ;
26699 PyObject *swig_obj[1] ;
26700
26701 if (!args) SWIG_fail;
26702 swig_obj[0] = args;
26703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26704 if (!SWIG_IsOK(res1)) {
26705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26706 }
26707 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 {
26715 resultobj = wxPyMake_wxObject(result, (bool)0);
26716 }
26717 return resultobj;
26718 fail:
26719 return NULL;
26720 }
26721
26722
26723 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26724 PyObject *resultobj = 0;
26725 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26726 wxWindow *arg2 = (wxWindow *) 0 ;
26727 void *argp1 = 0 ;
26728 int res1 = 0 ;
26729 void *argp2 = 0 ;
26730 int res2 = 0 ;
26731 PyObject * obj0 = 0 ;
26732 PyObject * obj1 = 0 ;
26733 char * kwnames[] = {
26734 (char *) "self",(char *) "win", NULL
26735 };
26736
26737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26739 if (!SWIG_IsOK(res1)) {
26740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26741 }
26742 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26743 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26744 if (!SWIG_IsOK(res2)) {
26745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26746 }
26747 arg2 = reinterpret_cast< wxWindow * >(argp2);
26748 {
26749 PyThreadState* __tstate = wxPyBeginAllowThreads();
26750 (arg1)->SetCurrentFocus(arg2);
26751 wxPyEndAllowThreads(__tstate);
26752 if (PyErr_Occurred()) SWIG_fail;
26753 }
26754 resultobj = SWIG_Py_Void();
26755 return resultobj;
26756 fail:
26757 return NULL;
26758 }
26759
26760
26761 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26762 PyObject *obj;
26763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26764 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26765 return SWIG_Py_Void();
26766 }
26767
26768 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26769 return SWIG_Python_InitShadowInstance(args);
26770 }
26771
26772 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26773 PyObject *resultobj = 0;
26774 wxWindow *arg1 = (wxWindow *) NULL ;
26775 wxWindowCreateEvent *result = 0 ;
26776 void *argp1 = 0 ;
26777 int res1 = 0 ;
26778 PyObject * obj0 = 0 ;
26779 char * kwnames[] = {
26780 (char *) "win", NULL
26781 };
26782
26783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26784 if (obj0) {
26785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26786 if (!SWIG_IsOK(res1)) {
26787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26788 }
26789 arg1 = reinterpret_cast< wxWindow * >(argp1);
26790 }
26791 {
26792 PyThreadState* __tstate = wxPyBeginAllowThreads();
26793 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26798 return resultobj;
26799 fail:
26800 return NULL;
26801 }
26802
26803
26804 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26805 PyObject *resultobj = 0;
26806 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26807 wxWindow *result = 0 ;
26808 void *argp1 = 0 ;
26809 int res1 = 0 ;
26810 PyObject *swig_obj[1] ;
26811
26812 if (!args) SWIG_fail;
26813 swig_obj[0] = args;
26814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26815 if (!SWIG_IsOK(res1)) {
26816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26817 }
26818 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26819 {
26820 PyThreadState* __tstate = wxPyBeginAllowThreads();
26821 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26822 wxPyEndAllowThreads(__tstate);
26823 if (PyErr_Occurred()) SWIG_fail;
26824 }
26825 {
26826 resultobj = wxPyMake_wxObject(result, (bool)0);
26827 }
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26835 PyObject *obj;
26836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26837 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26838 return SWIG_Py_Void();
26839 }
26840
26841 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26842 return SWIG_Python_InitShadowInstance(args);
26843 }
26844
26845 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26846 PyObject *resultobj = 0;
26847 wxWindow *arg1 = (wxWindow *) NULL ;
26848 wxWindowDestroyEvent *result = 0 ;
26849 void *argp1 = 0 ;
26850 int res1 = 0 ;
26851 PyObject * obj0 = 0 ;
26852 char * kwnames[] = {
26853 (char *) "win", NULL
26854 };
26855
26856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26857 if (obj0) {
26858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26859 if (!SWIG_IsOK(res1)) {
26860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26861 }
26862 arg1 = reinterpret_cast< wxWindow * >(argp1);
26863 }
26864 {
26865 PyThreadState* __tstate = wxPyBeginAllowThreads();
26866 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26867 wxPyEndAllowThreads(__tstate);
26868 if (PyErr_Occurred()) SWIG_fail;
26869 }
26870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26871 return resultobj;
26872 fail:
26873 return NULL;
26874 }
26875
26876
26877 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26878 PyObject *resultobj = 0;
26879 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26880 wxWindow *result = 0 ;
26881 void *argp1 = 0 ;
26882 int res1 = 0 ;
26883 PyObject *swig_obj[1] ;
26884
26885 if (!args) SWIG_fail;
26886 swig_obj[0] = args;
26887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26888 if (!SWIG_IsOK(res1)) {
26889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26890 }
26891 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26892 {
26893 PyThreadState* __tstate = wxPyBeginAllowThreads();
26894 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26895 wxPyEndAllowThreads(__tstate);
26896 if (PyErr_Occurred()) SWIG_fail;
26897 }
26898 {
26899 resultobj = wxPyMake_wxObject(result, (bool)0);
26900 }
26901 return resultobj;
26902 fail:
26903 return NULL;
26904 }
26905
26906
26907 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26908 PyObject *obj;
26909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26910 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26911 return SWIG_Py_Void();
26912 }
26913
26914 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26915 return SWIG_Python_InitShadowInstance(args);
26916 }
26917
26918 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26919 PyObject *resultobj = 0;
26920 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26921 int arg2 = (int) 0 ;
26922 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26923 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26924 wxContextMenuEvent *result = 0 ;
26925 int val1 ;
26926 int ecode1 = 0 ;
26927 int val2 ;
26928 int ecode2 = 0 ;
26929 wxPoint temp3 ;
26930 PyObject * obj0 = 0 ;
26931 PyObject * obj1 = 0 ;
26932 PyObject * obj2 = 0 ;
26933 char * kwnames[] = {
26934 (char *) "type",(char *) "winid",(char *) "pt", NULL
26935 };
26936
26937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26938 if (obj0) {
26939 ecode1 = SWIG_AsVal_int(obj0, &val1);
26940 if (!SWIG_IsOK(ecode1)) {
26941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26942 }
26943 arg1 = static_cast< wxEventType >(val1);
26944 }
26945 if (obj1) {
26946 ecode2 = SWIG_AsVal_int(obj1, &val2);
26947 if (!SWIG_IsOK(ecode2)) {
26948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26949 }
26950 arg2 = static_cast< int >(val2);
26951 }
26952 if (obj2) {
26953 {
26954 arg3 = &temp3;
26955 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26956 }
26957 }
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26965 return resultobj;
26966 fail:
26967 return NULL;
26968 }
26969
26970
26971 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26972 PyObject *resultobj = 0;
26973 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26974 wxPoint *result = 0 ;
26975 void *argp1 = 0 ;
26976 int res1 = 0 ;
26977 PyObject *swig_obj[1] ;
26978
26979 if (!args) SWIG_fail;
26980 swig_obj[0] = args;
26981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26982 if (!SWIG_IsOK(res1)) {
26983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26984 }
26985 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26986 {
26987 PyThreadState* __tstate = wxPyBeginAllowThreads();
26988 {
26989 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26990 result = (wxPoint *) &_result_ref;
26991 }
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26996 return resultobj;
26997 fail:
26998 return NULL;
26999 }
27000
27001
27002 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27003 PyObject *resultobj = 0;
27004 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27005 wxPoint *arg2 = 0 ;
27006 void *argp1 = 0 ;
27007 int res1 = 0 ;
27008 wxPoint temp2 ;
27009 PyObject * obj0 = 0 ;
27010 PyObject * obj1 = 0 ;
27011 char * kwnames[] = {
27012 (char *) "self",(char *) "pos", NULL
27013 };
27014
27015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27017 if (!SWIG_IsOK(res1)) {
27018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27019 }
27020 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27021 {
27022 arg2 = &temp2;
27023 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27024 }
27025 {
27026 PyThreadState* __tstate = wxPyBeginAllowThreads();
27027 (arg1)->SetPosition((wxPoint const &)*arg2);
27028 wxPyEndAllowThreads(__tstate);
27029 if (PyErr_Occurred()) SWIG_fail;
27030 }
27031 resultobj = SWIG_Py_Void();
27032 return resultobj;
27033 fail:
27034 return NULL;
27035 }
27036
27037
27038 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27039 PyObject *obj;
27040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27041 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27042 return SWIG_Py_Void();
27043 }
27044
27045 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27046 return SWIG_Python_InitShadowInstance(args);
27047 }
27048
27049 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27050 PyObject *resultobj = 0;
27051 wxIdleEvent *result = 0 ;
27052
27053 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27054 {
27055 PyThreadState* __tstate = wxPyBeginAllowThreads();
27056 result = (wxIdleEvent *)new wxIdleEvent();
27057 wxPyEndAllowThreads(__tstate);
27058 if (PyErr_Occurred()) SWIG_fail;
27059 }
27060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27061 return resultobj;
27062 fail:
27063 return NULL;
27064 }
27065
27066
27067 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27068 PyObject *resultobj = 0;
27069 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27070 bool arg2 = (bool) true ;
27071 void *argp1 = 0 ;
27072 int res1 = 0 ;
27073 bool val2 ;
27074 int ecode2 = 0 ;
27075 PyObject * obj0 = 0 ;
27076 PyObject * obj1 = 0 ;
27077 char * kwnames[] = {
27078 (char *) "self",(char *) "needMore", NULL
27079 };
27080
27081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27083 if (!SWIG_IsOK(res1)) {
27084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27085 }
27086 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27087 if (obj1) {
27088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27089 if (!SWIG_IsOK(ecode2)) {
27090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27091 }
27092 arg2 = static_cast< bool >(val2);
27093 }
27094 {
27095 PyThreadState* __tstate = wxPyBeginAllowThreads();
27096 (arg1)->RequestMore(arg2);
27097 wxPyEndAllowThreads(__tstate);
27098 if (PyErr_Occurred()) SWIG_fail;
27099 }
27100 resultobj = SWIG_Py_Void();
27101 return resultobj;
27102 fail:
27103 return NULL;
27104 }
27105
27106
27107 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27108 PyObject *resultobj = 0;
27109 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27110 bool result;
27111 void *argp1 = 0 ;
27112 int res1 = 0 ;
27113 PyObject *swig_obj[1] ;
27114
27115 if (!args) SWIG_fail;
27116 swig_obj[0] = args;
27117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27118 if (!SWIG_IsOK(res1)) {
27119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27120 }
27121 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27125 wxPyEndAllowThreads(__tstate);
27126 if (PyErr_Occurred()) SWIG_fail;
27127 }
27128 {
27129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27130 }
27131 return resultobj;
27132 fail:
27133 return NULL;
27134 }
27135
27136
27137 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27138 PyObject *resultobj = 0;
27139 wxIdleMode arg1 ;
27140 int val1 ;
27141 int ecode1 = 0 ;
27142 PyObject * obj0 = 0 ;
27143 char * kwnames[] = {
27144 (char *) "mode", NULL
27145 };
27146
27147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27148 ecode1 = SWIG_AsVal_int(obj0, &val1);
27149 if (!SWIG_IsOK(ecode1)) {
27150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27151 }
27152 arg1 = static_cast< wxIdleMode >(val1);
27153 {
27154 PyThreadState* __tstate = wxPyBeginAllowThreads();
27155 wxIdleEvent::SetMode(arg1);
27156 wxPyEndAllowThreads(__tstate);
27157 if (PyErr_Occurred()) SWIG_fail;
27158 }
27159 resultobj = SWIG_Py_Void();
27160 return resultobj;
27161 fail:
27162 return NULL;
27163 }
27164
27165
27166 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27167 PyObject *resultobj = 0;
27168 wxIdleMode result;
27169
27170 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27171 {
27172 PyThreadState* __tstate = wxPyBeginAllowThreads();
27173 result = (wxIdleMode)wxIdleEvent::GetMode();
27174 wxPyEndAllowThreads(__tstate);
27175 if (PyErr_Occurred()) SWIG_fail;
27176 }
27177 resultobj = SWIG_From_int(static_cast< int >(result));
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj = 0;
27186 wxWindow *arg1 = (wxWindow *) 0 ;
27187 bool result;
27188 void *argp1 = 0 ;
27189 int res1 = 0 ;
27190 PyObject * obj0 = 0 ;
27191 char * kwnames[] = {
27192 (char *) "win", NULL
27193 };
27194
27195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27197 if (!SWIG_IsOK(res1)) {
27198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27199 }
27200 arg1 = reinterpret_cast< wxWindow * >(argp1);
27201 {
27202 PyThreadState* __tstate = wxPyBeginAllowThreads();
27203 result = (bool)wxIdleEvent::CanSend(arg1);
27204 wxPyEndAllowThreads(__tstate);
27205 if (PyErr_Occurred()) SWIG_fail;
27206 }
27207 {
27208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27209 }
27210 return resultobj;
27211 fail:
27212 return NULL;
27213 }
27214
27215
27216 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27217 PyObject *obj;
27218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27219 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27220 return SWIG_Py_Void();
27221 }
27222
27223 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27224 return SWIG_Python_InitShadowInstance(args);
27225 }
27226
27227 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27228 PyObject *resultobj = 0;
27229 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27230 int arg2 = (int) 0 ;
27231 wxClipboardTextEvent *result = 0 ;
27232 int val1 ;
27233 int ecode1 = 0 ;
27234 int val2 ;
27235 int ecode2 = 0 ;
27236 PyObject * obj0 = 0 ;
27237 PyObject * obj1 = 0 ;
27238 char * kwnames[] = {
27239 (char *) "type",(char *) "winid", NULL
27240 };
27241
27242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27243 if (obj0) {
27244 ecode1 = SWIG_AsVal_int(obj0, &val1);
27245 if (!SWIG_IsOK(ecode1)) {
27246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27247 }
27248 arg1 = static_cast< wxEventType >(val1);
27249 }
27250 if (obj1) {
27251 ecode2 = SWIG_AsVal_int(obj1, &val2);
27252 if (!SWIG_IsOK(ecode2)) {
27253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27254 }
27255 arg2 = static_cast< int >(val2);
27256 }
27257 {
27258 PyThreadState* __tstate = wxPyBeginAllowThreads();
27259 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27260 wxPyEndAllowThreads(__tstate);
27261 if (PyErr_Occurred()) SWIG_fail;
27262 }
27263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27264 return resultobj;
27265 fail:
27266 return NULL;
27267 }
27268
27269
27270 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27271 PyObject *obj;
27272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27273 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27274 return SWIG_Py_Void();
27275 }
27276
27277 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27278 return SWIG_Python_InitShadowInstance(args);
27279 }
27280
27281 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27282 PyObject *resultobj = 0;
27283 int arg1 = (int) 0 ;
27284 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27285 wxPyEvent *result = 0 ;
27286 int val1 ;
27287 int ecode1 = 0 ;
27288 int val2 ;
27289 int ecode2 = 0 ;
27290 PyObject * obj0 = 0 ;
27291 PyObject * obj1 = 0 ;
27292 char * kwnames[] = {
27293 (char *) "winid",(char *) "eventType", NULL
27294 };
27295
27296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27297 if (obj0) {
27298 ecode1 = SWIG_AsVal_int(obj0, &val1);
27299 if (!SWIG_IsOK(ecode1)) {
27300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27301 }
27302 arg1 = static_cast< int >(val1);
27303 }
27304 if (obj1) {
27305 ecode2 = SWIG_AsVal_int(obj1, &val2);
27306 if (!SWIG_IsOK(ecode2)) {
27307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27308 }
27309 arg2 = static_cast< wxEventType >(val2);
27310 }
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27318 return resultobj;
27319 fail:
27320 return NULL;
27321 }
27322
27323
27324 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27325 PyObject *resultobj = 0;
27326 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27327 void *argp1 = 0 ;
27328 int res1 = 0 ;
27329 PyObject *swig_obj[1] ;
27330
27331 if (!args) SWIG_fail;
27332 swig_obj[0] = args;
27333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27334 if (!SWIG_IsOK(res1)) {
27335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27336 }
27337 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27338 {
27339 PyThreadState* __tstate = wxPyBeginAllowThreads();
27340 delete arg1;
27341
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 resultobj = SWIG_Py_Void();
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj = 0;
27354 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27355 PyObject *arg2 = (PyObject *) 0 ;
27356 void *argp1 = 0 ;
27357 int res1 = 0 ;
27358 PyObject * obj0 = 0 ;
27359 PyObject * obj1 = 0 ;
27360 char * kwnames[] = {
27361 (char *) "self",(char *) "self", NULL
27362 };
27363
27364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27366 if (!SWIG_IsOK(res1)) {
27367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27368 }
27369 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27370 arg2 = obj1;
27371 {
27372 PyThreadState* __tstate = wxPyBeginAllowThreads();
27373 (arg1)->SetSelf(arg2);
27374 wxPyEndAllowThreads(__tstate);
27375 if (PyErr_Occurred()) SWIG_fail;
27376 }
27377 resultobj = SWIG_Py_Void();
27378 return resultobj;
27379 fail:
27380 return NULL;
27381 }
27382
27383
27384 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27385 PyObject *resultobj = 0;
27386 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27387 PyObject *result = 0 ;
27388 void *argp1 = 0 ;
27389 int res1 = 0 ;
27390 PyObject *swig_obj[1] ;
27391
27392 if (!args) SWIG_fail;
27393 swig_obj[0] = args;
27394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27395 if (!SWIG_IsOK(res1)) {
27396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27397 }
27398 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (PyObject *)(arg1)->GetSelf();
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 resultobj = result;
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27413 PyObject *obj;
27414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27415 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27416 return SWIG_Py_Void();
27417 }
27418
27419 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27420 return SWIG_Python_InitShadowInstance(args);
27421 }
27422
27423 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27424 PyObject *resultobj = 0;
27425 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27426 int arg2 = (int) 0 ;
27427 wxPyCommandEvent *result = 0 ;
27428 int val1 ;
27429 int ecode1 = 0 ;
27430 int val2 ;
27431 int ecode2 = 0 ;
27432 PyObject * obj0 = 0 ;
27433 PyObject * obj1 = 0 ;
27434 char * kwnames[] = {
27435 (char *) "eventType",(char *) "id", NULL
27436 };
27437
27438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27439 if (obj0) {
27440 ecode1 = SWIG_AsVal_int(obj0, &val1);
27441 if (!SWIG_IsOK(ecode1)) {
27442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27443 }
27444 arg1 = static_cast< wxEventType >(val1);
27445 }
27446 if (obj1) {
27447 ecode2 = SWIG_AsVal_int(obj1, &val2);
27448 if (!SWIG_IsOK(ecode2)) {
27449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27450 }
27451 arg2 = static_cast< int >(val2);
27452 }
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27460 return resultobj;
27461 fail:
27462 return NULL;
27463 }
27464
27465
27466 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27467 PyObject *resultobj = 0;
27468 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27469 void *argp1 = 0 ;
27470 int res1 = 0 ;
27471 PyObject *swig_obj[1] ;
27472
27473 if (!args) SWIG_fail;
27474 swig_obj[0] = args;
27475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27476 if (!SWIG_IsOK(res1)) {
27477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27478 }
27479 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27480 {
27481 PyThreadState* __tstate = wxPyBeginAllowThreads();
27482 delete arg1;
27483
27484 wxPyEndAllowThreads(__tstate);
27485 if (PyErr_Occurred()) SWIG_fail;
27486 }
27487 resultobj = SWIG_Py_Void();
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27495 PyObject *resultobj = 0;
27496 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27497 PyObject *arg2 = (PyObject *) 0 ;
27498 void *argp1 = 0 ;
27499 int res1 = 0 ;
27500 PyObject * obj0 = 0 ;
27501 PyObject * obj1 = 0 ;
27502 char * kwnames[] = {
27503 (char *) "self",(char *) "self", NULL
27504 };
27505
27506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27508 if (!SWIG_IsOK(res1)) {
27509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27510 }
27511 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27512 arg2 = obj1;
27513 {
27514 PyThreadState* __tstate = wxPyBeginAllowThreads();
27515 (arg1)->SetSelf(arg2);
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 resultobj = SWIG_Py_Void();
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27527 PyObject *resultobj = 0;
27528 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27529 PyObject *result = 0 ;
27530 void *argp1 = 0 ;
27531 int res1 = 0 ;
27532 PyObject *swig_obj[1] ;
27533
27534 if (!args) SWIG_fail;
27535 swig_obj[0] = args;
27536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27537 if (!SWIG_IsOK(res1)) {
27538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27539 }
27540 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 result = (PyObject *)(arg1)->GetSelf();
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 resultobj = result;
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27555 PyObject *obj;
27556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27557 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27558 return SWIG_Py_Void();
27559 }
27560
27561 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27562 return SWIG_Python_InitShadowInstance(args);
27563 }
27564
27565 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27566 PyObject *resultobj = 0;
27567 wxWindow *arg1 = (wxWindow *) 0 ;
27568 wxDateTime *arg2 = 0 ;
27569 wxEventType arg3 ;
27570 wxDateEvent *result = 0 ;
27571 void *argp1 = 0 ;
27572 int res1 = 0 ;
27573 void *argp2 = 0 ;
27574 int res2 = 0 ;
27575 int val3 ;
27576 int ecode3 = 0 ;
27577 PyObject * obj0 = 0 ;
27578 PyObject * obj1 = 0 ;
27579 PyObject * obj2 = 0 ;
27580 char * kwnames[] = {
27581 (char *) "win",(char *) "dt",(char *) "type", NULL
27582 };
27583
27584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27586 if (!SWIG_IsOK(res1)) {
27587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27588 }
27589 arg1 = reinterpret_cast< wxWindow * >(argp1);
27590 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27591 if (!SWIG_IsOK(res2)) {
27592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27593 }
27594 if (!argp2) {
27595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27596 }
27597 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27598 ecode3 = SWIG_AsVal_int(obj2, &val3);
27599 if (!SWIG_IsOK(ecode3)) {
27600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27601 }
27602 arg3 = static_cast< wxEventType >(val3);
27603 {
27604 PyThreadState* __tstate = wxPyBeginAllowThreads();
27605 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27606 wxPyEndAllowThreads(__tstate);
27607 if (PyErr_Occurred()) SWIG_fail;
27608 }
27609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27610 return resultobj;
27611 fail:
27612 return NULL;
27613 }
27614
27615
27616 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27617 PyObject *resultobj = 0;
27618 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27619 wxDateTime *result = 0 ;
27620 void *argp1 = 0 ;
27621 int res1 = 0 ;
27622 PyObject *swig_obj[1] ;
27623
27624 if (!args) SWIG_fail;
27625 swig_obj[0] = args;
27626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27627 if (!SWIG_IsOK(res1)) {
27628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27629 }
27630 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 {
27634 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27635 result = (wxDateTime *) &_result_ref;
27636 }
27637 wxPyEndAllowThreads(__tstate);
27638 if (PyErr_Occurred()) SWIG_fail;
27639 }
27640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27641 return resultobj;
27642 fail:
27643 return NULL;
27644 }
27645
27646
27647 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27648 PyObject *resultobj = 0;
27649 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27650 wxDateTime *arg2 = 0 ;
27651 void *argp1 = 0 ;
27652 int res1 = 0 ;
27653 void *argp2 = 0 ;
27654 int res2 = 0 ;
27655 PyObject * obj0 = 0 ;
27656 PyObject * obj1 = 0 ;
27657 char * kwnames[] = {
27658 (char *) "self",(char *) "date", NULL
27659 };
27660
27661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27663 if (!SWIG_IsOK(res1)) {
27664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27665 }
27666 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27667 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27668 if (!SWIG_IsOK(res2)) {
27669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27670 }
27671 if (!argp2) {
27672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27673 }
27674 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27675 {
27676 PyThreadState* __tstate = wxPyBeginAllowThreads();
27677 (arg1)->SetDate((wxDateTime const &)*arg2);
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 resultobj = SWIG_Py_Void();
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27689 PyObject *obj;
27690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27691 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27692 return SWIG_Py_Void();
27693 }
27694
27695 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27696 return SWIG_Python_InitShadowInstance(args);
27697 }
27698
27699 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27700 PyObject *resultobj = 0;
27701 wxPyApp *result = 0 ;
27702
27703 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27704 {
27705 PyThreadState* __tstate = wxPyBeginAllowThreads();
27706 result = (wxPyApp *)new_wxPyApp();
27707 wxPyEndAllowThreads(__tstate);
27708 if (PyErr_Occurred()) SWIG_fail;
27709 }
27710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27711 return resultobj;
27712 fail:
27713 return NULL;
27714 }
27715
27716
27717 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27718 PyObject *resultobj = 0;
27719 wxPyApp *arg1 = (wxPyApp *) 0 ;
27720 void *argp1 = 0 ;
27721 int res1 = 0 ;
27722 PyObject *swig_obj[1] ;
27723
27724 if (!args) SWIG_fail;
27725 swig_obj[0] = args;
27726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27727 if (!SWIG_IsOK(res1)) {
27728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27729 }
27730 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27731 {
27732 PyThreadState* __tstate = wxPyBeginAllowThreads();
27733 delete arg1;
27734
27735 wxPyEndAllowThreads(__tstate);
27736 if (PyErr_Occurred()) SWIG_fail;
27737 }
27738 resultobj = SWIG_Py_Void();
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27746 PyObject *resultobj = 0;
27747 wxPyApp *arg1 = (wxPyApp *) 0 ;
27748 PyObject *arg2 = (PyObject *) 0 ;
27749 PyObject *arg3 = (PyObject *) 0 ;
27750 bool arg4 ;
27751 void *argp1 = 0 ;
27752 int res1 = 0 ;
27753 bool val4 ;
27754 int ecode4 = 0 ;
27755 PyObject * obj0 = 0 ;
27756 PyObject * obj1 = 0 ;
27757 PyObject * obj2 = 0 ;
27758 PyObject * obj3 = 0 ;
27759 char * kwnames[] = {
27760 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27761 };
27762
27763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27765 if (!SWIG_IsOK(res1)) {
27766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27767 }
27768 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27769 arg2 = obj1;
27770 arg3 = obj2;
27771 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27772 if (!SWIG_IsOK(ecode4)) {
27773 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27774 }
27775 arg4 = static_cast< bool >(val4);
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27779 wxPyEndAllowThreads(__tstate);
27780 if (PyErr_Occurred()) SWIG_fail;
27781 }
27782 resultobj = SWIG_Py_Void();
27783 return resultobj;
27784 fail:
27785 return NULL;
27786 }
27787
27788
27789 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27790 PyObject *resultobj = 0;
27791 wxPyApp *arg1 = (wxPyApp *) 0 ;
27792 wxString result;
27793 void *argp1 = 0 ;
27794 int res1 = 0 ;
27795 PyObject *swig_obj[1] ;
27796
27797 if (!args) SWIG_fail;
27798 swig_obj[0] = args;
27799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27800 if (!SWIG_IsOK(res1)) {
27801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27802 }
27803 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27804 {
27805 PyThreadState* __tstate = wxPyBeginAllowThreads();
27806 result = ((wxPyApp const *)arg1)->GetAppName();
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 {
27811 #if wxUSE_UNICODE
27812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27813 #else
27814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27815 #endif
27816 }
27817 return resultobj;
27818 fail:
27819 return NULL;
27820 }
27821
27822
27823 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27824 PyObject *resultobj = 0;
27825 wxPyApp *arg1 = (wxPyApp *) 0 ;
27826 wxString *arg2 = 0 ;
27827 void *argp1 = 0 ;
27828 int res1 = 0 ;
27829 bool temp2 = false ;
27830 PyObject * obj0 = 0 ;
27831 PyObject * obj1 = 0 ;
27832 char * kwnames[] = {
27833 (char *) "self",(char *) "name", NULL
27834 };
27835
27836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27838 if (!SWIG_IsOK(res1)) {
27839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27840 }
27841 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27842 {
27843 arg2 = wxString_in_helper(obj1);
27844 if (arg2 == NULL) SWIG_fail;
27845 temp2 = true;
27846 }
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 (arg1)->SetAppName((wxString const &)*arg2);
27850 wxPyEndAllowThreads(__tstate);
27851 if (PyErr_Occurred()) SWIG_fail;
27852 }
27853 resultobj = SWIG_Py_Void();
27854 {
27855 if (temp2)
27856 delete arg2;
27857 }
27858 return resultobj;
27859 fail:
27860 {
27861 if (temp2)
27862 delete arg2;
27863 }
27864 return NULL;
27865 }
27866
27867
27868 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27869 PyObject *resultobj = 0;
27870 wxPyApp *arg1 = (wxPyApp *) 0 ;
27871 wxString result;
27872 void *argp1 = 0 ;
27873 int res1 = 0 ;
27874 PyObject *swig_obj[1] ;
27875
27876 if (!args) SWIG_fail;
27877 swig_obj[0] = args;
27878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27879 if (!SWIG_IsOK(res1)) {
27880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27881 }
27882 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 result = ((wxPyApp const *)arg1)->GetClassName();
27886 wxPyEndAllowThreads(__tstate);
27887 if (PyErr_Occurred()) SWIG_fail;
27888 }
27889 {
27890 #if wxUSE_UNICODE
27891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27892 #else
27893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27894 #endif
27895 }
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27903 PyObject *resultobj = 0;
27904 wxPyApp *arg1 = (wxPyApp *) 0 ;
27905 wxString *arg2 = 0 ;
27906 void *argp1 = 0 ;
27907 int res1 = 0 ;
27908 bool temp2 = false ;
27909 PyObject * obj0 = 0 ;
27910 PyObject * obj1 = 0 ;
27911 char * kwnames[] = {
27912 (char *) "self",(char *) "name", NULL
27913 };
27914
27915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27917 if (!SWIG_IsOK(res1)) {
27918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27919 }
27920 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27921 {
27922 arg2 = wxString_in_helper(obj1);
27923 if (arg2 == NULL) SWIG_fail;
27924 temp2 = true;
27925 }
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 (arg1)->SetClassName((wxString const &)*arg2);
27929 wxPyEndAllowThreads(__tstate);
27930 if (PyErr_Occurred()) SWIG_fail;
27931 }
27932 resultobj = SWIG_Py_Void();
27933 {
27934 if (temp2)
27935 delete arg2;
27936 }
27937 return resultobj;
27938 fail:
27939 {
27940 if (temp2)
27941 delete arg2;
27942 }
27943 return NULL;
27944 }
27945
27946
27947 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27948 PyObject *resultobj = 0;
27949 wxPyApp *arg1 = (wxPyApp *) 0 ;
27950 wxString *result = 0 ;
27951 void *argp1 = 0 ;
27952 int res1 = 0 ;
27953 PyObject *swig_obj[1] ;
27954
27955 if (!args) SWIG_fail;
27956 swig_obj[0] = args;
27957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27958 if (!SWIG_IsOK(res1)) {
27959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27960 }
27961 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27962 {
27963 PyThreadState* __tstate = wxPyBeginAllowThreads();
27964 {
27965 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27966 result = (wxString *) &_result_ref;
27967 }
27968 wxPyEndAllowThreads(__tstate);
27969 if (PyErr_Occurred()) SWIG_fail;
27970 }
27971 {
27972 #if wxUSE_UNICODE
27973 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27974 #else
27975 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27976 #endif
27977 }
27978 return resultobj;
27979 fail:
27980 return NULL;
27981 }
27982
27983
27984 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27985 PyObject *resultobj = 0;
27986 wxPyApp *arg1 = (wxPyApp *) 0 ;
27987 wxString *arg2 = 0 ;
27988 void *argp1 = 0 ;
27989 int res1 = 0 ;
27990 bool temp2 = false ;
27991 PyObject * obj0 = 0 ;
27992 PyObject * obj1 = 0 ;
27993 char * kwnames[] = {
27994 (char *) "self",(char *) "name", NULL
27995 };
27996
27997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27999 if (!SWIG_IsOK(res1)) {
28000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28001 }
28002 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28003 {
28004 arg2 = wxString_in_helper(obj1);
28005 if (arg2 == NULL) SWIG_fail;
28006 temp2 = true;
28007 }
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 (arg1)->SetVendorName((wxString const &)*arg2);
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 resultobj = SWIG_Py_Void();
28015 {
28016 if (temp2)
28017 delete arg2;
28018 }
28019 return resultobj;
28020 fail:
28021 {
28022 if (temp2)
28023 delete arg2;
28024 }
28025 return NULL;
28026 }
28027
28028
28029 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28030 PyObject *resultobj = 0;
28031 wxPyApp *arg1 = (wxPyApp *) 0 ;
28032 wxAppTraits *result = 0 ;
28033 void *argp1 = 0 ;
28034 int res1 = 0 ;
28035 PyObject *swig_obj[1] ;
28036
28037 if (!args) SWIG_fail;
28038 swig_obj[0] = args;
28039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28040 if (!SWIG_IsOK(res1)) {
28041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28042 }
28043 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28044 {
28045 PyThreadState* __tstate = wxPyBeginAllowThreads();
28046 result = (wxAppTraits *)(arg1)->GetTraits();
28047 wxPyEndAllowThreads(__tstate);
28048 if (PyErr_Occurred()) SWIG_fail;
28049 }
28050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28051 return resultobj;
28052 fail:
28053 return NULL;
28054 }
28055
28056
28057 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28058 PyObject *resultobj = 0;
28059 wxPyApp *arg1 = (wxPyApp *) 0 ;
28060 void *argp1 = 0 ;
28061 int res1 = 0 ;
28062 PyObject *swig_obj[1] ;
28063
28064 if (!args) SWIG_fail;
28065 swig_obj[0] = args;
28066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28067 if (!SWIG_IsOK(res1)) {
28068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28069 }
28070 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28071 {
28072 PyThreadState* __tstate = wxPyBeginAllowThreads();
28073 (arg1)->ProcessPendingEvents();
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_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28085 PyObject *resultobj = 0;
28086 wxPyApp *arg1 = (wxPyApp *) 0 ;
28087 bool arg2 = (bool) false ;
28088 bool result;
28089 void *argp1 = 0 ;
28090 int res1 = 0 ;
28091 bool val2 ;
28092 int ecode2 = 0 ;
28093 PyObject * obj0 = 0 ;
28094 PyObject * obj1 = 0 ;
28095 char * kwnames[] = {
28096 (char *) "self",(char *) "onlyIfNeeded", NULL
28097 };
28098
28099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28101 if (!SWIG_IsOK(res1)) {
28102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28103 }
28104 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28105 if (obj1) {
28106 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28107 if (!SWIG_IsOK(ecode2)) {
28108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28109 }
28110 arg2 = static_cast< bool >(val2);
28111 }
28112 {
28113 PyThreadState* __tstate = wxPyBeginAllowThreads();
28114 result = (bool)(arg1)->Yield(arg2);
28115 wxPyEndAllowThreads(__tstate);
28116 if (PyErr_Occurred()) SWIG_fail;
28117 }
28118 {
28119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28120 }
28121 return resultobj;
28122 fail:
28123 return NULL;
28124 }
28125
28126
28127 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28128 PyObject *resultobj = 0;
28129 wxPyApp *arg1 = (wxPyApp *) 0 ;
28130 void *argp1 = 0 ;
28131 int res1 = 0 ;
28132 PyObject *swig_obj[1] ;
28133
28134 if (!args) SWIG_fail;
28135 swig_obj[0] = args;
28136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28137 if (!SWIG_IsOK(res1)) {
28138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28139 }
28140 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28141 {
28142 PyThreadState* __tstate = wxPyBeginAllowThreads();
28143 (arg1)->WakeUpIdle();
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 resultobj = SWIG_Py_Void();
28148 return resultobj;
28149 fail:
28150 return NULL;
28151 }
28152
28153
28154 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28155 PyObject *resultobj = 0;
28156 bool result;
28157
28158 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28159 {
28160 PyThreadState* __tstate = wxPyBeginAllowThreads();
28161 result = (bool)wxPyApp::IsMainLoopRunning();
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 {
28166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28167 }
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28175 PyObject *resultobj = 0;
28176 wxPyApp *arg1 = (wxPyApp *) 0 ;
28177 int result;
28178 void *argp1 = 0 ;
28179 int res1 = 0 ;
28180 PyObject *swig_obj[1] ;
28181
28182 if (!args) SWIG_fail;
28183 swig_obj[0] = args;
28184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28185 if (!SWIG_IsOK(res1)) {
28186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28187 }
28188 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 result = (int)(arg1)->MainLoop();
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 resultobj = SWIG_From_int(static_cast< int >(result));
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28203 PyObject *resultobj = 0;
28204 wxPyApp *arg1 = (wxPyApp *) 0 ;
28205 void *argp1 = 0 ;
28206 int res1 = 0 ;
28207 PyObject *swig_obj[1] ;
28208
28209 if (!args) SWIG_fail;
28210 swig_obj[0] = args;
28211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28212 if (!SWIG_IsOK(res1)) {
28213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28214 }
28215 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28216 {
28217 PyThreadState* __tstate = wxPyBeginAllowThreads();
28218 (arg1)->Exit();
28219 wxPyEndAllowThreads(__tstate);
28220 if (PyErr_Occurred()) SWIG_fail;
28221 }
28222 resultobj = SWIG_Py_Void();
28223 return resultobj;
28224 fail:
28225 return NULL;
28226 }
28227
28228
28229 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28230 PyObject *resultobj = 0;
28231 wxPyApp *arg1 = (wxPyApp *) 0 ;
28232 wxLayoutDirection result;
28233 void *argp1 = 0 ;
28234 int res1 = 0 ;
28235 PyObject *swig_obj[1] ;
28236
28237 if (!args) SWIG_fail;
28238 swig_obj[0] = args;
28239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28240 if (!SWIG_IsOK(res1)) {
28241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28242 }
28243 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28244 {
28245 PyThreadState* __tstate = wxPyBeginAllowThreads();
28246 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28247 wxPyEndAllowThreads(__tstate);
28248 if (PyErr_Occurred()) SWIG_fail;
28249 }
28250 resultobj = SWIG_From_int(static_cast< int >(result));
28251 return resultobj;
28252 fail:
28253 return NULL;
28254 }
28255
28256
28257 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28258 PyObject *resultobj = 0;
28259 wxPyApp *arg1 = (wxPyApp *) 0 ;
28260 void *argp1 = 0 ;
28261 int res1 = 0 ;
28262 PyObject *swig_obj[1] ;
28263
28264 if (!args) SWIG_fail;
28265 swig_obj[0] = args;
28266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28267 if (!SWIG_IsOK(res1)) {
28268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28269 }
28270 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28271 {
28272 PyThreadState* __tstate = wxPyBeginAllowThreads();
28273 (arg1)->ExitMainLoop();
28274 wxPyEndAllowThreads(__tstate);
28275 if (PyErr_Occurred()) SWIG_fail;
28276 }
28277 resultobj = SWIG_Py_Void();
28278 return resultobj;
28279 fail:
28280 return NULL;
28281 }
28282
28283
28284 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28285 PyObject *resultobj = 0;
28286 wxPyApp *arg1 = (wxPyApp *) 0 ;
28287 bool result;
28288 void *argp1 = 0 ;
28289 int res1 = 0 ;
28290 PyObject *swig_obj[1] ;
28291
28292 if (!args) SWIG_fail;
28293 swig_obj[0] = args;
28294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28295 if (!SWIG_IsOK(res1)) {
28296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28297 }
28298 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28299 {
28300 PyThreadState* __tstate = wxPyBeginAllowThreads();
28301 result = (bool)(arg1)->Pending();
28302 wxPyEndAllowThreads(__tstate);
28303 if (PyErr_Occurred()) SWIG_fail;
28304 }
28305 {
28306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28307 }
28308 return resultobj;
28309 fail:
28310 return NULL;
28311 }
28312
28313
28314 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28315 PyObject *resultobj = 0;
28316 wxPyApp *arg1 = (wxPyApp *) 0 ;
28317 bool result;
28318 void *argp1 = 0 ;
28319 int res1 = 0 ;
28320 PyObject *swig_obj[1] ;
28321
28322 if (!args) SWIG_fail;
28323 swig_obj[0] = args;
28324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28325 if (!SWIG_IsOK(res1)) {
28326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28327 }
28328 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = (bool)(arg1)->Dispatch();
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28337 }
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 PyObject *resultobj = 0;
28346 wxPyApp *arg1 = (wxPyApp *) 0 ;
28347 bool result;
28348 void *argp1 = 0 ;
28349 int res1 = 0 ;
28350 PyObject *swig_obj[1] ;
28351
28352 if (!args) SWIG_fail;
28353 swig_obj[0] = args;
28354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28355 if (!SWIG_IsOK(res1)) {
28356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28357 }
28358 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28359 {
28360 PyThreadState* __tstate = wxPyBeginAllowThreads();
28361 result = (bool)(arg1)->ProcessIdle();
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 {
28366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28367 }
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28375 PyObject *resultobj = 0;
28376 wxPyApp *arg1 = (wxPyApp *) 0 ;
28377 wxWindow *arg2 = (wxWindow *) 0 ;
28378 wxIdleEvent *arg3 = 0 ;
28379 bool result;
28380 void *argp1 = 0 ;
28381 int res1 = 0 ;
28382 void *argp2 = 0 ;
28383 int res2 = 0 ;
28384 void *argp3 = 0 ;
28385 int res3 = 0 ;
28386 PyObject * obj0 = 0 ;
28387 PyObject * obj1 = 0 ;
28388 PyObject * obj2 = 0 ;
28389 char * kwnames[] = {
28390 (char *) "self",(char *) "win",(char *) "event", NULL
28391 };
28392
28393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28395 if (!SWIG_IsOK(res1)) {
28396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28397 }
28398 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28400 if (!SWIG_IsOK(res2)) {
28401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28402 }
28403 arg2 = reinterpret_cast< wxWindow * >(argp2);
28404 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28405 if (!SWIG_IsOK(res3)) {
28406 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28407 }
28408 if (!argp3) {
28409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28410 }
28411 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28412 {
28413 PyThreadState* __tstate = wxPyBeginAllowThreads();
28414 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28415 wxPyEndAllowThreads(__tstate);
28416 if (PyErr_Occurred()) SWIG_fail;
28417 }
28418 {
28419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28420 }
28421 return resultobj;
28422 fail:
28423 return NULL;
28424 }
28425
28426
28427 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28428 PyObject *resultobj = 0;
28429 wxPyApp *arg1 = (wxPyApp *) 0 ;
28430 bool result;
28431 void *argp1 = 0 ;
28432 int res1 = 0 ;
28433 PyObject *swig_obj[1] ;
28434
28435 if (!args) SWIG_fail;
28436 swig_obj[0] = args;
28437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28438 if (!SWIG_IsOK(res1)) {
28439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28440 }
28441 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28442 {
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = (bool)((wxPyApp const *)arg1)->IsActive();
28445 wxPyEndAllowThreads(__tstate);
28446 if (PyErr_Occurred()) SWIG_fail;
28447 }
28448 {
28449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28450 }
28451 return resultobj;
28452 fail:
28453 return NULL;
28454 }
28455
28456
28457 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28458 PyObject *resultobj = 0;
28459 wxPyApp *arg1 = (wxPyApp *) 0 ;
28460 wxWindow *arg2 = (wxWindow *) 0 ;
28461 void *argp1 = 0 ;
28462 int res1 = 0 ;
28463 void *argp2 = 0 ;
28464 int res2 = 0 ;
28465 PyObject * obj0 = 0 ;
28466 PyObject * obj1 = 0 ;
28467 char * kwnames[] = {
28468 (char *) "self",(char *) "win", NULL
28469 };
28470
28471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28473 if (!SWIG_IsOK(res1)) {
28474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28475 }
28476 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28477 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28478 if (!SWIG_IsOK(res2)) {
28479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28480 }
28481 arg2 = reinterpret_cast< wxWindow * >(argp2);
28482 {
28483 PyThreadState* __tstate = wxPyBeginAllowThreads();
28484 (arg1)->SetTopWindow(arg2);
28485 wxPyEndAllowThreads(__tstate);
28486 if (PyErr_Occurred()) SWIG_fail;
28487 }
28488 resultobj = SWIG_Py_Void();
28489 return resultobj;
28490 fail:
28491 return NULL;
28492 }
28493
28494
28495 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28496 PyObject *resultobj = 0;
28497 wxPyApp *arg1 = (wxPyApp *) 0 ;
28498 wxWindow *result = 0 ;
28499 void *argp1 = 0 ;
28500 int res1 = 0 ;
28501 PyObject *swig_obj[1] ;
28502
28503 if (!args) SWIG_fail;
28504 swig_obj[0] = args;
28505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28506 if (!SWIG_IsOK(res1)) {
28507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28508 }
28509 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28510 {
28511 PyThreadState* __tstate = wxPyBeginAllowThreads();
28512 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28513 wxPyEndAllowThreads(__tstate);
28514 if (PyErr_Occurred()) SWIG_fail;
28515 }
28516 {
28517 resultobj = wxPyMake_wxObject(result, (bool)0);
28518 }
28519 return resultobj;
28520 fail:
28521 return NULL;
28522 }
28523
28524
28525 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28526 PyObject *resultobj = 0;
28527 wxPyApp *arg1 = (wxPyApp *) 0 ;
28528 bool arg2 ;
28529 void *argp1 = 0 ;
28530 int res1 = 0 ;
28531 bool val2 ;
28532 int ecode2 = 0 ;
28533 PyObject * obj0 = 0 ;
28534 PyObject * obj1 = 0 ;
28535 char * kwnames[] = {
28536 (char *) "self",(char *) "flag", NULL
28537 };
28538
28539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28541 if (!SWIG_IsOK(res1)) {
28542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28543 }
28544 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28545 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28546 if (!SWIG_IsOK(ecode2)) {
28547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28548 }
28549 arg2 = static_cast< bool >(val2);
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 (arg1)->SetExitOnFrameDelete(arg2);
28553 wxPyEndAllowThreads(__tstate);
28554 if (PyErr_Occurred()) SWIG_fail;
28555 }
28556 resultobj = SWIG_Py_Void();
28557 return resultobj;
28558 fail:
28559 return NULL;
28560 }
28561
28562
28563 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28564 PyObject *resultobj = 0;
28565 wxPyApp *arg1 = (wxPyApp *) 0 ;
28566 bool result;
28567 void *argp1 = 0 ;
28568 int res1 = 0 ;
28569 PyObject *swig_obj[1] ;
28570
28571 if (!args) SWIG_fail;
28572 swig_obj[0] = args;
28573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28574 if (!SWIG_IsOK(res1)) {
28575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28576 }
28577 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28581 wxPyEndAllowThreads(__tstate);
28582 if (PyErr_Occurred()) SWIG_fail;
28583 }
28584 {
28585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28586 }
28587 return resultobj;
28588 fail:
28589 return NULL;
28590 }
28591
28592
28593 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28594 PyObject *resultobj = 0;
28595 wxPyApp *arg1 = (wxPyApp *) 0 ;
28596 bool arg2 ;
28597 void *argp1 = 0 ;
28598 int res1 = 0 ;
28599 bool val2 ;
28600 int ecode2 = 0 ;
28601 PyObject * obj0 = 0 ;
28602 PyObject * obj1 = 0 ;
28603 char * kwnames[] = {
28604 (char *) "self",(char *) "flag", NULL
28605 };
28606
28607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28609 if (!SWIG_IsOK(res1)) {
28610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28611 }
28612 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28613 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28614 if (!SWIG_IsOK(ecode2)) {
28615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28616 }
28617 arg2 = static_cast< bool >(val2);
28618 {
28619 PyThreadState* __tstate = wxPyBeginAllowThreads();
28620 (arg1)->SetUseBestVisual(arg2);
28621 wxPyEndAllowThreads(__tstate);
28622 if (PyErr_Occurred()) SWIG_fail;
28623 }
28624 resultobj = SWIG_Py_Void();
28625 return resultobj;
28626 fail:
28627 return NULL;
28628 }
28629
28630
28631 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28632 PyObject *resultobj = 0;
28633 wxPyApp *arg1 = (wxPyApp *) 0 ;
28634 bool result;
28635 void *argp1 = 0 ;
28636 int res1 = 0 ;
28637 PyObject *swig_obj[1] ;
28638
28639 if (!args) SWIG_fail;
28640 swig_obj[0] = args;
28641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28642 if (!SWIG_IsOK(res1)) {
28643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28644 }
28645 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28646 {
28647 PyThreadState* __tstate = wxPyBeginAllowThreads();
28648 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28649 wxPyEndAllowThreads(__tstate);
28650 if (PyErr_Occurred()) SWIG_fail;
28651 }
28652 {
28653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28654 }
28655 return resultobj;
28656 fail:
28657 return NULL;
28658 }
28659
28660
28661 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28662 PyObject *resultobj = 0;
28663 wxPyApp *arg1 = (wxPyApp *) 0 ;
28664 int arg2 ;
28665 void *argp1 = 0 ;
28666 int res1 = 0 ;
28667 int val2 ;
28668 int ecode2 = 0 ;
28669 PyObject * obj0 = 0 ;
28670 PyObject * obj1 = 0 ;
28671 char * kwnames[] = {
28672 (char *) "self",(char *) "mode", NULL
28673 };
28674
28675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28677 if (!SWIG_IsOK(res1)) {
28678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28679 }
28680 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28681 ecode2 = SWIG_AsVal_int(obj1, &val2);
28682 if (!SWIG_IsOK(ecode2)) {
28683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28684 }
28685 arg2 = static_cast< int >(val2);
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 (arg1)->SetPrintMode(arg2);
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 resultobj = SWIG_Py_Void();
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28700 PyObject *resultobj = 0;
28701 wxPyApp *arg1 = (wxPyApp *) 0 ;
28702 int result;
28703 void *argp1 = 0 ;
28704 int res1 = 0 ;
28705 PyObject *swig_obj[1] ;
28706
28707 if (!args) SWIG_fail;
28708 swig_obj[0] = args;
28709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28710 if (!SWIG_IsOK(res1)) {
28711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28712 }
28713 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28714 {
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 resultobj = SWIG_From_int(static_cast< int >(result));
28721 return resultobj;
28722 fail:
28723 return NULL;
28724 }
28725
28726
28727 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28728 PyObject *resultobj = 0;
28729 wxPyApp *arg1 = (wxPyApp *) 0 ;
28730 int arg2 ;
28731 void *argp1 = 0 ;
28732 int res1 = 0 ;
28733 int val2 ;
28734 int ecode2 = 0 ;
28735 PyObject * obj0 = 0 ;
28736 PyObject * obj1 = 0 ;
28737 char * kwnames[] = {
28738 (char *) "self",(char *) "mode", NULL
28739 };
28740
28741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28743 if (!SWIG_IsOK(res1)) {
28744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28745 }
28746 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28747 ecode2 = SWIG_AsVal_int(obj1, &val2);
28748 if (!SWIG_IsOK(ecode2)) {
28749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28750 }
28751 arg2 = static_cast< int >(val2);
28752 {
28753 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 (arg1)->SetAssertMode(arg2);
28755 wxPyEndAllowThreads(__tstate);
28756 if (PyErr_Occurred()) SWIG_fail;
28757 }
28758 resultobj = SWIG_Py_Void();
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28766 PyObject *resultobj = 0;
28767 wxPyApp *arg1 = (wxPyApp *) 0 ;
28768 int result;
28769 void *argp1 = 0 ;
28770 int res1 = 0 ;
28771 PyObject *swig_obj[1] ;
28772
28773 if (!args) SWIG_fail;
28774 swig_obj[0] = args;
28775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28776 if (!SWIG_IsOK(res1)) {
28777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28778 }
28779 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 result = (int)(arg1)->GetAssertMode();
28783 wxPyEndAllowThreads(__tstate);
28784 if (PyErr_Occurred()) SWIG_fail;
28785 }
28786 resultobj = SWIG_From_int(static_cast< int >(result));
28787 return resultobj;
28788 fail:
28789 return NULL;
28790 }
28791
28792
28793 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28794 PyObject *resultobj = 0;
28795 bool result;
28796
28797 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28801 wxPyEndAllowThreads(__tstate);
28802 if (PyErr_Occurred()) SWIG_fail;
28803 }
28804 {
28805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28806 }
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28814 PyObject *resultobj = 0;
28815 long result;
28816
28817 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28818 {
28819 PyThreadState* __tstate = wxPyBeginAllowThreads();
28820 result = (long)wxPyApp::GetMacAboutMenuItemId();
28821 wxPyEndAllowThreads(__tstate);
28822 if (PyErr_Occurred()) SWIG_fail;
28823 }
28824 resultobj = SWIG_From_long(static_cast< long >(result));
28825 return resultobj;
28826 fail:
28827 return NULL;
28828 }
28829
28830
28831 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28832 PyObject *resultobj = 0;
28833 long result;
28834
28835 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28836 {
28837 PyThreadState* __tstate = wxPyBeginAllowThreads();
28838 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28839 wxPyEndAllowThreads(__tstate);
28840 if (PyErr_Occurred()) SWIG_fail;
28841 }
28842 resultobj = SWIG_From_long(static_cast< long >(result));
28843 return resultobj;
28844 fail:
28845 return NULL;
28846 }
28847
28848
28849 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28850 PyObject *resultobj = 0;
28851 long result;
28852
28853 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 result = (long)wxPyApp::GetMacExitMenuItemId();
28857 wxPyEndAllowThreads(__tstate);
28858 if (PyErr_Occurred()) SWIG_fail;
28859 }
28860 resultobj = SWIG_From_long(static_cast< long >(result));
28861 return resultobj;
28862 fail:
28863 return NULL;
28864 }
28865
28866
28867 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28868 PyObject *resultobj = 0;
28869 wxString result;
28870
28871 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28872 {
28873 PyThreadState* __tstate = wxPyBeginAllowThreads();
28874 result = wxPyApp::GetMacHelpMenuTitleName();
28875 wxPyEndAllowThreads(__tstate);
28876 if (PyErr_Occurred()) SWIG_fail;
28877 }
28878 {
28879 #if wxUSE_UNICODE
28880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28881 #else
28882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28883 #endif
28884 }
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28892 PyObject *resultobj = 0;
28893 bool arg1 ;
28894 bool val1 ;
28895 int ecode1 = 0 ;
28896 PyObject * obj0 = 0 ;
28897 char * kwnames[] = {
28898 (char *) "val", NULL
28899 };
28900
28901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28902 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28903 if (!SWIG_IsOK(ecode1)) {
28904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28905 }
28906 arg1 = static_cast< bool >(val1);
28907 {
28908 PyThreadState* __tstate = wxPyBeginAllowThreads();
28909 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 resultobj = SWIG_Py_Void();
28914 return resultobj;
28915 fail:
28916 return NULL;
28917 }
28918
28919
28920 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28921 PyObject *resultobj = 0;
28922 long arg1 ;
28923 long val1 ;
28924 int ecode1 = 0 ;
28925 PyObject * obj0 = 0 ;
28926 char * kwnames[] = {
28927 (char *) "val", NULL
28928 };
28929
28930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28931 ecode1 = SWIG_AsVal_long(obj0, &val1);
28932 if (!SWIG_IsOK(ecode1)) {
28933 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28934 }
28935 arg1 = static_cast< long >(val1);
28936 {
28937 PyThreadState* __tstate = wxPyBeginAllowThreads();
28938 wxPyApp::SetMacAboutMenuItemId(arg1);
28939 wxPyEndAllowThreads(__tstate);
28940 if (PyErr_Occurred()) SWIG_fail;
28941 }
28942 resultobj = SWIG_Py_Void();
28943 return resultobj;
28944 fail:
28945 return NULL;
28946 }
28947
28948
28949 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28950 PyObject *resultobj = 0;
28951 long arg1 ;
28952 long val1 ;
28953 int ecode1 = 0 ;
28954 PyObject * obj0 = 0 ;
28955 char * kwnames[] = {
28956 (char *) "val", NULL
28957 };
28958
28959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28960 ecode1 = SWIG_AsVal_long(obj0, &val1);
28961 if (!SWIG_IsOK(ecode1)) {
28962 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28963 }
28964 arg1 = static_cast< long >(val1);
28965 {
28966 PyThreadState* __tstate = wxPyBeginAllowThreads();
28967 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28968 wxPyEndAllowThreads(__tstate);
28969 if (PyErr_Occurred()) SWIG_fail;
28970 }
28971 resultobj = SWIG_Py_Void();
28972 return resultobj;
28973 fail:
28974 return NULL;
28975 }
28976
28977
28978 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28979 PyObject *resultobj = 0;
28980 long arg1 ;
28981 long val1 ;
28982 int ecode1 = 0 ;
28983 PyObject * obj0 = 0 ;
28984 char * kwnames[] = {
28985 (char *) "val", NULL
28986 };
28987
28988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28989 ecode1 = SWIG_AsVal_long(obj0, &val1);
28990 if (!SWIG_IsOK(ecode1)) {
28991 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28992 }
28993 arg1 = static_cast< long >(val1);
28994 {
28995 PyThreadState* __tstate = wxPyBeginAllowThreads();
28996 wxPyApp::SetMacExitMenuItemId(arg1);
28997 wxPyEndAllowThreads(__tstate);
28998 if (PyErr_Occurred()) SWIG_fail;
28999 }
29000 resultobj = SWIG_Py_Void();
29001 return resultobj;
29002 fail:
29003 return NULL;
29004 }
29005
29006
29007 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29008 PyObject *resultobj = 0;
29009 wxString *arg1 = 0 ;
29010 bool temp1 = false ;
29011 PyObject * obj0 = 0 ;
29012 char * kwnames[] = {
29013 (char *) "val", NULL
29014 };
29015
29016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29017 {
29018 arg1 = wxString_in_helper(obj0);
29019 if (arg1 == NULL) SWIG_fail;
29020 temp1 = true;
29021 }
29022 {
29023 PyThreadState* __tstate = wxPyBeginAllowThreads();
29024 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29025 wxPyEndAllowThreads(__tstate);
29026 if (PyErr_Occurred()) SWIG_fail;
29027 }
29028 resultobj = SWIG_Py_Void();
29029 {
29030 if (temp1)
29031 delete arg1;
29032 }
29033 return resultobj;
29034 fail:
29035 {
29036 if (temp1)
29037 delete arg1;
29038 }
29039 return NULL;
29040 }
29041
29042
29043 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29044 PyObject *resultobj = 0;
29045 wxPyApp *arg1 = (wxPyApp *) 0 ;
29046 void *argp1 = 0 ;
29047 int res1 = 0 ;
29048 PyObject *swig_obj[1] ;
29049
29050 if (!args) SWIG_fail;
29051 swig_obj[0] = args;
29052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29053 if (!SWIG_IsOK(res1)) {
29054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29055 }
29056 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 (arg1)->_BootstrapApp();
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_Py_Void();
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29071 PyObject *resultobj = 0;
29072 int result;
29073
29074 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29075 {
29076 PyThreadState* __tstate = wxPyBeginAllowThreads();
29077 result = (int)wxPyApp_GetComCtl32Version();
29078 wxPyEndAllowThreads(__tstate);
29079 if (PyErr_Occurred()) SWIG_fail;
29080 }
29081 resultobj = SWIG_From_int(static_cast< int >(result));
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29089 PyObject *resultobj = 0;
29090 bool result;
29091
29092 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29093 {
29094 PyThreadState* __tstate = wxPyBeginAllowThreads();
29095 result = (bool)wxPyApp_IsDisplayAvailable();
29096 wxPyEndAllowThreads(__tstate);
29097 if (PyErr_Occurred()) SWIG_fail;
29098 }
29099 {
29100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29101 }
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29109 PyObject *obj;
29110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29111 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29112 return SWIG_Py_Void();
29113 }
29114
29115 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29116 return SWIG_Python_InitShadowInstance(args);
29117 }
29118
29119 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29120 PyObject *resultobj = 0;
29121
29122 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29123 {
29124 PyThreadState* __tstate = wxPyBeginAllowThreads();
29125 wxExit();
29126 wxPyEndAllowThreads(__tstate);
29127 if (PyErr_Occurred()) SWIG_fail;
29128 }
29129 resultobj = SWIG_Py_Void();
29130 return resultobj;
29131 fail:
29132 return NULL;
29133 }
29134
29135
29136 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29137 PyObject *resultobj = 0;
29138 bool result;
29139
29140 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 result = (bool)wxYield();
29144 wxPyEndAllowThreads(__tstate);
29145 if (PyErr_Occurred()) SWIG_fail;
29146 }
29147 {
29148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29149 }
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29157 PyObject *resultobj = 0;
29158 bool result;
29159
29160 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29161 {
29162 PyThreadState* __tstate = wxPyBeginAllowThreads();
29163 result = (bool)wxYieldIfNeeded();
29164 wxPyEndAllowThreads(__tstate);
29165 if (PyErr_Occurred()) SWIG_fail;
29166 }
29167 {
29168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29169 }
29170 return resultobj;
29171 fail:
29172 return NULL;
29173 }
29174
29175
29176 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29177 PyObject *resultobj = 0;
29178 wxWindow *arg1 = (wxWindow *) NULL ;
29179 bool arg2 = (bool) false ;
29180 bool result;
29181 void *argp1 = 0 ;
29182 int res1 = 0 ;
29183 bool val2 ;
29184 int ecode2 = 0 ;
29185 PyObject * obj0 = 0 ;
29186 PyObject * obj1 = 0 ;
29187 char * kwnames[] = {
29188 (char *) "win",(char *) "onlyIfNeeded", NULL
29189 };
29190
29191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29192 if (obj0) {
29193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29194 if (!SWIG_IsOK(res1)) {
29195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29196 }
29197 arg1 = reinterpret_cast< wxWindow * >(argp1);
29198 }
29199 if (obj1) {
29200 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29201 if (!SWIG_IsOK(ecode2)) {
29202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29203 }
29204 arg2 = static_cast< bool >(val2);
29205 }
29206 {
29207 PyThreadState* __tstate = wxPyBeginAllowThreads();
29208 result = (bool)wxSafeYield(arg1,arg2);
29209 wxPyEndAllowThreads(__tstate);
29210 if (PyErr_Occurred()) SWIG_fail;
29211 }
29212 {
29213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29214 }
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29222 PyObject *resultobj = 0;
29223
29224 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29225 {
29226 PyThreadState* __tstate = wxPyBeginAllowThreads();
29227 wxWakeUpIdle();
29228 wxPyEndAllowThreads(__tstate);
29229 if (PyErr_Occurred()) SWIG_fail;
29230 }
29231 resultobj = SWIG_Py_Void();
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29239 PyObject *resultobj = 0;
29240 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29241 wxEvent *arg2 = 0 ;
29242 void *argp1 = 0 ;
29243 int res1 = 0 ;
29244 void *argp2 = 0 ;
29245 int res2 = 0 ;
29246 PyObject * obj0 = 0 ;
29247 PyObject * obj1 = 0 ;
29248 char * kwnames[] = {
29249 (char *) "dest",(char *) "event", NULL
29250 };
29251
29252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29254 if (!SWIG_IsOK(res1)) {
29255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29256 }
29257 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29258 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29259 if (!SWIG_IsOK(res2)) {
29260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29261 }
29262 if (!argp2) {
29263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29264 }
29265 arg2 = reinterpret_cast< wxEvent * >(argp2);
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 wxPostEvent(arg1,*arg2);
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 resultobj = SWIG_Py_Void();
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 PyObject *resultobj = 0;
29281
29282 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29283 {
29284 PyThreadState* __tstate = wxPyBeginAllowThreads();
29285 wxApp_CleanUp();
29286 wxPyEndAllowThreads(__tstate);
29287 if (PyErr_Occurred()) SWIG_fail;
29288 }
29289 resultobj = SWIG_Py_Void();
29290 return resultobj;
29291 fail:
29292 return NULL;
29293 }
29294
29295
29296 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29297 PyObject *resultobj = 0;
29298 wxPyApp *result = 0 ;
29299
29300 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 result = (wxPyApp *)wxPyGetApp();
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 {
29308 resultobj = wxPyMake_wxObject(result, 0);
29309 }
29310 return resultobj;
29311 fail:
29312 return NULL;
29313 }
29314
29315
29316 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29317 PyObject *resultobj = 0;
29318 char *arg1 = (char *) 0 ;
29319 int res1 ;
29320 char *buf1 = 0 ;
29321 int alloc1 = 0 ;
29322 PyObject * obj0 = 0 ;
29323 char * kwnames[] = {
29324 (char *) "encoding", NULL
29325 };
29326
29327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29328 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29329 if (!SWIG_IsOK(res1)) {
29330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29331 }
29332 arg1 = buf1;
29333 {
29334 PyThreadState* __tstate = wxPyBeginAllowThreads();
29335 wxSetDefaultPyEncoding((char const *)arg1);
29336 wxPyEndAllowThreads(__tstate);
29337 if (PyErr_Occurred()) SWIG_fail;
29338 }
29339 resultobj = SWIG_Py_Void();
29340 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29341 return resultobj;
29342 fail:
29343 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29344 return NULL;
29345 }
29346
29347
29348 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29349 PyObject *resultobj = 0;
29350 char *result = 0 ;
29351
29352 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29353 {
29354 PyThreadState* __tstate = wxPyBeginAllowThreads();
29355 result = (char *)wxGetDefaultPyEncoding();
29356 wxPyEndAllowThreads(__tstate);
29357 if (PyErr_Occurred()) SWIG_fail;
29358 }
29359 resultobj = SWIG_FromCharPtr(result);
29360 return resultobj;
29361 fail:
29362 return NULL;
29363 }
29364
29365
29366 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29367 PyObject *resultobj = 0;
29368 wxEventLoop *result = 0 ;
29369
29370 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29371 {
29372 PyThreadState* __tstate = wxPyBeginAllowThreads();
29373 result = (wxEventLoop *)new wxEventLoop();
29374 wxPyEndAllowThreads(__tstate);
29375 if (PyErr_Occurred()) SWIG_fail;
29376 }
29377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29378 return resultobj;
29379 fail:
29380 return NULL;
29381 }
29382
29383
29384 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29385 PyObject *resultobj = 0;
29386 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29387 void *argp1 = 0 ;
29388 int res1 = 0 ;
29389 PyObject *swig_obj[1] ;
29390
29391 if (!args) SWIG_fail;
29392 swig_obj[0] = args;
29393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29396 }
29397 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29398 {
29399 PyThreadState* __tstate = wxPyBeginAllowThreads();
29400 delete arg1;
29401
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 resultobj = SWIG_Py_Void();
29406 return resultobj;
29407 fail:
29408 return NULL;
29409 }
29410
29411
29412 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29413 PyObject *resultobj = 0;
29414 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29415 int result;
29416 void *argp1 = 0 ;
29417 int res1 = 0 ;
29418 PyObject *swig_obj[1] ;
29419
29420 if (!args) SWIG_fail;
29421 swig_obj[0] = args;
29422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29423 if (!SWIG_IsOK(res1)) {
29424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29425 }
29426 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29427 {
29428 PyThreadState* __tstate = wxPyBeginAllowThreads();
29429 result = (int)(arg1)->Run();
29430 wxPyEndAllowThreads(__tstate);
29431 if (PyErr_Occurred()) SWIG_fail;
29432 }
29433 resultobj = SWIG_From_int(static_cast< int >(result));
29434 return resultobj;
29435 fail:
29436 return NULL;
29437 }
29438
29439
29440 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29441 PyObject *resultobj = 0;
29442 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29443 int arg2 = (int) 0 ;
29444 void *argp1 = 0 ;
29445 int res1 = 0 ;
29446 int val2 ;
29447 int ecode2 = 0 ;
29448 PyObject * obj0 = 0 ;
29449 PyObject * obj1 = 0 ;
29450 char * kwnames[] = {
29451 (char *) "self",(char *) "rc", NULL
29452 };
29453
29454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29456 if (!SWIG_IsOK(res1)) {
29457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29458 }
29459 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29460 if (obj1) {
29461 ecode2 = SWIG_AsVal_int(obj1, &val2);
29462 if (!SWIG_IsOK(ecode2)) {
29463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29464 }
29465 arg2 = static_cast< int >(val2);
29466 }
29467 {
29468 PyThreadState* __tstate = wxPyBeginAllowThreads();
29469 (arg1)->Exit(arg2);
29470 wxPyEndAllowThreads(__tstate);
29471 if (PyErr_Occurred()) SWIG_fail;
29472 }
29473 resultobj = SWIG_Py_Void();
29474 return resultobj;
29475 fail:
29476 return NULL;
29477 }
29478
29479
29480 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29481 PyObject *resultobj = 0;
29482 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29483 bool result;
29484 void *argp1 = 0 ;
29485 int res1 = 0 ;
29486 PyObject *swig_obj[1] ;
29487
29488 if (!args) SWIG_fail;
29489 swig_obj[0] = args;
29490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29491 if (!SWIG_IsOK(res1)) {
29492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29493 }
29494 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29495 {
29496 PyThreadState* __tstate = wxPyBeginAllowThreads();
29497 result = (bool)((wxEventLoop const *)arg1)->Pending();
29498 wxPyEndAllowThreads(__tstate);
29499 if (PyErr_Occurred()) SWIG_fail;
29500 }
29501 {
29502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29503 }
29504 return resultobj;
29505 fail:
29506 return NULL;
29507 }
29508
29509
29510 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29511 PyObject *resultobj = 0;
29512 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29513 bool result;
29514 void *argp1 = 0 ;
29515 int res1 = 0 ;
29516 PyObject *swig_obj[1] ;
29517
29518 if (!args) SWIG_fail;
29519 swig_obj[0] = args;
29520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29521 if (!SWIG_IsOK(res1)) {
29522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29523 }
29524 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29525 {
29526 PyThreadState* __tstate = wxPyBeginAllowThreads();
29527 result = (bool)(arg1)->Dispatch();
29528 wxPyEndAllowThreads(__tstate);
29529 if (PyErr_Occurred()) SWIG_fail;
29530 }
29531 {
29532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29533 }
29534 return resultobj;
29535 fail:
29536 return NULL;
29537 }
29538
29539
29540 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29541 PyObject *resultobj = 0;
29542 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29543 bool result;
29544 void *argp1 = 0 ;
29545 int res1 = 0 ;
29546 PyObject *swig_obj[1] ;
29547
29548 if (!args) SWIG_fail;
29549 swig_obj[0] = args;
29550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29551 if (!SWIG_IsOK(res1)) {
29552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29553 }
29554 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29555 {
29556 PyThreadState* __tstate = wxPyBeginAllowThreads();
29557 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29558 wxPyEndAllowThreads(__tstate);
29559 if (PyErr_Occurred()) SWIG_fail;
29560 }
29561 {
29562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29563 }
29564 return resultobj;
29565 fail:
29566 return NULL;
29567 }
29568
29569
29570 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29571 PyObject *resultobj = 0;
29572 wxEventLoop *result = 0 ;
29573
29574 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29575 {
29576 PyThreadState* __tstate = wxPyBeginAllowThreads();
29577 result = (wxEventLoop *)wxEventLoop::GetActive();
29578 wxPyEndAllowThreads(__tstate);
29579 if (PyErr_Occurred()) SWIG_fail;
29580 }
29581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29582 return resultobj;
29583 fail:
29584 return NULL;
29585 }
29586
29587
29588 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj = 0;
29590 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29591 void *argp1 = 0 ;
29592 int res1 = 0 ;
29593 PyObject * obj0 = 0 ;
29594 char * kwnames[] = {
29595 (char *) "loop", NULL
29596 };
29597
29598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29600 if (!SWIG_IsOK(res1)) {
29601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29602 }
29603 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 wxEventLoop::SetActive(arg1);
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 resultobj = SWIG_Py_Void();
29611 return resultobj;
29612 fail:
29613 return NULL;
29614 }
29615
29616
29617 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29618 PyObject *obj;
29619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29620 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29621 return SWIG_Py_Void();
29622 }
29623
29624 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29625 return SWIG_Python_InitShadowInstance(args);
29626 }
29627
29628 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29629 PyObject *resultobj = 0;
29630 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29631 wxEventLoopActivator *result = 0 ;
29632 void *argp1 = 0 ;
29633 int res1 = 0 ;
29634 PyObject * obj0 = 0 ;
29635 char * kwnames[] = {
29636 (char *) "evtLoop", NULL
29637 };
29638
29639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29641 if (!SWIG_IsOK(res1)) {
29642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29643 }
29644 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29645 {
29646 PyThreadState* __tstate = wxPyBeginAllowThreads();
29647 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29648 wxPyEndAllowThreads(__tstate);
29649 if (PyErr_Occurred()) SWIG_fail;
29650 }
29651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29652 return resultobj;
29653 fail:
29654 return NULL;
29655 }
29656
29657
29658 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29659 PyObject *resultobj = 0;
29660 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29661 void *argp1 = 0 ;
29662 int res1 = 0 ;
29663 PyObject *swig_obj[1] ;
29664
29665 if (!args) SWIG_fail;
29666 swig_obj[0] = args;
29667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29668 if (!SWIG_IsOK(res1)) {
29669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29670 }
29671 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 delete arg1;
29675
29676 wxPyEndAllowThreads(__tstate);
29677 if (PyErr_Occurred()) SWIG_fail;
29678 }
29679 resultobj = SWIG_Py_Void();
29680 return resultobj;
29681 fail:
29682 return NULL;
29683 }
29684
29685
29686 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29687 PyObject *obj;
29688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29689 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29690 return SWIG_Py_Void();
29691 }
29692
29693 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29694 return SWIG_Python_InitShadowInstance(args);
29695 }
29696
29697 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29698 PyObject *resultobj = 0;
29699 int arg1 = (int) 0 ;
29700 int arg2 = (int) 0 ;
29701 int arg3 = (int) 0 ;
29702 wxAcceleratorEntry *result = 0 ;
29703 int val1 ;
29704 int ecode1 = 0 ;
29705 int val2 ;
29706 int ecode2 = 0 ;
29707 int val3 ;
29708 int ecode3 = 0 ;
29709 PyObject * obj0 = 0 ;
29710 PyObject * obj1 = 0 ;
29711 PyObject * obj2 = 0 ;
29712 char * kwnames[] = {
29713 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29714 };
29715
29716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29717 if (obj0) {
29718 ecode1 = SWIG_AsVal_int(obj0, &val1);
29719 if (!SWIG_IsOK(ecode1)) {
29720 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29721 }
29722 arg1 = static_cast< int >(val1);
29723 }
29724 if (obj1) {
29725 ecode2 = SWIG_AsVal_int(obj1, &val2);
29726 if (!SWIG_IsOK(ecode2)) {
29727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29728 }
29729 arg2 = static_cast< int >(val2);
29730 }
29731 if (obj2) {
29732 ecode3 = SWIG_AsVal_int(obj2, &val3);
29733 if (!SWIG_IsOK(ecode3)) {
29734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29735 }
29736 arg3 = static_cast< int >(val3);
29737 }
29738 {
29739 PyThreadState* __tstate = wxPyBeginAllowThreads();
29740 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29741 wxPyEndAllowThreads(__tstate);
29742 if (PyErr_Occurred()) SWIG_fail;
29743 }
29744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29745 return resultobj;
29746 fail:
29747 return NULL;
29748 }
29749
29750
29751 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29752 PyObject *resultobj = 0;
29753 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29754 void *argp1 = 0 ;
29755 int res1 = 0 ;
29756 PyObject *swig_obj[1] ;
29757
29758 if (!args) SWIG_fail;
29759 swig_obj[0] = args;
29760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29761 if (!SWIG_IsOK(res1)) {
29762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29763 }
29764 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29765 {
29766 PyThreadState* __tstate = wxPyBeginAllowThreads();
29767 delete arg1;
29768
29769 wxPyEndAllowThreads(__tstate);
29770 if (PyErr_Occurred()) SWIG_fail;
29771 }
29772 resultobj = SWIG_Py_Void();
29773 return resultobj;
29774 fail:
29775 return NULL;
29776 }
29777
29778
29779 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29780 PyObject *resultobj = 0;
29781 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29782 int arg2 ;
29783 int arg3 ;
29784 int arg4 ;
29785 void *argp1 = 0 ;
29786 int res1 = 0 ;
29787 int val2 ;
29788 int ecode2 = 0 ;
29789 int val3 ;
29790 int ecode3 = 0 ;
29791 int val4 ;
29792 int ecode4 = 0 ;
29793 PyObject * obj0 = 0 ;
29794 PyObject * obj1 = 0 ;
29795 PyObject * obj2 = 0 ;
29796 PyObject * obj3 = 0 ;
29797 char * kwnames[] = {
29798 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29799 };
29800
29801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29803 if (!SWIG_IsOK(res1)) {
29804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29805 }
29806 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29807 ecode2 = SWIG_AsVal_int(obj1, &val2);
29808 if (!SWIG_IsOK(ecode2)) {
29809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29810 }
29811 arg2 = static_cast< int >(val2);
29812 ecode3 = SWIG_AsVal_int(obj2, &val3);
29813 if (!SWIG_IsOK(ecode3)) {
29814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29815 }
29816 arg3 = static_cast< int >(val3);
29817 ecode4 = SWIG_AsVal_int(obj3, &val4);
29818 if (!SWIG_IsOK(ecode4)) {
29819 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29820 }
29821 arg4 = static_cast< int >(val4);
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 (arg1)->Set(arg2,arg3,arg4);
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 resultobj = SWIG_Py_Void();
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29836 PyObject *resultobj = 0;
29837 wxString *arg1 = 0 ;
29838 wxAcceleratorEntry *result = 0 ;
29839 bool temp1 = false ;
29840 PyObject * obj0 = 0 ;
29841 char * kwnames[] = {
29842 (char *) "str", NULL
29843 };
29844
29845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29846 {
29847 arg1 = wxString_in_helper(obj0);
29848 if (arg1 == NULL) SWIG_fail;
29849 temp1 = true;
29850 }
29851 {
29852 PyThreadState* __tstate = wxPyBeginAllowThreads();
29853 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29854 wxPyEndAllowThreads(__tstate);
29855 if (PyErr_Occurred()) SWIG_fail;
29856 }
29857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29858 {
29859 if (temp1)
29860 delete arg1;
29861 }
29862 return resultobj;
29863 fail:
29864 {
29865 if (temp1)
29866 delete arg1;
29867 }
29868 return NULL;
29869 }
29870
29871
29872 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29873 PyObject *resultobj = 0;
29874 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29875 int result;
29876 void *argp1 = 0 ;
29877 int res1 = 0 ;
29878 PyObject *swig_obj[1] ;
29879
29880 if (!args) SWIG_fail;
29881 swig_obj[0] = args;
29882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29883 if (!SWIG_IsOK(res1)) {
29884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29885 }
29886 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29887 {
29888 PyThreadState* __tstate = wxPyBeginAllowThreads();
29889 result = (int)(arg1)->GetFlags();
29890 wxPyEndAllowThreads(__tstate);
29891 if (PyErr_Occurred()) SWIG_fail;
29892 }
29893 resultobj = SWIG_From_int(static_cast< int >(result));
29894 return resultobj;
29895 fail:
29896 return NULL;
29897 }
29898
29899
29900 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29901 PyObject *resultobj = 0;
29902 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29903 int 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_wxAcceleratorEntry, 0 | 0 );
29911 if (!SWIG_IsOK(res1)) {
29912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29913 }
29914 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 result = (int)(arg1)->GetKeyCode();
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 resultobj = SWIG_From_int(static_cast< int >(result));
29922 return resultobj;
29923 fail:
29924 return NULL;
29925 }
29926
29927
29928 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29929 PyObject *resultobj = 0;
29930 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29931 int result;
29932 void *argp1 = 0 ;
29933 int res1 = 0 ;
29934 PyObject *swig_obj[1] ;
29935
29936 if (!args) SWIG_fail;
29937 swig_obj[0] = args;
29938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29939 if (!SWIG_IsOK(res1)) {
29940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29941 }
29942 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29943 {
29944 PyThreadState* __tstate = wxPyBeginAllowThreads();
29945 result = (int)(arg1)->GetCommand();
29946 wxPyEndAllowThreads(__tstate);
29947 if (PyErr_Occurred()) SWIG_fail;
29948 }
29949 resultobj = SWIG_From_int(static_cast< int >(result));
29950 return resultobj;
29951 fail:
29952 return NULL;
29953 }
29954
29955
29956 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29957 PyObject *resultobj = 0;
29958 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29959 bool result;
29960 void *argp1 = 0 ;
29961 int res1 = 0 ;
29962 PyObject *swig_obj[1] ;
29963
29964 if (!args) SWIG_fail;
29965 swig_obj[0] = args;
29966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29967 if (!SWIG_IsOK(res1)) {
29968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29969 }
29970 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29974 wxPyEndAllowThreads(__tstate);
29975 if (PyErr_Occurred()) SWIG_fail;
29976 }
29977 {
29978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29979 }
29980 return resultobj;
29981 fail:
29982 return NULL;
29983 }
29984
29985
29986 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29987 PyObject *resultobj = 0;
29988 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29989 wxString result;
29990 void *argp1 = 0 ;
29991 int res1 = 0 ;
29992 PyObject *swig_obj[1] ;
29993
29994 if (!args) SWIG_fail;
29995 swig_obj[0] = args;
29996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29997 if (!SWIG_IsOK(res1)) {
29998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29999 }
30000 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30001 {
30002 PyThreadState* __tstate = wxPyBeginAllowThreads();
30003 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30004 wxPyEndAllowThreads(__tstate);
30005 if (PyErr_Occurred()) SWIG_fail;
30006 }
30007 {
30008 #if wxUSE_UNICODE
30009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30010 #else
30011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30012 #endif
30013 }
30014 return resultobj;
30015 fail:
30016 return NULL;
30017 }
30018
30019
30020 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30021 PyObject *resultobj = 0;
30022 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30023 wxString *arg2 = 0 ;
30024 bool result;
30025 void *argp1 = 0 ;
30026 int res1 = 0 ;
30027 bool temp2 = false ;
30028 PyObject * obj0 = 0 ;
30029 PyObject * obj1 = 0 ;
30030 char * kwnames[] = {
30031 (char *) "self",(char *) "str", NULL
30032 };
30033
30034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30036 if (!SWIG_IsOK(res1)) {
30037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30038 }
30039 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30040 {
30041 arg2 = wxString_in_helper(obj1);
30042 if (arg2 == NULL) SWIG_fail;
30043 temp2 = true;
30044 }
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 {
30052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30053 }
30054 {
30055 if (temp2)
30056 delete arg2;
30057 }
30058 return resultobj;
30059 fail:
30060 {
30061 if (temp2)
30062 delete arg2;
30063 }
30064 return NULL;
30065 }
30066
30067
30068 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30069 PyObject *obj;
30070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30071 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30072 return SWIG_Py_Void();
30073 }
30074
30075 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30076 return SWIG_Python_InitShadowInstance(args);
30077 }
30078
30079 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30080 PyObject *resultobj = 0;
30081 int arg1 ;
30082 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30083 wxAcceleratorTable *result = 0 ;
30084 PyObject * obj0 = 0 ;
30085 char * kwnames[] = {
30086 (char *) "n", NULL
30087 };
30088
30089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30090 {
30091 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30092 if (arg2) arg1 = PyList_Size(obj0);
30093 else arg1 = 0;
30094 }
30095 {
30096 PyThreadState* __tstate = wxPyBeginAllowThreads();
30097 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30098 wxPyEndAllowThreads(__tstate);
30099 if (PyErr_Occurred()) SWIG_fail;
30100 }
30101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30109 PyObject *resultobj = 0;
30110 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30111 void *argp1 = 0 ;
30112 int res1 = 0 ;
30113 PyObject *swig_obj[1] ;
30114
30115 if (!args) SWIG_fail;
30116 swig_obj[0] = args;
30117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30118 if (!SWIG_IsOK(res1)) {
30119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30120 }
30121 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30122 {
30123 PyThreadState* __tstate = wxPyBeginAllowThreads();
30124 delete arg1;
30125
30126 wxPyEndAllowThreads(__tstate);
30127 if (PyErr_Occurred()) SWIG_fail;
30128 }
30129 resultobj = SWIG_Py_Void();
30130 return resultobj;
30131 fail:
30132 return NULL;
30133 }
30134
30135
30136 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30137 PyObject *resultobj = 0;
30138 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30139 bool result;
30140 void *argp1 = 0 ;
30141 int res1 = 0 ;
30142 PyObject *swig_obj[1] ;
30143
30144 if (!args) SWIG_fail;
30145 swig_obj[0] = args;
30146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30147 if (!SWIG_IsOK(res1)) {
30148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30149 }
30150 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30151 {
30152 PyThreadState* __tstate = wxPyBeginAllowThreads();
30153 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
30154 wxPyEndAllowThreads(__tstate);
30155 if (PyErr_Occurred()) SWIG_fail;
30156 }
30157 {
30158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30159 }
30160 return resultobj;
30161 fail:
30162 return NULL;
30163 }
30164
30165
30166 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30167 PyObject *obj;
30168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30169 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30170 return SWIG_Py_Void();
30171 }
30172
30173 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30174 return SWIG_Python_InitShadowInstance(args);
30175 }
30176
30177 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30178 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30179 return 1;
30180 }
30181
30182
30183 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30184 PyObject *pyobj = 0;
30185
30186 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30187 return pyobj;
30188 }
30189
30190
30191 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30192 PyObject *resultobj = 0;
30193 wxString *arg1 = 0 ;
30194 wxAcceleratorEntry *result = 0 ;
30195 bool temp1 = false ;
30196 PyObject * obj0 = 0 ;
30197 char * kwnames[] = {
30198 (char *) "label", NULL
30199 };
30200
30201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30202 {
30203 arg1 = wxString_in_helper(obj0);
30204 if (arg1 == NULL) SWIG_fail;
30205 temp1 = true;
30206 }
30207 {
30208 PyThreadState* __tstate = wxPyBeginAllowThreads();
30209 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30210 wxPyEndAllowThreads(__tstate);
30211 if (PyErr_Occurred()) SWIG_fail;
30212 }
30213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30214 {
30215 if (temp1)
30216 delete arg1;
30217 }
30218 return resultobj;
30219 fail:
30220 {
30221 if (temp1)
30222 delete arg1;
30223 }
30224 return NULL;
30225 }
30226
30227
30228 SWIGINTERN int PanelNameStr_set(PyObject *) {
30229 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30230 return 1;
30231 }
30232
30233
30234 SWIGINTERN PyObject *PanelNameStr_get(void) {
30235 PyObject *pyobj = 0;
30236
30237 {
30238 #if wxUSE_UNICODE
30239 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30240 #else
30241 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30242 #endif
30243 }
30244 return pyobj;
30245 }
30246
30247
30248 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30249 PyObject *resultobj = 0;
30250 wxVisualAttributes *result = 0 ;
30251
30252 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30253 {
30254 PyThreadState* __tstate = wxPyBeginAllowThreads();
30255 result = (wxVisualAttributes *)new_wxVisualAttributes();
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30267 PyObject *resultobj = 0;
30268 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30269 void *argp1 = 0 ;
30270 int res1 = 0 ;
30271 PyObject *swig_obj[1] ;
30272
30273 if (!args) SWIG_fail;
30274 swig_obj[0] = args;
30275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30276 if (!SWIG_IsOK(res1)) {
30277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30278 }
30279 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30280 {
30281 PyThreadState* __tstate = wxPyBeginAllowThreads();
30282 delete_wxVisualAttributes(arg1);
30283
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 resultobj = SWIG_Py_Void();
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30295 PyObject *resultobj = 0;
30296 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30297 wxFont *arg2 = (wxFont *) 0 ;
30298 void *argp1 = 0 ;
30299 int res1 = 0 ;
30300 void *argp2 = 0 ;
30301 int res2 = 0 ;
30302 PyObject *swig_obj[2] ;
30303
30304 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30306 if (!SWIG_IsOK(res1)) {
30307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30308 }
30309 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30310 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30311 if (!SWIG_IsOK(res2)) {
30312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30313 }
30314 arg2 = reinterpret_cast< wxFont * >(argp2);
30315 if (arg1) (arg1)->font = *arg2;
30316
30317 resultobj = SWIG_Py_Void();
30318 return resultobj;
30319 fail:
30320 return NULL;
30321 }
30322
30323
30324 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30325 PyObject *resultobj = 0;
30326 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30327 wxFont *result = 0 ;
30328 void *argp1 = 0 ;
30329 int res1 = 0 ;
30330 PyObject *swig_obj[1] ;
30331
30332 if (!args) SWIG_fail;
30333 swig_obj[0] = args;
30334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30335 if (!SWIG_IsOK(res1)) {
30336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30337 }
30338 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30339 result = (wxFont *)& ((arg1)->font);
30340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30348 PyObject *resultobj = 0;
30349 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30350 wxColour *arg2 = (wxColour *) 0 ;
30351 void *argp1 = 0 ;
30352 int res1 = 0 ;
30353 void *argp2 = 0 ;
30354 int res2 = 0 ;
30355 PyObject *swig_obj[2] ;
30356
30357 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30359 if (!SWIG_IsOK(res1)) {
30360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30361 }
30362 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30363 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30364 if (!SWIG_IsOK(res2)) {
30365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30366 }
30367 arg2 = reinterpret_cast< wxColour * >(argp2);
30368 if (arg1) (arg1)->colFg = *arg2;
30369
30370 resultobj = SWIG_Py_Void();
30371 return resultobj;
30372 fail:
30373 return NULL;
30374 }
30375
30376
30377 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30378 PyObject *resultobj = 0;
30379 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30380 wxColour *result = 0 ;
30381 void *argp1 = 0 ;
30382 int res1 = 0 ;
30383 PyObject *swig_obj[1] ;
30384
30385 if (!args) SWIG_fail;
30386 swig_obj[0] = args;
30387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30388 if (!SWIG_IsOK(res1)) {
30389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30390 }
30391 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30392 result = (wxColour *)& ((arg1)->colFg);
30393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30394 return resultobj;
30395 fail:
30396 return NULL;
30397 }
30398
30399
30400 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30401 PyObject *resultobj = 0;
30402 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30403 wxColour *arg2 = (wxColour *) 0 ;
30404 void *argp1 = 0 ;
30405 int res1 = 0 ;
30406 void *argp2 = 0 ;
30407 int res2 = 0 ;
30408 PyObject *swig_obj[2] ;
30409
30410 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30412 if (!SWIG_IsOK(res1)) {
30413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30414 }
30415 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30416 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30417 if (!SWIG_IsOK(res2)) {
30418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30419 }
30420 arg2 = reinterpret_cast< wxColour * >(argp2);
30421 if (arg1) (arg1)->colBg = *arg2;
30422
30423 resultobj = SWIG_Py_Void();
30424 return resultobj;
30425 fail:
30426 return NULL;
30427 }
30428
30429
30430 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30431 PyObject *resultobj = 0;
30432 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30433 wxColour *result = 0 ;
30434 void *argp1 = 0 ;
30435 int res1 = 0 ;
30436 PyObject *swig_obj[1] ;
30437
30438 if (!args) SWIG_fail;
30439 swig_obj[0] = args;
30440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30441 if (!SWIG_IsOK(res1)) {
30442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30443 }
30444 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30445 result = (wxColour *)& ((arg1)->colBg);
30446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30447 return resultobj;
30448 fail:
30449 return NULL;
30450 }
30451
30452
30453 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30454 PyObject *obj;
30455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30456 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30457 return SWIG_Py_Void();
30458 }
30459
30460 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30461 return SWIG_Python_InitShadowInstance(args);
30462 }
30463
30464 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30465 PyObject *resultobj = 0;
30466 wxWindow *arg1 = (wxWindow *) 0 ;
30467 int arg2 = (int) (int)-1 ;
30468 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30469 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30470 wxSize const &arg4_defvalue = wxDefaultSize ;
30471 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30472 long arg5 = (long) 0 ;
30473 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30474 wxString *arg6 = (wxString *) &arg6_defvalue ;
30475 wxWindow *result = 0 ;
30476 void *argp1 = 0 ;
30477 int res1 = 0 ;
30478 int val2 ;
30479 int ecode2 = 0 ;
30480 wxPoint temp3 ;
30481 wxSize temp4 ;
30482 long val5 ;
30483 int ecode5 = 0 ;
30484 bool temp6 = false ;
30485 PyObject * obj0 = 0 ;
30486 PyObject * obj1 = 0 ;
30487 PyObject * obj2 = 0 ;
30488 PyObject * obj3 = 0 ;
30489 PyObject * obj4 = 0 ;
30490 PyObject * obj5 = 0 ;
30491 char * kwnames[] = {
30492 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30493 };
30494
30495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30497 if (!SWIG_IsOK(res1)) {
30498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30499 }
30500 arg1 = reinterpret_cast< wxWindow * >(argp1);
30501 if (obj1) {
30502 ecode2 = SWIG_AsVal_int(obj1, &val2);
30503 if (!SWIG_IsOK(ecode2)) {
30504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30505 }
30506 arg2 = static_cast< int >(val2);
30507 }
30508 if (obj2) {
30509 {
30510 arg3 = &temp3;
30511 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30512 }
30513 }
30514 if (obj3) {
30515 {
30516 arg4 = &temp4;
30517 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30518 }
30519 }
30520 if (obj4) {
30521 ecode5 = SWIG_AsVal_long(obj4, &val5);
30522 if (!SWIG_IsOK(ecode5)) {
30523 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30524 }
30525 arg5 = static_cast< long >(val5);
30526 }
30527 if (obj5) {
30528 {
30529 arg6 = wxString_in_helper(obj5);
30530 if (arg6 == NULL) SWIG_fail;
30531 temp6 = true;
30532 }
30533 }
30534 {
30535 if (!wxPyCheckForApp()) SWIG_fail;
30536 PyThreadState* __tstate = wxPyBeginAllowThreads();
30537 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30542 {
30543 if (temp6)
30544 delete arg6;
30545 }
30546 return resultobj;
30547 fail:
30548 {
30549 if (temp6)
30550 delete arg6;
30551 }
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30557 PyObject *resultobj = 0;
30558 wxWindow *result = 0 ;
30559
30560 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30561 {
30562 if (!wxPyCheckForApp()) SWIG_fail;
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 result = (wxWindow *)new wxWindow();
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30569 return resultobj;
30570 fail:
30571 return NULL;
30572 }
30573
30574
30575 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30576 PyObject *resultobj = 0;
30577 wxWindow *arg1 = (wxWindow *) 0 ;
30578 wxWindow *arg2 = (wxWindow *) 0 ;
30579 int arg3 = (int) (int)-1 ;
30580 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30581 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30582 wxSize const &arg5_defvalue = wxDefaultSize ;
30583 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30584 long arg6 = (long) 0 ;
30585 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30586 wxString *arg7 = (wxString *) &arg7_defvalue ;
30587 bool result;
30588 void *argp1 = 0 ;
30589 int res1 = 0 ;
30590 void *argp2 = 0 ;
30591 int res2 = 0 ;
30592 int val3 ;
30593 int ecode3 = 0 ;
30594 wxPoint temp4 ;
30595 wxSize temp5 ;
30596 long val6 ;
30597 int ecode6 = 0 ;
30598 bool temp7 = false ;
30599 PyObject * obj0 = 0 ;
30600 PyObject * obj1 = 0 ;
30601 PyObject * obj2 = 0 ;
30602 PyObject * obj3 = 0 ;
30603 PyObject * obj4 = 0 ;
30604 PyObject * obj5 = 0 ;
30605 PyObject * obj6 = 0 ;
30606 char * kwnames[] = {
30607 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30608 };
30609
30610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30612 if (!SWIG_IsOK(res1)) {
30613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30614 }
30615 arg1 = reinterpret_cast< wxWindow * >(argp1);
30616 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30617 if (!SWIG_IsOK(res2)) {
30618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30619 }
30620 arg2 = reinterpret_cast< wxWindow * >(argp2);
30621 if (obj2) {
30622 ecode3 = SWIG_AsVal_int(obj2, &val3);
30623 if (!SWIG_IsOK(ecode3)) {
30624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30625 }
30626 arg3 = static_cast< int >(val3);
30627 }
30628 if (obj3) {
30629 {
30630 arg4 = &temp4;
30631 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30632 }
30633 }
30634 if (obj4) {
30635 {
30636 arg5 = &temp5;
30637 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30638 }
30639 }
30640 if (obj5) {
30641 ecode6 = SWIG_AsVal_long(obj5, &val6);
30642 if (!SWIG_IsOK(ecode6)) {
30643 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30644 }
30645 arg6 = static_cast< long >(val6);
30646 }
30647 if (obj6) {
30648 {
30649 arg7 = wxString_in_helper(obj6);
30650 if (arg7 == NULL) SWIG_fail;
30651 temp7 = true;
30652 }
30653 }
30654 {
30655 PyThreadState* __tstate = wxPyBeginAllowThreads();
30656 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30657 wxPyEndAllowThreads(__tstate);
30658 if (PyErr_Occurred()) SWIG_fail;
30659 }
30660 {
30661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30662 }
30663 {
30664 if (temp7)
30665 delete arg7;
30666 }
30667 return resultobj;
30668 fail:
30669 {
30670 if (temp7)
30671 delete arg7;
30672 }
30673 return NULL;
30674 }
30675
30676
30677 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30678 PyObject *resultobj = 0;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 bool arg2 = (bool) false ;
30681 bool result;
30682 void *argp1 = 0 ;
30683 int res1 = 0 ;
30684 bool val2 ;
30685 int ecode2 = 0 ;
30686 PyObject * obj0 = 0 ;
30687 PyObject * obj1 = 0 ;
30688 char * kwnames[] = {
30689 (char *) "self",(char *) "force", NULL
30690 };
30691
30692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30694 if (!SWIG_IsOK(res1)) {
30695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30696 }
30697 arg1 = reinterpret_cast< wxWindow * >(argp1);
30698 if (obj1) {
30699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30700 if (!SWIG_IsOK(ecode2)) {
30701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30702 }
30703 arg2 = static_cast< bool >(val2);
30704 }
30705 {
30706 PyThreadState* __tstate = wxPyBeginAllowThreads();
30707 result = (bool)(arg1)->Close(arg2);
30708 wxPyEndAllowThreads(__tstate);
30709 if (PyErr_Occurred()) SWIG_fail;
30710 }
30711 {
30712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30713 }
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30721 PyObject *resultobj = 0;
30722 wxWindow *arg1 = (wxWindow *) 0 ;
30723 bool result;
30724 void *argp1 = 0 ;
30725 int res1 = 0 ;
30726 PyObject *swig_obj[1] ;
30727
30728 if (!args) SWIG_fail;
30729 swig_obj[0] = args;
30730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30731 if (!SWIG_IsOK(res1)) {
30732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30733 }
30734 arg1 = reinterpret_cast< wxWindow * >(argp1);
30735 {
30736 PyThreadState* __tstate = wxPyBeginAllowThreads();
30737 result = (bool)(arg1)->Destroy();
30738 wxPyEndAllowThreads(__tstate);
30739 if (PyErr_Occurred()) SWIG_fail;
30740 }
30741 {
30742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30743 }
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30751 PyObject *resultobj = 0;
30752 wxWindow *arg1 = (wxWindow *) 0 ;
30753 bool result;
30754 void *argp1 = 0 ;
30755 int res1 = 0 ;
30756 PyObject *swig_obj[1] ;
30757
30758 if (!args) SWIG_fail;
30759 swig_obj[0] = args;
30760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30761 if (!SWIG_IsOK(res1)) {
30762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30763 }
30764 arg1 = reinterpret_cast< wxWindow * >(argp1);
30765 {
30766 PyThreadState* __tstate = wxPyBeginAllowThreads();
30767 result = (bool)(arg1)->DestroyChildren();
30768 wxPyEndAllowThreads(__tstate);
30769 if (PyErr_Occurred()) SWIG_fail;
30770 }
30771 {
30772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30773 }
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30781 PyObject *resultobj = 0;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 bool result;
30784 void *argp1 = 0 ;
30785 int res1 = 0 ;
30786 PyObject *swig_obj[1] ;
30787
30788 if (!args) SWIG_fail;
30789 swig_obj[0] = args;
30790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30791 if (!SWIG_IsOK(res1)) {
30792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30793 }
30794 arg1 = reinterpret_cast< wxWindow * >(argp1);
30795 {
30796 PyThreadState* __tstate = wxPyBeginAllowThreads();
30797 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30798 wxPyEndAllowThreads(__tstate);
30799 if (PyErr_Occurred()) SWIG_fail;
30800 }
30801 {
30802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30803 }
30804 return resultobj;
30805 fail:
30806 return NULL;
30807 }
30808
30809
30810 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30811 PyObject *resultobj = 0;
30812 wxWindow *arg1 = (wxWindow *) 0 ;
30813 wxString *arg2 = 0 ;
30814 void *argp1 = 0 ;
30815 int res1 = 0 ;
30816 bool temp2 = false ;
30817 PyObject * obj0 = 0 ;
30818 PyObject * obj1 = 0 ;
30819 char * kwnames[] = {
30820 (char *) "self",(char *) "label", NULL
30821 };
30822
30823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30825 if (!SWIG_IsOK(res1)) {
30826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30827 }
30828 arg1 = reinterpret_cast< wxWindow * >(argp1);
30829 {
30830 arg2 = wxString_in_helper(obj1);
30831 if (arg2 == NULL) SWIG_fail;
30832 temp2 = true;
30833 }
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 (arg1)->SetLabel((wxString const &)*arg2);
30837 wxPyEndAllowThreads(__tstate);
30838 if (PyErr_Occurred()) SWIG_fail;
30839 }
30840 resultobj = SWIG_Py_Void();
30841 {
30842 if (temp2)
30843 delete arg2;
30844 }
30845 return resultobj;
30846 fail:
30847 {
30848 if (temp2)
30849 delete arg2;
30850 }
30851 return NULL;
30852 }
30853
30854
30855 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30856 PyObject *resultobj = 0;
30857 wxWindow *arg1 = (wxWindow *) 0 ;
30858 wxString result;
30859 void *argp1 = 0 ;
30860 int res1 = 0 ;
30861 PyObject *swig_obj[1] ;
30862
30863 if (!args) SWIG_fail;
30864 swig_obj[0] = args;
30865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30868 }
30869 arg1 = reinterpret_cast< wxWindow * >(argp1);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = ((wxWindow const *)arg1)->GetLabel();
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 {
30877 #if wxUSE_UNICODE
30878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30879 #else
30880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30881 #endif
30882 }
30883 return resultobj;
30884 fail:
30885 return NULL;
30886 }
30887
30888
30889 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30890 PyObject *resultobj = 0;
30891 wxWindow *arg1 = (wxWindow *) 0 ;
30892 wxString *arg2 = 0 ;
30893 void *argp1 = 0 ;
30894 int res1 = 0 ;
30895 bool temp2 = false ;
30896 PyObject * obj0 = 0 ;
30897 PyObject * obj1 = 0 ;
30898 char * kwnames[] = {
30899 (char *) "self",(char *) "name", NULL
30900 };
30901
30902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30904 if (!SWIG_IsOK(res1)) {
30905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30906 }
30907 arg1 = reinterpret_cast< wxWindow * >(argp1);
30908 {
30909 arg2 = wxString_in_helper(obj1);
30910 if (arg2 == NULL) SWIG_fail;
30911 temp2 = true;
30912 }
30913 {
30914 PyThreadState* __tstate = wxPyBeginAllowThreads();
30915 (arg1)->SetName((wxString const &)*arg2);
30916 wxPyEndAllowThreads(__tstate);
30917 if (PyErr_Occurred()) SWIG_fail;
30918 }
30919 resultobj = SWIG_Py_Void();
30920 {
30921 if (temp2)
30922 delete arg2;
30923 }
30924 return resultobj;
30925 fail:
30926 {
30927 if (temp2)
30928 delete arg2;
30929 }
30930 return NULL;
30931 }
30932
30933
30934 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30935 PyObject *resultobj = 0;
30936 wxWindow *arg1 = (wxWindow *) 0 ;
30937 wxString result;
30938 void *argp1 = 0 ;
30939 int res1 = 0 ;
30940 PyObject *swig_obj[1] ;
30941
30942 if (!args) SWIG_fail;
30943 swig_obj[0] = args;
30944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30945 if (!SWIG_IsOK(res1)) {
30946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30947 }
30948 arg1 = reinterpret_cast< wxWindow * >(argp1);
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 result = ((wxWindow const *)arg1)->GetName();
30952 wxPyEndAllowThreads(__tstate);
30953 if (PyErr_Occurred()) SWIG_fail;
30954 }
30955 {
30956 #if wxUSE_UNICODE
30957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30958 #else
30959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30960 #endif
30961 }
30962 return resultobj;
30963 fail:
30964 return NULL;
30965 }
30966
30967
30968 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30969 PyObject *resultobj = 0;
30970 wxWindow *arg1 = (wxWindow *) 0 ;
30971 wxWindowVariant arg2 ;
30972 void *argp1 = 0 ;
30973 int res1 = 0 ;
30974 int val2 ;
30975 int ecode2 = 0 ;
30976 PyObject * obj0 = 0 ;
30977 PyObject * obj1 = 0 ;
30978 char * kwnames[] = {
30979 (char *) "self",(char *) "variant", NULL
30980 };
30981
30982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30984 if (!SWIG_IsOK(res1)) {
30985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30986 }
30987 arg1 = reinterpret_cast< wxWindow * >(argp1);
30988 ecode2 = SWIG_AsVal_int(obj1, &val2);
30989 if (!SWIG_IsOK(ecode2)) {
30990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30991 }
30992 arg2 = static_cast< wxWindowVariant >(val2);
30993 {
30994 PyThreadState* __tstate = wxPyBeginAllowThreads();
30995 (arg1)->SetWindowVariant(arg2);
30996 wxPyEndAllowThreads(__tstate);
30997 if (PyErr_Occurred()) SWIG_fail;
30998 }
30999 resultobj = SWIG_Py_Void();
31000 return resultobj;
31001 fail:
31002 return NULL;
31003 }
31004
31005
31006 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31007 PyObject *resultobj = 0;
31008 wxWindow *arg1 = (wxWindow *) 0 ;
31009 wxWindowVariant result;
31010 void *argp1 = 0 ;
31011 int res1 = 0 ;
31012 PyObject *swig_obj[1] ;
31013
31014 if (!args) SWIG_fail;
31015 swig_obj[0] = args;
31016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31017 if (!SWIG_IsOK(res1)) {
31018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31019 }
31020 arg1 = reinterpret_cast< wxWindow * >(argp1);
31021 {
31022 PyThreadState* __tstate = wxPyBeginAllowThreads();
31023 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31024 wxPyEndAllowThreads(__tstate);
31025 if (PyErr_Occurred()) SWIG_fail;
31026 }
31027 resultobj = SWIG_From_int(static_cast< int >(result));
31028 return resultobj;
31029 fail:
31030 return NULL;
31031 }
31032
31033
31034 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31035 PyObject *resultobj = 0;
31036 wxWindow *arg1 = (wxWindow *) 0 ;
31037 int arg2 ;
31038 void *argp1 = 0 ;
31039 int res1 = 0 ;
31040 int val2 ;
31041 int ecode2 = 0 ;
31042 PyObject * obj0 = 0 ;
31043 PyObject * obj1 = 0 ;
31044 char * kwnames[] = {
31045 (char *) "self",(char *) "winid", NULL
31046 };
31047
31048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31050 if (!SWIG_IsOK(res1)) {
31051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31052 }
31053 arg1 = reinterpret_cast< wxWindow * >(argp1);
31054 ecode2 = SWIG_AsVal_int(obj1, &val2);
31055 if (!SWIG_IsOK(ecode2)) {
31056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31057 }
31058 arg2 = static_cast< int >(val2);
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 (arg1)->SetId(arg2);
31062 wxPyEndAllowThreads(__tstate);
31063 if (PyErr_Occurred()) SWIG_fail;
31064 }
31065 resultobj = SWIG_Py_Void();
31066 return resultobj;
31067 fail:
31068 return NULL;
31069 }
31070
31071
31072 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31073 PyObject *resultobj = 0;
31074 wxWindow *arg1 = (wxWindow *) 0 ;
31075 int result;
31076 void *argp1 = 0 ;
31077 int res1 = 0 ;
31078 PyObject *swig_obj[1] ;
31079
31080 if (!args) SWIG_fail;
31081 swig_obj[0] = args;
31082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31083 if (!SWIG_IsOK(res1)) {
31084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31085 }
31086 arg1 = reinterpret_cast< wxWindow * >(argp1);
31087 {
31088 PyThreadState* __tstate = wxPyBeginAllowThreads();
31089 result = (int)((wxWindow const *)arg1)->GetId();
31090 wxPyEndAllowThreads(__tstate);
31091 if (PyErr_Occurred()) SWIG_fail;
31092 }
31093 resultobj = SWIG_From_int(static_cast< int >(result));
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31101 PyObject *resultobj = 0;
31102 int result;
31103
31104 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31105 {
31106 PyThreadState* __tstate = wxPyBeginAllowThreads();
31107 result = (int)wxWindow::NewControlId();
31108 wxPyEndAllowThreads(__tstate);
31109 if (PyErr_Occurred()) SWIG_fail;
31110 }
31111 resultobj = SWIG_From_int(static_cast< int >(result));
31112 return resultobj;
31113 fail:
31114 return NULL;
31115 }
31116
31117
31118 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31119 PyObject *resultobj = 0;
31120 int arg1 ;
31121 int result;
31122 int val1 ;
31123 int ecode1 = 0 ;
31124 PyObject * obj0 = 0 ;
31125 char * kwnames[] = {
31126 (char *) "winid", NULL
31127 };
31128
31129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31130 ecode1 = SWIG_AsVal_int(obj0, &val1);
31131 if (!SWIG_IsOK(ecode1)) {
31132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31133 }
31134 arg1 = static_cast< int >(val1);
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 result = (int)wxWindow::NextControlId(arg1);
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_From_int(static_cast< int >(result));
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 int arg1 ;
31151 int result;
31152 int val1 ;
31153 int ecode1 = 0 ;
31154 PyObject * obj0 = 0 ;
31155 char * kwnames[] = {
31156 (char *) "winid", NULL
31157 };
31158
31159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31160 ecode1 = SWIG_AsVal_int(obj0, &val1);
31161 if (!SWIG_IsOK(ecode1)) {
31162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31163 }
31164 arg1 = static_cast< int >(val1);
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 result = (int)wxWindow::PrevControlId(arg1);
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 resultobj = SWIG_From_int(static_cast< int >(result));
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31179 PyObject *resultobj = 0;
31180 wxWindow *arg1 = (wxWindow *) 0 ;
31181 wxLayoutDirection result;
31182 void *argp1 = 0 ;
31183 int res1 = 0 ;
31184 PyObject *swig_obj[1] ;
31185
31186 if (!args) SWIG_fail;
31187 swig_obj[0] = args;
31188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31189 if (!SWIG_IsOK(res1)) {
31190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31191 }
31192 arg1 = reinterpret_cast< wxWindow * >(argp1);
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 resultobj = SWIG_From_int(static_cast< int >(result));
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31207 PyObject *resultobj = 0;
31208 wxWindow *arg1 = (wxWindow *) 0 ;
31209 wxLayoutDirection arg2 ;
31210 void *argp1 = 0 ;
31211 int res1 = 0 ;
31212 int val2 ;
31213 int ecode2 = 0 ;
31214 PyObject * obj0 = 0 ;
31215 PyObject * obj1 = 0 ;
31216 char * kwnames[] = {
31217 (char *) "self",(char *) "dir", NULL
31218 };
31219
31220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31222 if (!SWIG_IsOK(res1)) {
31223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31224 }
31225 arg1 = reinterpret_cast< wxWindow * >(argp1);
31226 ecode2 = SWIG_AsVal_int(obj1, &val2);
31227 if (!SWIG_IsOK(ecode2)) {
31228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31229 }
31230 arg2 = static_cast< wxLayoutDirection >(val2);
31231 {
31232 PyThreadState* __tstate = wxPyBeginAllowThreads();
31233 (arg1)->SetLayoutDirection(arg2);
31234 wxPyEndAllowThreads(__tstate);
31235 if (PyErr_Occurred()) SWIG_fail;
31236 }
31237 resultobj = SWIG_Py_Void();
31238 return resultobj;
31239 fail:
31240 return NULL;
31241 }
31242
31243
31244 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31245 PyObject *resultobj = 0;
31246 wxWindow *arg1 = (wxWindow *) 0 ;
31247 int arg2 ;
31248 int arg3 ;
31249 int arg4 ;
31250 int result;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 int val2 ;
31254 int ecode2 = 0 ;
31255 int val3 ;
31256 int ecode3 = 0 ;
31257 int val4 ;
31258 int ecode4 = 0 ;
31259 PyObject * obj0 = 0 ;
31260 PyObject * obj1 = 0 ;
31261 PyObject * obj2 = 0 ;
31262 PyObject * obj3 = 0 ;
31263 char * kwnames[] = {
31264 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31265 };
31266
31267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31269 if (!SWIG_IsOK(res1)) {
31270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31271 }
31272 arg1 = reinterpret_cast< wxWindow * >(argp1);
31273 ecode2 = SWIG_AsVal_int(obj1, &val2);
31274 if (!SWIG_IsOK(ecode2)) {
31275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31276 }
31277 arg2 = static_cast< int >(val2);
31278 ecode3 = SWIG_AsVal_int(obj2, &val3);
31279 if (!SWIG_IsOK(ecode3)) {
31280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31281 }
31282 arg3 = static_cast< int >(val3);
31283 ecode4 = SWIG_AsVal_int(obj3, &val4);
31284 if (!SWIG_IsOK(ecode4)) {
31285 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31286 }
31287 arg4 = static_cast< int >(val4);
31288 {
31289 PyThreadState* __tstate = wxPyBeginAllowThreads();
31290 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31291 wxPyEndAllowThreads(__tstate);
31292 if (PyErr_Occurred()) SWIG_fail;
31293 }
31294 resultobj = SWIG_From_int(static_cast< int >(result));
31295 return resultobj;
31296 fail:
31297 return NULL;
31298 }
31299
31300
31301 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31302 PyObject *resultobj = 0;
31303 wxWindow *arg1 = (wxWindow *) 0 ;
31304 wxSize *arg2 = 0 ;
31305 void *argp1 = 0 ;
31306 int res1 = 0 ;
31307 wxSize temp2 ;
31308 PyObject * obj0 = 0 ;
31309 PyObject * obj1 = 0 ;
31310 char * kwnames[] = {
31311 (char *) "self",(char *) "size", NULL
31312 };
31313
31314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31316 if (!SWIG_IsOK(res1)) {
31317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31318 }
31319 arg1 = reinterpret_cast< wxWindow * >(argp1);
31320 {
31321 arg2 = &temp2;
31322 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31323 }
31324 {
31325 PyThreadState* __tstate = wxPyBeginAllowThreads();
31326 (arg1)->SetSize((wxSize const &)*arg2);
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 resultobj = SWIG_Py_Void();
31331 return resultobj;
31332 fail:
31333 return NULL;
31334 }
31335
31336
31337 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31338 PyObject *resultobj = 0;
31339 wxWindow *arg1 = (wxWindow *) 0 ;
31340 int arg2 ;
31341 int arg3 ;
31342 int arg4 ;
31343 int arg5 ;
31344 int arg6 = (int) wxSIZE_AUTO ;
31345 void *argp1 = 0 ;
31346 int res1 = 0 ;
31347 int val2 ;
31348 int ecode2 = 0 ;
31349 int val3 ;
31350 int ecode3 = 0 ;
31351 int val4 ;
31352 int ecode4 = 0 ;
31353 int val5 ;
31354 int ecode5 = 0 ;
31355 int val6 ;
31356 int ecode6 = 0 ;
31357 PyObject * obj0 = 0 ;
31358 PyObject * obj1 = 0 ;
31359 PyObject * obj2 = 0 ;
31360 PyObject * obj3 = 0 ;
31361 PyObject * obj4 = 0 ;
31362 PyObject * obj5 = 0 ;
31363 char * kwnames[] = {
31364 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31365 };
31366
31367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31369 if (!SWIG_IsOK(res1)) {
31370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31371 }
31372 arg1 = reinterpret_cast< wxWindow * >(argp1);
31373 ecode2 = SWIG_AsVal_int(obj1, &val2);
31374 if (!SWIG_IsOK(ecode2)) {
31375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31376 }
31377 arg2 = static_cast< int >(val2);
31378 ecode3 = SWIG_AsVal_int(obj2, &val3);
31379 if (!SWIG_IsOK(ecode3)) {
31380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31381 }
31382 arg3 = static_cast< int >(val3);
31383 ecode4 = SWIG_AsVal_int(obj3, &val4);
31384 if (!SWIG_IsOK(ecode4)) {
31385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31386 }
31387 arg4 = static_cast< int >(val4);
31388 ecode5 = SWIG_AsVal_int(obj4, &val5);
31389 if (!SWIG_IsOK(ecode5)) {
31390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31391 }
31392 arg5 = static_cast< int >(val5);
31393 if (obj5) {
31394 ecode6 = SWIG_AsVal_int(obj5, &val6);
31395 if (!SWIG_IsOK(ecode6)) {
31396 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31397 }
31398 arg6 = static_cast< int >(val6);
31399 }
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31403 wxPyEndAllowThreads(__tstate);
31404 if (PyErr_Occurred()) SWIG_fail;
31405 }
31406 resultobj = SWIG_Py_Void();
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31414 PyObject *resultobj = 0;
31415 wxWindow *arg1 = (wxWindow *) 0 ;
31416 wxRect *arg2 = 0 ;
31417 int arg3 = (int) wxSIZE_AUTO ;
31418 void *argp1 = 0 ;
31419 int res1 = 0 ;
31420 wxRect temp2 ;
31421 int val3 ;
31422 int ecode3 = 0 ;
31423 PyObject * obj0 = 0 ;
31424 PyObject * obj1 = 0 ;
31425 PyObject * obj2 = 0 ;
31426 char * kwnames[] = {
31427 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31428 };
31429
31430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31432 if (!SWIG_IsOK(res1)) {
31433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31434 }
31435 arg1 = reinterpret_cast< wxWindow * >(argp1);
31436 {
31437 arg2 = &temp2;
31438 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31439 }
31440 if (obj2) {
31441 ecode3 = SWIG_AsVal_int(obj2, &val3);
31442 if (!SWIG_IsOK(ecode3)) {
31443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31444 }
31445 arg3 = static_cast< int >(val3);
31446 }
31447 {
31448 PyThreadState* __tstate = wxPyBeginAllowThreads();
31449 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31450 wxPyEndAllowThreads(__tstate);
31451 if (PyErr_Occurred()) SWIG_fail;
31452 }
31453 resultobj = SWIG_Py_Void();
31454 return resultobj;
31455 fail:
31456 return NULL;
31457 }
31458
31459
31460 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31461 PyObject *resultobj = 0;
31462 wxWindow *arg1 = (wxWindow *) 0 ;
31463 int arg2 ;
31464 int arg3 ;
31465 void *argp1 = 0 ;
31466 int res1 = 0 ;
31467 int val2 ;
31468 int ecode2 = 0 ;
31469 int val3 ;
31470 int ecode3 = 0 ;
31471 PyObject * obj0 = 0 ;
31472 PyObject * obj1 = 0 ;
31473 PyObject * obj2 = 0 ;
31474 char * kwnames[] = {
31475 (char *) "self",(char *) "width",(char *) "height", NULL
31476 };
31477
31478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31480 if (!SWIG_IsOK(res1)) {
31481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31482 }
31483 arg1 = reinterpret_cast< wxWindow * >(argp1);
31484 ecode2 = SWIG_AsVal_int(obj1, &val2);
31485 if (!SWIG_IsOK(ecode2)) {
31486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31487 }
31488 arg2 = static_cast< int >(val2);
31489 ecode3 = SWIG_AsVal_int(obj2, &val3);
31490 if (!SWIG_IsOK(ecode3)) {
31491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31492 }
31493 arg3 = static_cast< int >(val3);
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 (arg1)->SetSize(arg2,arg3);
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 resultobj = SWIG_Py_Void();
31501 return resultobj;
31502 fail:
31503 return NULL;
31504 }
31505
31506
31507 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31508 PyObject *resultobj = 0;
31509 wxWindow *arg1 = (wxWindow *) 0 ;
31510 wxPoint *arg2 = 0 ;
31511 int arg3 = (int) wxSIZE_USE_EXISTING ;
31512 void *argp1 = 0 ;
31513 int res1 = 0 ;
31514 wxPoint temp2 ;
31515 int val3 ;
31516 int ecode3 = 0 ;
31517 PyObject * obj0 = 0 ;
31518 PyObject * obj1 = 0 ;
31519 PyObject * obj2 = 0 ;
31520 char * kwnames[] = {
31521 (char *) "self",(char *) "pt",(char *) "flags", NULL
31522 };
31523
31524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31526 if (!SWIG_IsOK(res1)) {
31527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31528 }
31529 arg1 = reinterpret_cast< wxWindow * >(argp1);
31530 {
31531 arg2 = &temp2;
31532 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31533 }
31534 if (obj2) {
31535 ecode3 = SWIG_AsVal_int(obj2, &val3);
31536 if (!SWIG_IsOK(ecode3)) {
31537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31538 }
31539 arg3 = static_cast< int >(val3);
31540 }
31541 {
31542 PyThreadState* __tstate = wxPyBeginAllowThreads();
31543 (arg1)->Move((wxPoint const &)*arg2,arg3);
31544 wxPyEndAllowThreads(__tstate);
31545 if (PyErr_Occurred()) SWIG_fail;
31546 }
31547 resultobj = SWIG_Py_Void();
31548 return resultobj;
31549 fail:
31550 return NULL;
31551 }
31552
31553
31554 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31555 PyObject *resultobj = 0;
31556 wxWindow *arg1 = (wxWindow *) 0 ;
31557 int arg2 ;
31558 int arg3 ;
31559 int arg4 = (int) wxSIZE_USE_EXISTING ;
31560 void *argp1 = 0 ;
31561 int res1 = 0 ;
31562 int val2 ;
31563 int ecode2 = 0 ;
31564 int val3 ;
31565 int ecode3 = 0 ;
31566 int val4 ;
31567 int ecode4 = 0 ;
31568 PyObject * obj0 = 0 ;
31569 PyObject * obj1 = 0 ;
31570 PyObject * obj2 = 0 ;
31571 PyObject * obj3 = 0 ;
31572 char * kwnames[] = {
31573 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31574 };
31575
31576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31578 if (!SWIG_IsOK(res1)) {
31579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31580 }
31581 arg1 = reinterpret_cast< wxWindow * >(argp1);
31582 ecode2 = SWIG_AsVal_int(obj1, &val2);
31583 if (!SWIG_IsOK(ecode2)) {
31584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31585 }
31586 arg2 = static_cast< int >(val2);
31587 ecode3 = SWIG_AsVal_int(obj2, &val3);
31588 if (!SWIG_IsOK(ecode3)) {
31589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31590 }
31591 arg3 = static_cast< int >(val3);
31592 if (obj3) {
31593 ecode4 = SWIG_AsVal_int(obj3, &val4);
31594 if (!SWIG_IsOK(ecode4)) {
31595 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31596 }
31597 arg4 = static_cast< int >(val4);
31598 }
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 (arg1)->Move(arg2,arg3,arg4);
31602 wxPyEndAllowThreads(__tstate);
31603 if (PyErr_Occurred()) SWIG_fail;
31604 }
31605 resultobj = SWIG_Py_Void();
31606 return resultobj;
31607 fail:
31608 return NULL;
31609 }
31610
31611
31612 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31613 PyObject *resultobj = 0;
31614 wxWindow *arg1 = (wxWindow *) 0 ;
31615 wxSize const &arg2_defvalue = wxDefaultSize ;
31616 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31617 void *argp1 = 0 ;
31618 int res1 = 0 ;
31619 wxSize temp2 ;
31620 PyObject * obj0 = 0 ;
31621 PyObject * obj1 = 0 ;
31622 char * kwnames[] = {
31623 (char *) "self",(char *) "size", NULL
31624 };
31625
31626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31628 if (!SWIG_IsOK(res1)) {
31629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31630 }
31631 arg1 = reinterpret_cast< wxWindow * >(argp1);
31632 if (obj1) {
31633 {
31634 arg2 = &temp2;
31635 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31636 }
31637 }
31638 {
31639 PyThreadState* __tstate = wxPyBeginAllowThreads();
31640 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31641 wxPyEndAllowThreads(__tstate);
31642 if (PyErr_Occurred()) SWIG_fail;
31643 }
31644 resultobj = SWIG_Py_Void();
31645 return resultobj;
31646 fail:
31647 return NULL;
31648 }
31649
31650
31651 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31652 PyObject *resultobj = 0;
31653 wxWindow *arg1 = (wxWindow *) 0 ;
31654 void *argp1 = 0 ;
31655 int res1 = 0 ;
31656 PyObject *swig_obj[1] ;
31657
31658 if (!args) SWIG_fail;
31659 swig_obj[0] = args;
31660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31661 if (!SWIG_IsOK(res1)) {
31662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31663 }
31664 arg1 = reinterpret_cast< wxWindow * >(argp1);
31665 {
31666 PyThreadState* __tstate = wxPyBeginAllowThreads();
31667 (arg1)->Raise();
31668 wxPyEndAllowThreads(__tstate);
31669 if (PyErr_Occurred()) SWIG_fail;
31670 }
31671 resultobj = SWIG_Py_Void();
31672 return resultobj;
31673 fail:
31674 return NULL;
31675 }
31676
31677
31678 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31679 PyObject *resultobj = 0;
31680 wxWindow *arg1 = (wxWindow *) 0 ;
31681 void *argp1 = 0 ;
31682 int res1 = 0 ;
31683 PyObject *swig_obj[1] ;
31684
31685 if (!args) SWIG_fail;
31686 swig_obj[0] = args;
31687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31688 if (!SWIG_IsOK(res1)) {
31689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31690 }
31691 arg1 = reinterpret_cast< wxWindow * >(argp1);
31692 {
31693 PyThreadState* __tstate = wxPyBeginAllowThreads();
31694 (arg1)->Lower();
31695 wxPyEndAllowThreads(__tstate);
31696 if (PyErr_Occurred()) SWIG_fail;
31697 }
31698 resultobj = SWIG_Py_Void();
31699 return resultobj;
31700 fail:
31701 return NULL;
31702 }
31703
31704
31705 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31706 PyObject *resultobj = 0;
31707 wxWindow *arg1 = (wxWindow *) 0 ;
31708 wxSize *arg2 = 0 ;
31709 void *argp1 = 0 ;
31710 int res1 = 0 ;
31711 wxSize temp2 ;
31712 PyObject * obj0 = 0 ;
31713 PyObject * obj1 = 0 ;
31714 char * kwnames[] = {
31715 (char *) "self",(char *) "size", NULL
31716 };
31717
31718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31720 if (!SWIG_IsOK(res1)) {
31721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31722 }
31723 arg1 = reinterpret_cast< wxWindow * >(argp1);
31724 {
31725 arg2 = &temp2;
31726 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31727 }
31728 {
31729 PyThreadState* __tstate = wxPyBeginAllowThreads();
31730 (arg1)->SetClientSize((wxSize const &)*arg2);
31731 wxPyEndAllowThreads(__tstate);
31732 if (PyErr_Occurred()) SWIG_fail;
31733 }
31734 resultobj = SWIG_Py_Void();
31735 return resultobj;
31736 fail:
31737 return NULL;
31738 }
31739
31740
31741 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31742 PyObject *resultobj = 0;
31743 wxWindow *arg1 = (wxWindow *) 0 ;
31744 int arg2 ;
31745 int arg3 ;
31746 void *argp1 = 0 ;
31747 int res1 = 0 ;
31748 int val2 ;
31749 int ecode2 = 0 ;
31750 int val3 ;
31751 int ecode3 = 0 ;
31752 PyObject * obj0 = 0 ;
31753 PyObject * obj1 = 0 ;
31754 PyObject * obj2 = 0 ;
31755 char * kwnames[] = {
31756 (char *) "self",(char *) "width",(char *) "height", NULL
31757 };
31758
31759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31761 if (!SWIG_IsOK(res1)) {
31762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31763 }
31764 arg1 = reinterpret_cast< wxWindow * >(argp1);
31765 ecode2 = SWIG_AsVal_int(obj1, &val2);
31766 if (!SWIG_IsOK(ecode2)) {
31767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31768 }
31769 arg2 = static_cast< int >(val2);
31770 ecode3 = SWIG_AsVal_int(obj2, &val3);
31771 if (!SWIG_IsOK(ecode3)) {
31772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31773 }
31774 arg3 = static_cast< int >(val3);
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 (arg1)->SetClientSize(arg2,arg3);
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_Py_Void();
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31789 PyObject *resultobj = 0;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 wxRect *arg2 = 0 ;
31792 void *argp1 = 0 ;
31793 int res1 = 0 ;
31794 wxRect temp2 ;
31795 PyObject * obj0 = 0 ;
31796 PyObject * obj1 = 0 ;
31797 char * kwnames[] = {
31798 (char *) "self",(char *) "rect", NULL
31799 };
31800
31801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31803 if (!SWIG_IsOK(res1)) {
31804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31805 }
31806 arg1 = reinterpret_cast< wxWindow * >(argp1);
31807 {
31808 arg2 = &temp2;
31809 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31810 }
31811 {
31812 PyThreadState* __tstate = wxPyBeginAllowThreads();
31813 (arg1)->SetClientSize((wxRect const &)*arg2);
31814 wxPyEndAllowThreads(__tstate);
31815 if (PyErr_Occurred()) SWIG_fail;
31816 }
31817 resultobj = SWIG_Py_Void();
31818 return resultobj;
31819 fail:
31820 return NULL;
31821 }
31822
31823
31824 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31825 PyObject *resultobj = 0;
31826 wxWindow *arg1 = (wxWindow *) 0 ;
31827 wxPoint result;
31828 void *argp1 = 0 ;
31829 int res1 = 0 ;
31830 PyObject *swig_obj[1] ;
31831
31832 if (!args) SWIG_fail;
31833 swig_obj[0] = args;
31834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31835 if (!SWIG_IsOK(res1)) {
31836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31837 }
31838 arg1 = reinterpret_cast< wxWindow * >(argp1);
31839 {
31840 PyThreadState* __tstate = wxPyBeginAllowThreads();
31841 result = ((wxWindow const *)arg1)->GetPosition();
31842 wxPyEndAllowThreads(__tstate);
31843 if (PyErr_Occurred()) SWIG_fail;
31844 }
31845 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31846 return resultobj;
31847 fail:
31848 return NULL;
31849 }
31850
31851
31852 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31853 PyObject *resultobj = 0;
31854 wxWindow *arg1 = (wxWindow *) 0 ;
31855 int *arg2 = (int *) 0 ;
31856 int *arg3 = (int *) 0 ;
31857 void *argp1 = 0 ;
31858 int res1 = 0 ;
31859 int temp2 ;
31860 int res2 = SWIG_TMPOBJ ;
31861 int temp3 ;
31862 int res3 = SWIG_TMPOBJ ;
31863 PyObject *swig_obj[1] ;
31864
31865 arg2 = &temp2;
31866 arg3 = &temp3;
31867 if (!args) SWIG_fail;
31868 swig_obj[0] = args;
31869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31870 if (!SWIG_IsOK(res1)) {
31871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31872 }
31873 arg1 = reinterpret_cast< wxWindow * >(argp1);
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31877 wxPyEndAllowThreads(__tstate);
31878 if (PyErr_Occurred()) SWIG_fail;
31879 }
31880 resultobj = SWIG_Py_Void();
31881 if (SWIG_IsTmpObj(res2)) {
31882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31883 } else {
31884 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31886 }
31887 if (SWIG_IsTmpObj(res3)) {
31888 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31889 } else {
31890 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31892 }
31893 return resultobj;
31894 fail:
31895 return NULL;
31896 }
31897
31898
31899 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31900 PyObject *resultobj = 0;
31901 wxWindow *arg1 = (wxWindow *) 0 ;
31902 wxPoint result;
31903 void *argp1 = 0 ;
31904 int res1 = 0 ;
31905 PyObject *swig_obj[1] ;
31906
31907 if (!args) SWIG_fail;
31908 swig_obj[0] = args;
31909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31910 if (!SWIG_IsOK(res1)) {
31911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31912 }
31913 arg1 = reinterpret_cast< wxWindow * >(argp1);
31914 {
31915 PyThreadState* __tstate = wxPyBeginAllowThreads();
31916 result = ((wxWindow const *)arg1)->GetScreenPosition();
31917 wxPyEndAllowThreads(__tstate);
31918 if (PyErr_Occurred()) SWIG_fail;
31919 }
31920 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31921 return resultobj;
31922 fail:
31923 return NULL;
31924 }
31925
31926
31927 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31928 PyObject *resultobj = 0;
31929 wxWindow *arg1 = (wxWindow *) 0 ;
31930 int *arg2 = (int *) 0 ;
31931 int *arg3 = (int *) 0 ;
31932 void *argp1 = 0 ;
31933 int res1 = 0 ;
31934 int temp2 ;
31935 int res2 = SWIG_TMPOBJ ;
31936 int temp3 ;
31937 int res3 = SWIG_TMPOBJ ;
31938 PyObject *swig_obj[1] ;
31939
31940 arg2 = &temp2;
31941 arg3 = &temp3;
31942 if (!args) SWIG_fail;
31943 swig_obj[0] = args;
31944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31945 if (!SWIG_IsOK(res1)) {
31946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31947 }
31948 arg1 = reinterpret_cast< wxWindow * >(argp1);
31949 {
31950 PyThreadState* __tstate = wxPyBeginAllowThreads();
31951 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 resultobj = SWIG_Py_Void();
31956 if (SWIG_IsTmpObj(res2)) {
31957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31958 } else {
31959 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31961 }
31962 if (SWIG_IsTmpObj(res3)) {
31963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31964 } else {
31965 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31967 }
31968 return resultobj;
31969 fail:
31970 return NULL;
31971 }
31972
31973
31974 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31975 PyObject *resultobj = 0;
31976 wxWindow *arg1 = (wxWindow *) 0 ;
31977 wxRect result;
31978 void *argp1 = 0 ;
31979 int res1 = 0 ;
31980 PyObject *swig_obj[1] ;
31981
31982 if (!args) SWIG_fail;
31983 swig_obj[0] = args;
31984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31985 if (!SWIG_IsOK(res1)) {
31986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31987 }
31988 arg1 = reinterpret_cast< wxWindow * >(argp1);
31989 {
31990 PyThreadState* __tstate = wxPyBeginAllowThreads();
31991 result = ((wxWindow const *)arg1)->GetScreenRect();
31992 wxPyEndAllowThreads(__tstate);
31993 if (PyErr_Occurred()) SWIG_fail;
31994 }
31995 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31996 return resultobj;
31997 fail:
31998 return NULL;
31999 }
32000
32001
32002 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32003 PyObject *resultobj = 0;
32004 wxWindow *arg1 = (wxWindow *) 0 ;
32005 wxSize result;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 PyObject *swig_obj[1] ;
32009
32010 if (!args) SWIG_fail;
32011 swig_obj[0] = args;
32012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32015 }
32016 arg1 = reinterpret_cast< wxWindow * >(argp1);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 result = ((wxWindow const *)arg1)->GetSize();
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32031 PyObject *resultobj = 0;
32032 wxWindow *arg1 = (wxWindow *) 0 ;
32033 int *arg2 = (int *) 0 ;
32034 int *arg3 = (int *) 0 ;
32035 void *argp1 = 0 ;
32036 int res1 = 0 ;
32037 int temp2 ;
32038 int res2 = SWIG_TMPOBJ ;
32039 int temp3 ;
32040 int res3 = SWIG_TMPOBJ ;
32041 PyObject *swig_obj[1] ;
32042
32043 arg2 = &temp2;
32044 arg3 = &temp3;
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_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32050 }
32051 arg1 = reinterpret_cast< wxWindow * >(argp1);
32052 {
32053 PyThreadState* __tstate = wxPyBeginAllowThreads();
32054 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32055 wxPyEndAllowThreads(__tstate);
32056 if (PyErr_Occurred()) SWIG_fail;
32057 }
32058 resultobj = SWIG_Py_Void();
32059 if (SWIG_IsTmpObj(res2)) {
32060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32061 } else {
32062 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32063 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32064 }
32065 if (SWIG_IsTmpObj(res3)) {
32066 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32067 } else {
32068 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32069 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32070 }
32071 return resultobj;
32072 fail:
32073 return NULL;
32074 }
32075
32076
32077 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32078 PyObject *resultobj = 0;
32079 wxWindow *arg1 = (wxWindow *) 0 ;
32080 wxRect result;
32081 void *argp1 = 0 ;
32082 int res1 = 0 ;
32083 PyObject *swig_obj[1] ;
32084
32085 if (!args) SWIG_fail;
32086 swig_obj[0] = args;
32087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32088 if (!SWIG_IsOK(res1)) {
32089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32090 }
32091 arg1 = reinterpret_cast< wxWindow * >(argp1);
32092 {
32093 PyThreadState* __tstate = wxPyBeginAllowThreads();
32094 result = ((wxWindow const *)arg1)->GetRect();
32095 wxPyEndAllowThreads(__tstate);
32096 if (PyErr_Occurred()) SWIG_fail;
32097 }
32098 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32099 return resultobj;
32100 fail:
32101 return NULL;
32102 }
32103
32104
32105 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32106 PyObject *resultobj = 0;
32107 wxWindow *arg1 = (wxWindow *) 0 ;
32108 wxSize result;
32109 void *argp1 = 0 ;
32110 int res1 = 0 ;
32111 PyObject *swig_obj[1] ;
32112
32113 if (!args) SWIG_fail;
32114 swig_obj[0] = args;
32115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32116 if (!SWIG_IsOK(res1)) {
32117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32118 }
32119 arg1 = reinterpret_cast< wxWindow * >(argp1);
32120 {
32121 PyThreadState* __tstate = wxPyBeginAllowThreads();
32122 result = ((wxWindow const *)arg1)->GetClientSize();
32123 wxPyEndAllowThreads(__tstate);
32124 if (PyErr_Occurred()) SWIG_fail;
32125 }
32126 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32127 return resultobj;
32128 fail:
32129 return NULL;
32130 }
32131
32132
32133 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32134 PyObject *resultobj = 0;
32135 wxWindow *arg1 = (wxWindow *) 0 ;
32136 int *arg2 = (int *) 0 ;
32137 int *arg3 = (int *) 0 ;
32138 void *argp1 = 0 ;
32139 int res1 = 0 ;
32140 int temp2 ;
32141 int res2 = SWIG_TMPOBJ ;
32142 int temp3 ;
32143 int res3 = SWIG_TMPOBJ ;
32144 PyObject *swig_obj[1] ;
32145
32146 arg2 = &temp2;
32147 arg3 = &temp3;
32148 if (!args) SWIG_fail;
32149 swig_obj[0] = args;
32150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32151 if (!SWIG_IsOK(res1)) {
32152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32153 }
32154 arg1 = reinterpret_cast< wxWindow * >(argp1);
32155 {
32156 PyThreadState* __tstate = wxPyBeginAllowThreads();
32157 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32158 wxPyEndAllowThreads(__tstate);
32159 if (PyErr_Occurred()) SWIG_fail;
32160 }
32161 resultobj = SWIG_Py_Void();
32162 if (SWIG_IsTmpObj(res2)) {
32163 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32164 } else {
32165 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32166 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32167 }
32168 if (SWIG_IsTmpObj(res3)) {
32169 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32170 } else {
32171 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32173 }
32174 return resultobj;
32175 fail:
32176 return NULL;
32177 }
32178
32179
32180 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32181 PyObject *resultobj = 0;
32182 wxWindow *arg1 = (wxWindow *) 0 ;
32183 wxPoint result;
32184 void *argp1 = 0 ;
32185 int res1 = 0 ;
32186 PyObject *swig_obj[1] ;
32187
32188 if (!args) SWIG_fail;
32189 swig_obj[0] = args;
32190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32191 if (!SWIG_IsOK(res1)) {
32192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32193 }
32194 arg1 = reinterpret_cast< wxWindow * >(argp1);
32195 {
32196 PyThreadState* __tstate = wxPyBeginAllowThreads();
32197 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32198 wxPyEndAllowThreads(__tstate);
32199 if (PyErr_Occurred()) SWIG_fail;
32200 }
32201 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32202 return resultobj;
32203 fail:
32204 return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209 PyObject *resultobj = 0;
32210 wxWindow *arg1 = (wxWindow *) 0 ;
32211 wxRect result;
32212 void *argp1 = 0 ;
32213 int res1 = 0 ;
32214 PyObject *swig_obj[1] ;
32215
32216 if (!args) SWIG_fail;
32217 swig_obj[0] = args;
32218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32219 if (!SWIG_IsOK(res1)) {
32220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32221 }
32222 arg1 = reinterpret_cast< wxWindow * >(argp1);
32223 {
32224 PyThreadState* __tstate = wxPyBeginAllowThreads();
32225 result = ((wxWindow const *)arg1)->GetClientRect();
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32230 return resultobj;
32231 fail:
32232 return NULL;
32233 }
32234
32235
32236 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32237 PyObject *resultobj = 0;
32238 wxWindow *arg1 = (wxWindow *) 0 ;
32239 wxSize result;
32240 void *argp1 = 0 ;
32241 int res1 = 0 ;
32242 PyObject *swig_obj[1] ;
32243
32244 if (!args) SWIG_fail;
32245 swig_obj[0] = args;
32246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32247 if (!SWIG_IsOK(res1)) {
32248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32249 }
32250 arg1 = reinterpret_cast< wxWindow * >(argp1);
32251 {
32252 PyThreadState* __tstate = wxPyBeginAllowThreads();
32253 result = ((wxWindow const *)arg1)->GetBestSize();
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32258 return resultobj;
32259 fail:
32260 return NULL;
32261 }
32262
32263
32264 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32265 PyObject *resultobj = 0;
32266 wxWindow *arg1 = (wxWindow *) 0 ;
32267 int *arg2 = (int *) 0 ;
32268 int *arg3 = (int *) 0 ;
32269 void *argp1 = 0 ;
32270 int res1 = 0 ;
32271 int temp2 ;
32272 int res2 = SWIG_TMPOBJ ;
32273 int temp3 ;
32274 int res3 = SWIG_TMPOBJ ;
32275 PyObject *swig_obj[1] ;
32276
32277 arg2 = &temp2;
32278 arg3 = &temp3;
32279 if (!args) SWIG_fail;
32280 swig_obj[0] = args;
32281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32282 if (!SWIG_IsOK(res1)) {
32283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32284 }
32285 arg1 = reinterpret_cast< wxWindow * >(argp1);
32286 {
32287 PyThreadState* __tstate = wxPyBeginAllowThreads();
32288 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32289 wxPyEndAllowThreads(__tstate);
32290 if (PyErr_Occurred()) SWIG_fail;
32291 }
32292 resultobj = SWIG_Py_Void();
32293 if (SWIG_IsTmpObj(res2)) {
32294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32295 } else {
32296 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32298 }
32299 if (SWIG_IsTmpObj(res3)) {
32300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32301 } else {
32302 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32304 }
32305 return resultobj;
32306 fail:
32307 return NULL;
32308 }
32309
32310
32311 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32312 PyObject *resultobj = 0;
32313 wxWindow *arg1 = (wxWindow *) 0 ;
32314 void *argp1 = 0 ;
32315 int res1 = 0 ;
32316 PyObject *swig_obj[1] ;
32317
32318 if (!args) SWIG_fail;
32319 swig_obj[0] = args;
32320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32321 if (!SWIG_IsOK(res1)) {
32322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32323 }
32324 arg1 = reinterpret_cast< wxWindow * >(argp1);
32325 {
32326 PyThreadState* __tstate = wxPyBeginAllowThreads();
32327 (arg1)->InvalidateBestSize();
32328 wxPyEndAllowThreads(__tstate);
32329 if (PyErr_Occurred()) SWIG_fail;
32330 }
32331 resultobj = SWIG_Py_Void();
32332 return resultobj;
32333 fail:
32334 return NULL;
32335 }
32336
32337
32338 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32339 PyObject *resultobj = 0;
32340 wxWindow *arg1 = (wxWindow *) 0 ;
32341 wxSize *arg2 = 0 ;
32342 void *argp1 = 0 ;
32343 int res1 = 0 ;
32344 wxSize temp2 ;
32345 PyObject * obj0 = 0 ;
32346 PyObject * obj1 = 0 ;
32347 char * kwnames[] = {
32348 (char *) "self",(char *) "size", NULL
32349 };
32350
32351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32353 if (!SWIG_IsOK(res1)) {
32354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32355 }
32356 arg1 = reinterpret_cast< wxWindow * >(argp1);
32357 {
32358 arg2 = &temp2;
32359 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32360 }
32361 {
32362 PyThreadState* __tstate = wxPyBeginAllowThreads();
32363 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32364 wxPyEndAllowThreads(__tstate);
32365 if (PyErr_Occurred()) SWIG_fail;
32366 }
32367 resultobj = SWIG_Py_Void();
32368 return resultobj;
32369 fail:
32370 return NULL;
32371 }
32372
32373
32374 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32375 PyObject *resultobj = 0;
32376 wxWindow *arg1 = (wxWindow *) 0 ;
32377 wxSize result;
32378 void *argp1 = 0 ;
32379 int res1 = 0 ;
32380 PyObject *swig_obj[1] ;
32381
32382 if (!args) SWIG_fail;
32383 swig_obj[0] = args;
32384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32385 if (!SWIG_IsOK(res1)) {
32386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32387 }
32388 arg1 = reinterpret_cast< wxWindow * >(argp1);
32389 {
32390 PyThreadState* __tstate = wxPyBeginAllowThreads();
32391 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32392 wxPyEndAllowThreads(__tstate);
32393 if (PyErr_Occurred()) SWIG_fail;
32394 }
32395 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32396 return resultobj;
32397 fail:
32398 return NULL;
32399 }
32400
32401
32402 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32403 PyObject *resultobj = 0;
32404 wxWindow *arg1 = (wxWindow *) 0 ;
32405 wxSize result;
32406 void *argp1 = 0 ;
32407 int res1 = 0 ;
32408 PyObject *swig_obj[1] ;
32409
32410 if (!args) SWIG_fail;
32411 swig_obj[0] = args;
32412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32413 if (!SWIG_IsOK(res1)) {
32414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32415 }
32416 arg1 = reinterpret_cast< wxWindow * >(argp1);
32417 {
32418 PyThreadState* __tstate = wxPyBeginAllowThreads();
32419 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32420 wxPyEndAllowThreads(__tstate);
32421 if (PyErr_Occurred()) SWIG_fail;
32422 }
32423 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32424 return resultobj;
32425 fail:
32426 return NULL;
32427 }
32428
32429
32430 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32431 PyObject *resultobj = 0;
32432 wxWindow *arg1 = (wxWindow *) 0 ;
32433 int arg2 = (int) wxBOTH ;
32434 void *argp1 = 0 ;
32435 int res1 = 0 ;
32436 int val2 ;
32437 int ecode2 = 0 ;
32438 PyObject * obj0 = 0 ;
32439 PyObject * obj1 = 0 ;
32440 char * kwnames[] = {
32441 (char *) "self",(char *) "direction", NULL
32442 };
32443
32444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32446 if (!SWIG_IsOK(res1)) {
32447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32448 }
32449 arg1 = reinterpret_cast< wxWindow * >(argp1);
32450 if (obj1) {
32451 ecode2 = SWIG_AsVal_int(obj1, &val2);
32452 if (!SWIG_IsOK(ecode2)) {
32453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32454 }
32455 arg2 = static_cast< int >(val2);
32456 }
32457 {
32458 PyThreadState* __tstate = wxPyBeginAllowThreads();
32459 (arg1)->Center(arg2);
32460 wxPyEndAllowThreads(__tstate);
32461 if (PyErr_Occurred()) SWIG_fail;
32462 }
32463 resultobj = SWIG_Py_Void();
32464 return resultobj;
32465 fail:
32466 return NULL;
32467 }
32468
32469
32470 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32471 PyObject *resultobj = 0;
32472 wxWindow *arg1 = (wxWindow *) 0 ;
32473 int arg2 = (int) wxBOTH ;
32474 void *argp1 = 0 ;
32475 int res1 = 0 ;
32476 int val2 ;
32477 int ecode2 = 0 ;
32478 PyObject * obj0 = 0 ;
32479 PyObject * obj1 = 0 ;
32480 char * kwnames[] = {
32481 (char *) "self",(char *) "dir", NULL
32482 };
32483
32484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32486 if (!SWIG_IsOK(res1)) {
32487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32488 }
32489 arg1 = reinterpret_cast< wxWindow * >(argp1);
32490 if (obj1) {
32491 ecode2 = SWIG_AsVal_int(obj1, &val2);
32492 if (!SWIG_IsOK(ecode2)) {
32493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32494 }
32495 arg2 = static_cast< int >(val2);
32496 }
32497 {
32498 PyThreadState* __tstate = wxPyBeginAllowThreads();
32499 (arg1)->CenterOnParent(arg2);
32500 wxPyEndAllowThreads(__tstate);
32501 if (PyErr_Occurred()) SWIG_fail;
32502 }
32503 resultobj = SWIG_Py_Void();
32504 return resultobj;
32505 fail:
32506 return NULL;
32507 }
32508
32509
32510 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32511 PyObject *resultobj = 0;
32512 wxWindow *arg1 = (wxWindow *) 0 ;
32513 void *argp1 = 0 ;
32514 int res1 = 0 ;
32515 PyObject *swig_obj[1] ;
32516
32517 if (!args) SWIG_fail;
32518 swig_obj[0] = args;
32519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32520 if (!SWIG_IsOK(res1)) {
32521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32522 }
32523 arg1 = reinterpret_cast< wxWindow * >(argp1);
32524 {
32525 PyThreadState* __tstate = wxPyBeginAllowThreads();
32526 (arg1)->Fit();
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 resultobj = SWIG_Py_Void();
32531 return resultobj;
32532 fail:
32533 return NULL;
32534 }
32535
32536
32537 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32538 PyObject *resultobj = 0;
32539 wxWindow *arg1 = (wxWindow *) 0 ;
32540 void *argp1 = 0 ;
32541 int res1 = 0 ;
32542 PyObject *swig_obj[1] ;
32543
32544 if (!args) SWIG_fail;
32545 swig_obj[0] = args;
32546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32547 if (!SWIG_IsOK(res1)) {
32548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32549 }
32550 arg1 = reinterpret_cast< wxWindow * >(argp1);
32551 {
32552 PyThreadState* __tstate = wxPyBeginAllowThreads();
32553 (arg1)->FitInside();
32554 wxPyEndAllowThreads(__tstate);
32555 if (PyErr_Occurred()) SWIG_fail;
32556 }
32557 resultobj = SWIG_Py_Void();
32558 return resultobj;
32559 fail:
32560 return NULL;
32561 }
32562
32563
32564 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj = 0;
32566 wxWindow *arg1 = (wxWindow *) 0 ;
32567 int arg2 ;
32568 int arg3 ;
32569 int arg4 = (int) -1 ;
32570 int arg5 = (int) -1 ;
32571 int arg6 = (int) -1 ;
32572 int arg7 = (int) -1 ;
32573 void *argp1 = 0 ;
32574 int res1 = 0 ;
32575 int val2 ;
32576 int ecode2 = 0 ;
32577 int val3 ;
32578 int ecode3 = 0 ;
32579 int val4 ;
32580 int ecode4 = 0 ;
32581 int val5 ;
32582 int ecode5 = 0 ;
32583 int val6 ;
32584 int ecode6 = 0 ;
32585 int val7 ;
32586 int ecode7 = 0 ;
32587 PyObject * obj0 = 0 ;
32588 PyObject * obj1 = 0 ;
32589 PyObject * obj2 = 0 ;
32590 PyObject * obj3 = 0 ;
32591 PyObject * obj4 = 0 ;
32592 PyObject * obj5 = 0 ;
32593 PyObject * obj6 = 0 ;
32594 char * kwnames[] = {
32595 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32596 };
32597
32598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32600 if (!SWIG_IsOK(res1)) {
32601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32602 }
32603 arg1 = reinterpret_cast< wxWindow * >(argp1);
32604 ecode2 = SWIG_AsVal_int(obj1, &val2);
32605 if (!SWIG_IsOK(ecode2)) {
32606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32607 }
32608 arg2 = static_cast< int >(val2);
32609 ecode3 = SWIG_AsVal_int(obj2, &val3);
32610 if (!SWIG_IsOK(ecode3)) {
32611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32612 }
32613 arg3 = static_cast< int >(val3);
32614 if (obj3) {
32615 ecode4 = SWIG_AsVal_int(obj3, &val4);
32616 if (!SWIG_IsOK(ecode4)) {
32617 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32618 }
32619 arg4 = static_cast< int >(val4);
32620 }
32621 if (obj4) {
32622 ecode5 = SWIG_AsVal_int(obj4, &val5);
32623 if (!SWIG_IsOK(ecode5)) {
32624 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32625 }
32626 arg5 = static_cast< int >(val5);
32627 }
32628 if (obj5) {
32629 ecode6 = SWIG_AsVal_int(obj5, &val6);
32630 if (!SWIG_IsOK(ecode6)) {
32631 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32632 }
32633 arg6 = static_cast< int >(val6);
32634 }
32635 if (obj6) {
32636 ecode7 = SWIG_AsVal_int(obj6, &val7);
32637 if (!SWIG_IsOK(ecode7)) {
32638 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32639 }
32640 arg7 = static_cast< int >(val7);
32641 }
32642 {
32643 PyThreadState* __tstate = wxPyBeginAllowThreads();
32644 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32645 wxPyEndAllowThreads(__tstate);
32646 if (PyErr_Occurred()) SWIG_fail;
32647 }
32648 resultobj = SWIG_Py_Void();
32649 return resultobj;
32650 fail:
32651 return NULL;
32652 }
32653
32654
32655 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32656 PyObject *resultobj = 0;
32657 wxWindow *arg1 = (wxWindow *) 0 ;
32658 wxSize *arg2 = 0 ;
32659 wxSize const &arg3_defvalue = wxDefaultSize ;
32660 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32661 wxSize const &arg4_defvalue = wxDefaultSize ;
32662 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32663 void *argp1 = 0 ;
32664 int res1 = 0 ;
32665 wxSize temp2 ;
32666 wxSize temp3 ;
32667 wxSize temp4 ;
32668 PyObject * obj0 = 0 ;
32669 PyObject * obj1 = 0 ;
32670 PyObject * obj2 = 0 ;
32671 PyObject * obj3 = 0 ;
32672 char * kwnames[] = {
32673 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32674 };
32675
32676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32678 if (!SWIG_IsOK(res1)) {
32679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32680 }
32681 arg1 = reinterpret_cast< wxWindow * >(argp1);
32682 {
32683 arg2 = &temp2;
32684 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32685 }
32686 if (obj2) {
32687 {
32688 arg3 = &temp3;
32689 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32690 }
32691 }
32692 if (obj3) {
32693 {
32694 arg4 = &temp4;
32695 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32696 }
32697 }
32698 {
32699 PyThreadState* __tstate = wxPyBeginAllowThreads();
32700 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32701 wxPyEndAllowThreads(__tstate);
32702 if (PyErr_Occurred()) SWIG_fail;
32703 }
32704 resultobj = SWIG_Py_Void();
32705 return resultobj;
32706 fail:
32707 return NULL;
32708 }
32709
32710
32711 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32712 PyObject *resultobj = 0;
32713 wxWindow *arg1 = (wxWindow *) 0 ;
32714 int arg2 ;
32715 int arg3 ;
32716 int arg4 = (int) -1 ;
32717 int arg5 = (int) -1 ;
32718 void *argp1 = 0 ;
32719 int res1 = 0 ;
32720 int val2 ;
32721 int ecode2 = 0 ;
32722 int val3 ;
32723 int ecode3 = 0 ;
32724 int val4 ;
32725 int ecode4 = 0 ;
32726 int val5 ;
32727 int ecode5 = 0 ;
32728 PyObject * obj0 = 0 ;
32729 PyObject * obj1 = 0 ;
32730 PyObject * obj2 = 0 ;
32731 PyObject * obj3 = 0 ;
32732 PyObject * obj4 = 0 ;
32733 char * kwnames[] = {
32734 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32735 };
32736
32737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32739 if (!SWIG_IsOK(res1)) {
32740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32741 }
32742 arg1 = reinterpret_cast< wxWindow * >(argp1);
32743 ecode2 = SWIG_AsVal_int(obj1, &val2);
32744 if (!SWIG_IsOK(ecode2)) {
32745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32746 }
32747 arg2 = static_cast< int >(val2);
32748 ecode3 = SWIG_AsVal_int(obj2, &val3);
32749 if (!SWIG_IsOK(ecode3)) {
32750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32751 }
32752 arg3 = static_cast< int >(val3);
32753 if (obj3) {
32754 ecode4 = SWIG_AsVal_int(obj3, &val4);
32755 if (!SWIG_IsOK(ecode4)) {
32756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32757 }
32758 arg4 = static_cast< int >(val4);
32759 }
32760 if (obj4) {
32761 ecode5 = SWIG_AsVal_int(obj4, &val5);
32762 if (!SWIG_IsOK(ecode5)) {
32763 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32764 }
32765 arg5 = static_cast< int >(val5);
32766 }
32767 {
32768 PyThreadState* __tstate = wxPyBeginAllowThreads();
32769 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32770 wxPyEndAllowThreads(__tstate);
32771 if (PyErr_Occurred()) SWIG_fail;
32772 }
32773 resultobj = SWIG_Py_Void();
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32781 PyObject *resultobj = 0;
32782 wxWindow *arg1 = (wxWindow *) 0 ;
32783 wxSize *arg2 = 0 ;
32784 wxSize const &arg3_defvalue = wxDefaultSize ;
32785 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32786 void *argp1 = 0 ;
32787 int res1 = 0 ;
32788 wxSize temp2 ;
32789 wxSize temp3 ;
32790 PyObject * obj0 = 0 ;
32791 PyObject * obj1 = 0 ;
32792 PyObject * obj2 = 0 ;
32793 char * kwnames[] = {
32794 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32795 };
32796
32797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32799 if (!SWIG_IsOK(res1)) {
32800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32801 }
32802 arg1 = reinterpret_cast< wxWindow * >(argp1);
32803 {
32804 arg2 = &temp2;
32805 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32806 }
32807 if (obj2) {
32808 {
32809 arg3 = &temp3;
32810 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32811 }
32812 }
32813 {
32814 PyThreadState* __tstate = wxPyBeginAllowThreads();
32815 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32816 wxPyEndAllowThreads(__tstate);
32817 if (PyErr_Occurred()) SWIG_fail;
32818 }
32819 resultobj = SWIG_Py_Void();
32820 return resultobj;
32821 fail:
32822 return NULL;
32823 }
32824
32825
32826 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32827 PyObject *resultobj = 0;
32828 wxWindow *arg1 = (wxWindow *) 0 ;
32829 wxSize result;
32830 void *argp1 = 0 ;
32831 int res1 = 0 ;
32832 PyObject *swig_obj[1] ;
32833
32834 if (!args) SWIG_fail;
32835 swig_obj[0] = args;
32836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32837 if (!SWIG_IsOK(res1)) {
32838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32839 }
32840 arg1 = reinterpret_cast< wxWindow * >(argp1);
32841 {
32842 PyThreadState* __tstate = wxPyBeginAllowThreads();
32843 result = ((wxWindow const *)arg1)->GetMaxSize();
32844 wxPyEndAllowThreads(__tstate);
32845 if (PyErr_Occurred()) SWIG_fail;
32846 }
32847 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32848 return resultobj;
32849 fail:
32850 return NULL;
32851 }
32852
32853
32854 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32855 PyObject *resultobj = 0;
32856 wxWindow *arg1 = (wxWindow *) 0 ;
32857 wxSize result;
32858 void *argp1 = 0 ;
32859 int res1 = 0 ;
32860 PyObject *swig_obj[1] ;
32861
32862 if (!args) SWIG_fail;
32863 swig_obj[0] = args;
32864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32865 if (!SWIG_IsOK(res1)) {
32866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32867 }
32868 arg1 = reinterpret_cast< wxWindow * >(argp1);
32869 {
32870 PyThreadState* __tstate = wxPyBeginAllowThreads();
32871 result = ((wxWindow const *)arg1)->GetMinSize();
32872 wxPyEndAllowThreads(__tstate);
32873 if (PyErr_Occurred()) SWIG_fail;
32874 }
32875 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32876 return resultobj;
32877 fail:
32878 return NULL;
32879 }
32880
32881
32882 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32883 PyObject *resultobj = 0;
32884 wxWindow *arg1 = (wxWindow *) 0 ;
32885 wxSize *arg2 = 0 ;
32886 void *argp1 = 0 ;
32887 int res1 = 0 ;
32888 wxSize temp2 ;
32889 PyObject * obj0 = 0 ;
32890 PyObject * obj1 = 0 ;
32891 char * kwnames[] = {
32892 (char *) "self",(char *) "minSize", NULL
32893 };
32894
32895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32897 if (!SWIG_IsOK(res1)) {
32898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32899 }
32900 arg1 = reinterpret_cast< wxWindow * >(argp1);
32901 {
32902 arg2 = &temp2;
32903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32904 }
32905 {
32906 PyThreadState* __tstate = wxPyBeginAllowThreads();
32907 (arg1)->SetMinSize((wxSize const &)*arg2);
32908 wxPyEndAllowThreads(__tstate);
32909 if (PyErr_Occurred()) SWIG_fail;
32910 }
32911 resultobj = SWIG_Py_Void();
32912 return resultobj;
32913 fail:
32914 return NULL;
32915 }
32916
32917
32918 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32919 PyObject *resultobj = 0;
32920 wxWindow *arg1 = (wxWindow *) 0 ;
32921 wxSize *arg2 = 0 ;
32922 void *argp1 = 0 ;
32923 int res1 = 0 ;
32924 wxSize temp2 ;
32925 PyObject * obj0 = 0 ;
32926 PyObject * obj1 = 0 ;
32927 char * kwnames[] = {
32928 (char *) "self",(char *) "maxSize", NULL
32929 };
32930
32931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32933 if (!SWIG_IsOK(res1)) {
32934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32935 }
32936 arg1 = reinterpret_cast< wxWindow * >(argp1);
32937 {
32938 arg2 = &temp2;
32939 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32940 }
32941 {
32942 PyThreadState* __tstate = wxPyBeginAllowThreads();
32943 (arg1)->SetMaxSize((wxSize const &)*arg2);
32944 wxPyEndAllowThreads(__tstate);
32945 if (PyErr_Occurred()) SWIG_fail;
32946 }
32947 resultobj = SWIG_Py_Void();
32948 return resultobj;
32949 fail:
32950 return NULL;
32951 }
32952
32953
32954 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32955 PyObject *resultobj = 0;
32956 wxWindow *arg1 = (wxWindow *) 0 ;
32957 int result;
32958 void *argp1 = 0 ;
32959 int res1 = 0 ;
32960 PyObject *swig_obj[1] ;
32961
32962 if (!args) SWIG_fail;
32963 swig_obj[0] = args;
32964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32965 if (!SWIG_IsOK(res1)) {
32966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32967 }
32968 arg1 = reinterpret_cast< wxWindow * >(argp1);
32969 {
32970 PyThreadState* __tstate = wxPyBeginAllowThreads();
32971 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32972 wxPyEndAllowThreads(__tstate);
32973 if (PyErr_Occurred()) SWIG_fail;
32974 }
32975 resultobj = SWIG_From_int(static_cast< int >(result));
32976 return resultobj;
32977 fail:
32978 return NULL;
32979 }
32980
32981
32982 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32983 PyObject *resultobj = 0;
32984 wxWindow *arg1 = (wxWindow *) 0 ;
32985 int result;
32986 void *argp1 = 0 ;
32987 int res1 = 0 ;
32988 PyObject *swig_obj[1] ;
32989
32990 if (!args) SWIG_fail;
32991 swig_obj[0] = args;
32992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32993 if (!SWIG_IsOK(res1)) {
32994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32995 }
32996 arg1 = reinterpret_cast< wxWindow * >(argp1);
32997 {
32998 PyThreadState* __tstate = wxPyBeginAllowThreads();
32999 result = (int)((wxWindow const *)arg1)->GetMinHeight();
33000 wxPyEndAllowThreads(__tstate);
33001 if (PyErr_Occurred()) SWIG_fail;
33002 }
33003 resultobj = SWIG_From_int(static_cast< int >(result));
33004 return resultobj;
33005 fail:
33006 return NULL;
33007 }
33008
33009
33010 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33011 PyObject *resultobj = 0;
33012 wxWindow *arg1 = (wxWindow *) 0 ;
33013 int result;
33014 void *argp1 = 0 ;
33015 int res1 = 0 ;
33016 PyObject *swig_obj[1] ;
33017
33018 if (!args) SWIG_fail;
33019 swig_obj[0] = args;
33020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33021 if (!SWIG_IsOK(res1)) {
33022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33023 }
33024 arg1 = reinterpret_cast< wxWindow * >(argp1);
33025 {
33026 PyThreadState* __tstate = wxPyBeginAllowThreads();
33027 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33028 wxPyEndAllowThreads(__tstate);
33029 if (PyErr_Occurred()) SWIG_fail;
33030 }
33031 resultobj = SWIG_From_int(static_cast< int >(result));
33032 return resultobj;
33033 fail:
33034 return NULL;
33035 }
33036
33037
33038 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33039 PyObject *resultobj = 0;
33040 wxWindow *arg1 = (wxWindow *) 0 ;
33041 int result;
33042 void *argp1 = 0 ;
33043 int res1 = 0 ;
33044 PyObject *swig_obj[1] ;
33045
33046 if (!args) SWIG_fail;
33047 swig_obj[0] = args;
33048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33049 if (!SWIG_IsOK(res1)) {
33050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33051 }
33052 arg1 = reinterpret_cast< wxWindow * >(argp1);
33053 {
33054 PyThreadState* __tstate = wxPyBeginAllowThreads();
33055 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33056 wxPyEndAllowThreads(__tstate);
33057 if (PyErr_Occurred()) SWIG_fail;
33058 }
33059 resultobj = SWIG_From_int(static_cast< int >(result));
33060 return resultobj;
33061 fail:
33062 return NULL;
33063 }
33064
33065
33066 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33067 PyObject *resultobj = 0;
33068 wxWindow *arg1 = (wxWindow *) 0 ;
33069 wxSize *arg2 = 0 ;
33070 void *argp1 = 0 ;
33071 int res1 = 0 ;
33072 wxSize temp2 ;
33073 PyObject * obj0 = 0 ;
33074 PyObject * obj1 = 0 ;
33075 char * kwnames[] = {
33076 (char *) "self",(char *) "size", NULL
33077 };
33078
33079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33081 if (!SWIG_IsOK(res1)) {
33082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33083 }
33084 arg1 = reinterpret_cast< wxWindow * >(argp1);
33085 {
33086 arg2 = &temp2;
33087 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33088 }
33089 {
33090 PyThreadState* __tstate = wxPyBeginAllowThreads();
33091 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33092 wxPyEndAllowThreads(__tstate);
33093 if (PyErr_Occurred()) SWIG_fail;
33094 }
33095 resultobj = SWIG_Py_Void();
33096 return resultobj;
33097 fail:
33098 return NULL;
33099 }
33100
33101
33102 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33103 PyObject *resultobj = 0;
33104 wxWindow *arg1 = (wxWindow *) 0 ;
33105 int arg2 ;
33106 int arg3 ;
33107 void *argp1 = 0 ;
33108 int res1 = 0 ;
33109 int val2 ;
33110 int ecode2 = 0 ;
33111 int val3 ;
33112 int ecode3 = 0 ;
33113 PyObject * obj0 = 0 ;
33114 PyObject * obj1 = 0 ;
33115 PyObject * obj2 = 0 ;
33116 char * kwnames[] = {
33117 (char *) "self",(char *) "w",(char *) "h", NULL
33118 };
33119
33120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33122 if (!SWIG_IsOK(res1)) {
33123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33124 }
33125 arg1 = reinterpret_cast< wxWindow * >(argp1);
33126 ecode2 = SWIG_AsVal_int(obj1, &val2);
33127 if (!SWIG_IsOK(ecode2)) {
33128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33129 }
33130 arg2 = static_cast< int >(val2);
33131 ecode3 = SWIG_AsVal_int(obj2, &val3);
33132 if (!SWIG_IsOK(ecode3)) {
33133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33134 }
33135 arg3 = static_cast< int >(val3);
33136 {
33137 PyThreadState* __tstate = wxPyBeginAllowThreads();
33138 (arg1)->SetVirtualSize(arg2,arg3);
33139 wxPyEndAllowThreads(__tstate);
33140 if (PyErr_Occurred()) SWIG_fail;
33141 }
33142 resultobj = SWIG_Py_Void();
33143 return resultobj;
33144 fail:
33145 return NULL;
33146 }
33147
33148
33149 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33150 PyObject *resultobj = 0;
33151 wxWindow *arg1 = (wxWindow *) 0 ;
33152 wxSize result;
33153 void *argp1 = 0 ;
33154 int res1 = 0 ;
33155 PyObject *swig_obj[1] ;
33156
33157 if (!args) SWIG_fail;
33158 swig_obj[0] = args;
33159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33160 if (!SWIG_IsOK(res1)) {
33161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33162 }
33163 arg1 = reinterpret_cast< wxWindow * >(argp1);
33164 {
33165 PyThreadState* __tstate = wxPyBeginAllowThreads();
33166 result = ((wxWindow const *)arg1)->GetVirtualSize();
33167 wxPyEndAllowThreads(__tstate);
33168 if (PyErr_Occurred()) SWIG_fail;
33169 }
33170 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33171 return resultobj;
33172 fail:
33173 return NULL;
33174 }
33175
33176
33177 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33178 PyObject *resultobj = 0;
33179 wxWindow *arg1 = (wxWindow *) 0 ;
33180 int *arg2 = (int *) 0 ;
33181 int *arg3 = (int *) 0 ;
33182 void *argp1 = 0 ;
33183 int res1 = 0 ;
33184 int temp2 ;
33185 int res2 = SWIG_TMPOBJ ;
33186 int temp3 ;
33187 int res3 = SWIG_TMPOBJ ;
33188 PyObject *swig_obj[1] ;
33189
33190 arg2 = &temp2;
33191 arg3 = &temp3;
33192 if (!args) SWIG_fail;
33193 swig_obj[0] = args;
33194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33195 if (!SWIG_IsOK(res1)) {
33196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33197 }
33198 arg1 = reinterpret_cast< wxWindow * >(argp1);
33199 {
33200 PyThreadState* __tstate = wxPyBeginAllowThreads();
33201 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33202 wxPyEndAllowThreads(__tstate);
33203 if (PyErr_Occurred()) SWIG_fail;
33204 }
33205 resultobj = SWIG_Py_Void();
33206 if (SWIG_IsTmpObj(res2)) {
33207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33208 } else {
33209 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33211 }
33212 if (SWIG_IsTmpObj(res3)) {
33213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33214 } else {
33215 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33217 }
33218 return resultobj;
33219 fail:
33220 return NULL;
33221 }
33222
33223
33224 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33225 PyObject *resultobj = 0;
33226 wxWindow *arg1 = (wxWindow *) 0 ;
33227 wxSize result;
33228 void *argp1 = 0 ;
33229 int res1 = 0 ;
33230 PyObject *swig_obj[1] ;
33231
33232 if (!args) SWIG_fail;
33233 swig_obj[0] = args;
33234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33235 if (!SWIG_IsOK(res1)) {
33236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33237 }
33238 arg1 = reinterpret_cast< wxWindow * >(argp1);
33239 {
33240 PyThreadState* __tstate = wxPyBeginAllowThreads();
33241 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33242 wxPyEndAllowThreads(__tstate);
33243 if (PyErr_Occurred()) SWIG_fail;
33244 }
33245 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33246 return resultobj;
33247 fail:
33248 return NULL;
33249 }
33250
33251
33252 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33253 PyObject *resultobj = 0;
33254 wxWindow *arg1 = (wxWindow *) 0 ;
33255 bool arg2 = (bool) true ;
33256 bool result;
33257 void *argp1 = 0 ;
33258 int res1 = 0 ;
33259 bool val2 ;
33260 int ecode2 = 0 ;
33261 PyObject * obj0 = 0 ;
33262 PyObject * obj1 = 0 ;
33263 char * kwnames[] = {
33264 (char *) "self",(char *) "show", NULL
33265 };
33266
33267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33269 if (!SWIG_IsOK(res1)) {
33270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33271 }
33272 arg1 = reinterpret_cast< wxWindow * >(argp1);
33273 if (obj1) {
33274 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33275 if (!SWIG_IsOK(ecode2)) {
33276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33277 }
33278 arg2 = static_cast< bool >(val2);
33279 }
33280 {
33281 PyThreadState* __tstate = wxPyBeginAllowThreads();
33282 result = (bool)(arg1)->Show(arg2);
33283 wxPyEndAllowThreads(__tstate);
33284 if (PyErr_Occurred()) SWIG_fail;
33285 }
33286 {
33287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33288 }
33289 return resultobj;
33290 fail:
33291 return NULL;
33292 }
33293
33294
33295 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33296 PyObject *resultobj = 0;
33297 wxWindow *arg1 = (wxWindow *) 0 ;
33298 bool result;
33299 void *argp1 = 0 ;
33300 int res1 = 0 ;
33301 PyObject *swig_obj[1] ;
33302
33303 if (!args) SWIG_fail;
33304 swig_obj[0] = args;
33305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33306 if (!SWIG_IsOK(res1)) {
33307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33308 }
33309 arg1 = reinterpret_cast< wxWindow * >(argp1);
33310 {
33311 PyThreadState* __tstate = wxPyBeginAllowThreads();
33312 result = (bool)(arg1)->Hide();
33313 wxPyEndAllowThreads(__tstate);
33314 if (PyErr_Occurred()) SWIG_fail;
33315 }
33316 {
33317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33318 }
33319 return resultobj;
33320 fail:
33321 return NULL;
33322 }
33323
33324
33325 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33326 PyObject *resultobj = 0;
33327 wxWindow *arg1 = (wxWindow *) 0 ;
33328 bool arg2 = (bool) true ;
33329 bool result;
33330 void *argp1 = 0 ;
33331 int res1 = 0 ;
33332 bool val2 ;
33333 int ecode2 = 0 ;
33334 PyObject * obj0 = 0 ;
33335 PyObject * obj1 = 0 ;
33336 char * kwnames[] = {
33337 (char *) "self",(char *) "enable", NULL
33338 };
33339
33340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33342 if (!SWIG_IsOK(res1)) {
33343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33344 }
33345 arg1 = reinterpret_cast< wxWindow * >(argp1);
33346 if (obj1) {
33347 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33348 if (!SWIG_IsOK(ecode2)) {
33349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33350 }
33351 arg2 = static_cast< bool >(val2);
33352 }
33353 {
33354 PyThreadState* __tstate = wxPyBeginAllowThreads();
33355 result = (bool)(arg1)->Enable(arg2);
33356 wxPyEndAllowThreads(__tstate);
33357 if (PyErr_Occurred()) SWIG_fail;
33358 }
33359 {
33360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33361 }
33362 return resultobj;
33363 fail:
33364 return NULL;
33365 }
33366
33367
33368 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33369 PyObject *resultobj = 0;
33370 wxWindow *arg1 = (wxWindow *) 0 ;
33371 bool result;
33372 void *argp1 = 0 ;
33373 int res1 = 0 ;
33374 PyObject *swig_obj[1] ;
33375
33376 if (!args) SWIG_fail;
33377 swig_obj[0] = args;
33378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33379 if (!SWIG_IsOK(res1)) {
33380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33381 }
33382 arg1 = reinterpret_cast< wxWindow * >(argp1);
33383 {
33384 PyThreadState* __tstate = wxPyBeginAllowThreads();
33385 result = (bool)(arg1)->Disable();
33386 wxPyEndAllowThreads(__tstate);
33387 if (PyErr_Occurred()) SWIG_fail;
33388 }
33389 {
33390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33391 }
33392 return resultobj;
33393 fail:
33394 return NULL;
33395 }
33396
33397
33398 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33399 PyObject *resultobj = 0;
33400 wxWindow *arg1 = (wxWindow *) 0 ;
33401 bool result;
33402 void *argp1 = 0 ;
33403 int res1 = 0 ;
33404 PyObject *swig_obj[1] ;
33405
33406 if (!args) SWIG_fail;
33407 swig_obj[0] = args;
33408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33409 if (!SWIG_IsOK(res1)) {
33410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33411 }
33412 arg1 = reinterpret_cast< wxWindow * >(argp1);
33413 {
33414 PyThreadState* __tstate = wxPyBeginAllowThreads();
33415 result = (bool)((wxWindow const *)arg1)->IsShown();
33416 wxPyEndAllowThreads(__tstate);
33417 if (PyErr_Occurred()) SWIG_fail;
33418 }
33419 {
33420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33421 }
33422 return resultobj;
33423 fail:
33424 return NULL;
33425 }
33426
33427
33428 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33429 PyObject *resultobj = 0;
33430 wxWindow *arg1 = (wxWindow *) 0 ;
33431 bool result;
33432 void *argp1 = 0 ;
33433 int res1 = 0 ;
33434 PyObject *swig_obj[1] ;
33435
33436 if (!args) SWIG_fail;
33437 swig_obj[0] = args;
33438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33439 if (!SWIG_IsOK(res1)) {
33440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33441 }
33442 arg1 = reinterpret_cast< wxWindow * >(argp1);
33443 {
33444 PyThreadState* __tstate = wxPyBeginAllowThreads();
33445 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33446 wxPyEndAllowThreads(__tstate);
33447 if (PyErr_Occurred()) SWIG_fail;
33448 }
33449 {
33450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33451 }
33452 return resultobj;
33453 fail:
33454 return NULL;
33455 }
33456
33457
33458 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33459 PyObject *resultobj = 0;
33460 wxWindow *arg1 = (wxWindow *) 0 ;
33461 bool result;
33462 void *argp1 = 0 ;
33463 int res1 = 0 ;
33464 PyObject *swig_obj[1] ;
33465
33466 if (!args) SWIG_fail;
33467 swig_obj[0] = args;
33468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33469 if (!SWIG_IsOK(res1)) {
33470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33471 }
33472 arg1 = reinterpret_cast< wxWindow * >(argp1);
33473 {
33474 PyThreadState* __tstate = wxPyBeginAllowThreads();
33475 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33476 wxPyEndAllowThreads(__tstate);
33477 if (PyErr_Occurred()) SWIG_fail;
33478 }
33479 {
33480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33481 }
33482 return resultobj;
33483 fail:
33484 return NULL;
33485 }
33486
33487
33488 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33489 PyObject *resultobj = 0;
33490 wxWindow *arg1 = (wxWindow *) 0 ;
33491 long arg2 ;
33492 void *argp1 = 0 ;
33493 int res1 = 0 ;
33494 long val2 ;
33495 int ecode2 = 0 ;
33496 PyObject * obj0 = 0 ;
33497 PyObject * obj1 = 0 ;
33498 char * kwnames[] = {
33499 (char *) "self",(char *) "style", NULL
33500 };
33501
33502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33504 if (!SWIG_IsOK(res1)) {
33505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33506 }
33507 arg1 = reinterpret_cast< wxWindow * >(argp1);
33508 ecode2 = SWIG_AsVal_long(obj1, &val2);
33509 if (!SWIG_IsOK(ecode2)) {
33510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33511 }
33512 arg2 = static_cast< long >(val2);
33513 {
33514 PyThreadState* __tstate = wxPyBeginAllowThreads();
33515 (arg1)->SetWindowStyleFlag(arg2);
33516 wxPyEndAllowThreads(__tstate);
33517 if (PyErr_Occurred()) SWIG_fail;
33518 }
33519 resultobj = SWIG_Py_Void();
33520 return resultobj;
33521 fail:
33522 return NULL;
33523 }
33524
33525
33526 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33527 PyObject *resultobj = 0;
33528 wxWindow *arg1 = (wxWindow *) 0 ;
33529 long result;
33530 void *argp1 = 0 ;
33531 int res1 = 0 ;
33532 PyObject *swig_obj[1] ;
33533
33534 if (!args) SWIG_fail;
33535 swig_obj[0] = args;
33536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33537 if (!SWIG_IsOK(res1)) {
33538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33539 }
33540 arg1 = reinterpret_cast< wxWindow * >(argp1);
33541 {
33542 PyThreadState* __tstate = wxPyBeginAllowThreads();
33543 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33544 wxPyEndAllowThreads(__tstate);
33545 if (PyErr_Occurred()) SWIG_fail;
33546 }
33547 resultobj = SWIG_From_long(static_cast< long >(result));
33548 return resultobj;
33549 fail:
33550 return NULL;
33551 }
33552
33553
33554 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33555 PyObject *resultobj = 0;
33556 wxWindow *arg1 = (wxWindow *) 0 ;
33557 int arg2 ;
33558 bool result;
33559 void *argp1 = 0 ;
33560 int res1 = 0 ;
33561 int val2 ;
33562 int ecode2 = 0 ;
33563 PyObject * obj0 = 0 ;
33564 PyObject * obj1 = 0 ;
33565 char * kwnames[] = {
33566 (char *) "self",(char *) "flag", NULL
33567 };
33568
33569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33571 if (!SWIG_IsOK(res1)) {
33572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33573 }
33574 arg1 = reinterpret_cast< wxWindow * >(argp1);
33575 ecode2 = SWIG_AsVal_int(obj1, &val2);
33576 if (!SWIG_IsOK(ecode2)) {
33577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33578 }
33579 arg2 = static_cast< int >(val2);
33580 {
33581 PyThreadState* __tstate = wxPyBeginAllowThreads();
33582 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33583 wxPyEndAllowThreads(__tstate);
33584 if (PyErr_Occurred()) SWIG_fail;
33585 }
33586 {
33587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33588 }
33589 return resultobj;
33590 fail:
33591 return NULL;
33592 }
33593
33594
33595 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33596 PyObject *resultobj = 0;
33597 wxWindow *arg1 = (wxWindow *) 0 ;
33598 bool result;
33599 void *argp1 = 0 ;
33600 int res1 = 0 ;
33601 PyObject *swig_obj[1] ;
33602
33603 if (!args) SWIG_fail;
33604 swig_obj[0] = args;
33605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33606 if (!SWIG_IsOK(res1)) {
33607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33608 }
33609 arg1 = reinterpret_cast< wxWindow * >(argp1);
33610 {
33611 PyThreadState* __tstate = wxPyBeginAllowThreads();
33612 result = (bool)((wxWindow const *)arg1)->IsRetained();
33613 wxPyEndAllowThreads(__tstate);
33614 if (PyErr_Occurred()) SWIG_fail;
33615 }
33616 {
33617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33618 }
33619 return resultobj;
33620 fail:
33621 return NULL;
33622 }
33623
33624
33625 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33626 PyObject *resultobj = 0;
33627 wxWindow *arg1 = (wxWindow *) 0 ;
33628 long arg2 ;
33629 void *argp1 = 0 ;
33630 int res1 = 0 ;
33631 long val2 ;
33632 int ecode2 = 0 ;
33633 PyObject * obj0 = 0 ;
33634 PyObject * obj1 = 0 ;
33635 char * kwnames[] = {
33636 (char *) "self",(char *) "exStyle", NULL
33637 };
33638
33639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33641 if (!SWIG_IsOK(res1)) {
33642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33643 }
33644 arg1 = reinterpret_cast< wxWindow * >(argp1);
33645 ecode2 = SWIG_AsVal_long(obj1, &val2);
33646 if (!SWIG_IsOK(ecode2)) {
33647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33648 }
33649 arg2 = static_cast< long >(val2);
33650 {
33651 PyThreadState* __tstate = wxPyBeginAllowThreads();
33652 (arg1)->SetExtraStyle(arg2);
33653 wxPyEndAllowThreads(__tstate);
33654 if (PyErr_Occurred()) SWIG_fail;
33655 }
33656 resultobj = SWIG_Py_Void();
33657 return resultobj;
33658 fail:
33659 return NULL;
33660 }
33661
33662
33663 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33664 PyObject *resultobj = 0;
33665 wxWindow *arg1 = (wxWindow *) 0 ;
33666 long result;
33667 void *argp1 = 0 ;
33668 int res1 = 0 ;
33669 PyObject *swig_obj[1] ;
33670
33671 if (!args) SWIG_fail;
33672 swig_obj[0] = args;
33673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33674 if (!SWIG_IsOK(res1)) {
33675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33676 }
33677 arg1 = reinterpret_cast< wxWindow * >(argp1);
33678 {
33679 PyThreadState* __tstate = wxPyBeginAllowThreads();
33680 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33681 wxPyEndAllowThreads(__tstate);
33682 if (PyErr_Occurred()) SWIG_fail;
33683 }
33684 resultobj = SWIG_From_long(static_cast< long >(result));
33685 return resultobj;
33686 fail:
33687 return NULL;
33688 }
33689
33690
33691 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33692 PyObject *resultobj = 0;
33693 wxWindow *arg1 = (wxWindow *) 0 ;
33694 bool arg2 = (bool) true ;
33695 void *argp1 = 0 ;
33696 int res1 = 0 ;
33697 bool val2 ;
33698 int ecode2 = 0 ;
33699 PyObject * obj0 = 0 ;
33700 PyObject * obj1 = 0 ;
33701 char * kwnames[] = {
33702 (char *) "self",(char *) "modal", NULL
33703 };
33704
33705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33707 if (!SWIG_IsOK(res1)) {
33708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33709 }
33710 arg1 = reinterpret_cast< wxWindow * >(argp1);
33711 if (obj1) {
33712 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33713 if (!SWIG_IsOK(ecode2)) {
33714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33715 }
33716 arg2 = static_cast< bool >(val2);
33717 }
33718 {
33719 PyThreadState* __tstate = wxPyBeginAllowThreads();
33720 (arg1)->MakeModal(arg2);
33721 wxPyEndAllowThreads(__tstate);
33722 if (PyErr_Occurred()) SWIG_fail;
33723 }
33724 resultobj = SWIG_Py_Void();
33725 return resultobj;
33726 fail:
33727 return NULL;
33728 }
33729
33730
33731 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33732 PyObject *resultobj = 0;
33733 wxWindow *arg1 = (wxWindow *) 0 ;
33734 bool arg2 ;
33735 void *argp1 = 0 ;
33736 int res1 = 0 ;
33737 bool val2 ;
33738 int ecode2 = 0 ;
33739 PyObject * obj0 = 0 ;
33740 PyObject * obj1 = 0 ;
33741 char * kwnames[] = {
33742 (char *) "self",(char *) "enableTheme", NULL
33743 };
33744
33745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33747 if (!SWIG_IsOK(res1)) {
33748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33749 }
33750 arg1 = reinterpret_cast< wxWindow * >(argp1);
33751 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33752 if (!SWIG_IsOK(ecode2)) {
33753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33754 }
33755 arg2 = static_cast< bool >(val2);
33756 {
33757 PyThreadState* __tstate = wxPyBeginAllowThreads();
33758 (arg1)->SetThemeEnabled(arg2);
33759 wxPyEndAllowThreads(__tstate);
33760 if (PyErr_Occurred()) SWIG_fail;
33761 }
33762 resultobj = SWIG_Py_Void();
33763 return resultobj;
33764 fail:
33765 return NULL;
33766 }
33767
33768
33769 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33770 PyObject *resultobj = 0;
33771 wxWindow *arg1 = (wxWindow *) 0 ;
33772 bool result;
33773 void *argp1 = 0 ;
33774 int res1 = 0 ;
33775 PyObject *swig_obj[1] ;
33776
33777 if (!args) SWIG_fail;
33778 swig_obj[0] = args;
33779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33780 if (!SWIG_IsOK(res1)) {
33781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33782 }
33783 arg1 = reinterpret_cast< wxWindow * >(argp1);
33784 {
33785 PyThreadState* __tstate = wxPyBeginAllowThreads();
33786 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33787 wxPyEndAllowThreads(__tstate);
33788 if (PyErr_Occurred()) SWIG_fail;
33789 }
33790 {
33791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33792 }
33793 return resultobj;
33794 fail:
33795 return NULL;
33796 }
33797
33798
33799 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33800 PyObject *resultobj = 0;
33801 wxWindow *arg1 = (wxWindow *) 0 ;
33802 void *argp1 = 0 ;
33803 int res1 = 0 ;
33804 PyObject *swig_obj[1] ;
33805
33806 if (!args) SWIG_fail;
33807 swig_obj[0] = args;
33808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33809 if (!SWIG_IsOK(res1)) {
33810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33811 }
33812 arg1 = reinterpret_cast< wxWindow * >(argp1);
33813 {
33814 PyThreadState* __tstate = wxPyBeginAllowThreads();
33815 (arg1)->SetFocus();
33816 wxPyEndAllowThreads(__tstate);
33817 if (PyErr_Occurred()) SWIG_fail;
33818 }
33819 resultobj = SWIG_Py_Void();
33820 return resultobj;
33821 fail:
33822 return NULL;
33823 }
33824
33825
33826 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33827 PyObject *resultobj = 0;
33828 wxWindow *arg1 = (wxWindow *) 0 ;
33829 void *argp1 = 0 ;
33830 int res1 = 0 ;
33831 PyObject *swig_obj[1] ;
33832
33833 if (!args) SWIG_fail;
33834 swig_obj[0] = args;
33835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33836 if (!SWIG_IsOK(res1)) {
33837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33838 }
33839 arg1 = reinterpret_cast< wxWindow * >(argp1);
33840 {
33841 PyThreadState* __tstate = wxPyBeginAllowThreads();
33842 (arg1)->SetFocusFromKbd();
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 resultobj = SWIG_Py_Void();
33847 return resultobj;
33848 fail:
33849 return NULL;
33850 }
33851
33852
33853 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33854 PyObject *resultobj = 0;
33855 wxWindow *result = 0 ;
33856
33857 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33858 {
33859 if (!wxPyCheckForApp()) SWIG_fail;
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 result = (wxWindow *)wxWindow::FindFocus();
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 {
33866 resultobj = wxPyMake_wxObject(result, 0);
33867 }
33868 return resultobj;
33869 fail:
33870 return NULL;
33871 }
33872
33873
33874 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33875 PyObject *resultobj = 0;
33876 wxWindow *arg1 = (wxWindow *) 0 ;
33877 bool result;
33878 void *argp1 = 0 ;
33879 int res1 = 0 ;
33880 PyObject *swig_obj[1] ;
33881
33882 if (!args) SWIG_fail;
33883 swig_obj[0] = args;
33884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33885 if (!SWIG_IsOK(res1)) {
33886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33887 }
33888 arg1 = reinterpret_cast< wxWindow * >(argp1);
33889 {
33890 PyThreadState* __tstate = wxPyBeginAllowThreads();
33891 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33892 wxPyEndAllowThreads(__tstate);
33893 if (PyErr_Occurred()) SWIG_fail;
33894 }
33895 {
33896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33897 }
33898 return resultobj;
33899 fail:
33900 return NULL;
33901 }
33902
33903
33904 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33905 PyObject *resultobj = 0;
33906 wxWindow *arg1 = (wxWindow *) 0 ;
33907 bool result;
33908 void *argp1 = 0 ;
33909 int res1 = 0 ;
33910 PyObject *swig_obj[1] ;
33911
33912 if (!args) SWIG_fail;
33913 swig_obj[0] = args;
33914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33915 if (!SWIG_IsOK(res1)) {
33916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33917 }
33918 arg1 = reinterpret_cast< wxWindow * >(argp1);
33919 {
33920 PyThreadState* __tstate = wxPyBeginAllowThreads();
33921 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33922 wxPyEndAllowThreads(__tstate);
33923 if (PyErr_Occurred()) SWIG_fail;
33924 }
33925 {
33926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33927 }
33928 return resultobj;
33929 fail:
33930 return NULL;
33931 }
33932
33933
33934 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33935 PyObject *resultobj = 0;
33936 wxWindow *arg1 = (wxWindow *) 0 ;
33937 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33938 bool result;
33939 void *argp1 = 0 ;
33940 int res1 = 0 ;
33941 int val2 ;
33942 int ecode2 = 0 ;
33943 PyObject * obj0 = 0 ;
33944 PyObject * obj1 = 0 ;
33945 char * kwnames[] = {
33946 (char *) "self",(char *) "flags", NULL
33947 };
33948
33949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33951 if (!SWIG_IsOK(res1)) {
33952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33953 }
33954 arg1 = reinterpret_cast< wxWindow * >(argp1);
33955 if (obj1) {
33956 ecode2 = SWIG_AsVal_int(obj1, &val2);
33957 if (!SWIG_IsOK(ecode2)) {
33958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33959 }
33960 arg2 = static_cast< int >(val2);
33961 }
33962 {
33963 PyThreadState* __tstate = wxPyBeginAllowThreads();
33964 result = (bool)(arg1)->Navigate(arg2);
33965 wxPyEndAllowThreads(__tstate);
33966 if (PyErr_Occurred()) SWIG_fail;
33967 }
33968 {
33969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33970 }
33971 return resultobj;
33972 fail:
33973 return NULL;
33974 }
33975
33976
33977 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33978 PyObject *resultobj = 0;
33979 wxWindow *arg1 = (wxWindow *) 0 ;
33980 wxWindow *arg2 = (wxWindow *) 0 ;
33981 void *argp1 = 0 ;
33982 int res1 = 0 ;
33983 void *argp2 = 0 ;
33984 int res2 = 0 ;
33985 PyObject * obj0 = 0 ;
33986 PyObject * obj1 = 0 ;
33987 char * kwnames[] = {
33988 (char *) "self",(char *) "win", NULL
33989 };
33990
33991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33993 if (!SWIG_IsOK(res1)) {
33994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33995 }
33996 arg1 = reinterpret_cast< wxWindow * >(argp1);
33997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33998 if (!SWIG_IsOK(res2)) {
33999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34000 }
34001 arg2 = reinterpret_cast< wxWindow * >(argp2);
34002 {
34003 PyThreadState* __tstate = wxPyBeginAllowThreads();
34004 (arg1)->MoveAfterInTabOrder(arg2);
34005 wxPyEndAllowThreads(__tstate);
34006 if (PyErr_Occurred()) SWIG_fail;
34007 }
34008 resultobj = SWIG_Py_Void();
34009 return resultobj;
34010 fail:
34011 return NULL;
34012 }
34013
34014
34015 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34016 PyObject *resultobj = 0;
34017 wxWindow *arg1 = (wxWindow *) 0 ;
34018 wxWindow *arg2 = (wxWindow *) 0 ;
34019 void *argp1 = 0 ;
34020 int res1 = 0 ;
34021 void *argp2 = 0 ;
34022 int res2 = 0 ;
34023 PyObject * obj0 = 0 ;
34024 PyObject * obj1 = 0 ;
34025 char * kwnames[] = {
34026 (char *) "self",(char *) "win", NULL
34027 };
34028
34029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34031 if (!SWIG_IsOK(res1)) {
34032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34033 }
34034 arg1 = reinterpret_cast< wxWindow * >(argp1);
34035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34036 if (!SWIG_IsOK(res2)) {
34037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34038 }
34039 arg2 = reinterpret_cast< wxWindow * >(argp2);
34040 {
34041 PyThreadState* __tstate = wxPyBeginAllowThreads();
34042 (arg1)->MoveBeforeInTabOrder(arg2);
34043 wxPyEndAllowThreads(__tstate);
34044 if (PyErr_Occurred()) SWIG_fail;
34045 }
34046 resultobj = SWIG_Py_Void();
34047 return resultobj;
34048 fail:
34049 return NULL;
34050 }
34051
34052
34053 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34054 PyObject *resultobj = 0;
34055 wxWindow *arg1 = (wxWindow *) 0 ;
34056 PyObject *result = 0 ;
34057 void *argp1 = 0 ;
34058 int res1 = 0 ;
34059 PyObject *swig_obj[1] ;
34060
34061 if (!args) SWIG_fail;
34062 swig_obj[0] = args;
34063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34064 if (!SWIG_IsOK(res1)) {
34065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34066 }
34067 arg1 = reinterpret_cast< wxWindow * >(argp1);
34068 {
34069 PyThreadState* __tstate = wxPyBeginAllowThreads();
34070 result = (PyObject *)wxWindow_GetChildren(arg1);
34071 wxPyEndAllowThreads(__tstate);
34072 if (PyErr_Occurred()) SWIG_fail;
34073 }
34074 resultobj = result;
34075 return resultobj;
34076 fail:
34077 return NULL;
34078 }
34079
34080
34081 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34082 PyObject *resultobj = 0;
34083 wxWindow *arg1 = (wxWindow *) 0 ;
34084 wxWindow *result = 0 ;
34085 void *argp1 = 0 ;
34086 int res1 = 0 ;
34087 PyObject *swig_obj[1] ;
34088
34089 if (!args) SWIG_fail;
34090 swig_obj[0] = args;
34091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34092 if (!SWIG_IsOK(res1)) {
34093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34094 }
34095 arg1 = reinterpret_cast< wxWindow * >(argp1);
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34099 wxPyEndAllowThreads(__tstate);
34100 if (PyErr_Occurred()) SWIG_fail;
34101 }
34102 {
34103 resultobj = wxPyMake_wxObject(result, 0);
34104 }
34105 return resultobj;
34106 fail:
34107 return NULL;
34108 }
34109
34110
34111 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34112 PyObject *resultobj = 0;
34113 wxWindow *arg1 = (wxWindow *) 0 ;
34114 wxWindow *result = 0 ;
34115 void *argp1 = 0 ;
34116 int res1 = 0 ;
34117 PyObject *swig_obj[1] ;
34118
34119 if (!args) SWIG_fail;
34120 swig_obj[0] = args;
34121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34122 if (!SWIG_IsOK(res1)) {
34123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34124 }
34125 arg1 = reinterpret_cast< wxWindow * >(argp1);
34126 {
34127 PyThreadState* __tstate = wxPyBeginAllowThreads();
34128 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34129 wxPyEndAllowThreads(__tstate);
34130 if (PyErr_Occurred()) SWIG_fail;
34131 }
34132 {
34133 resultobj = wxPyMake_wxObject(result, 0);
34134 }
34135 return resultobj;
34136 fail:
34137 return NULL;
34138 }
34139
34140
34141 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34142 PyObject *resultobj = 0;
34143 wxWindow *arg1 = (wxWindow *) 0 ;
34144 bool result;
34145 void *argp1 = 0 ;
34146 int res1 = 0 ;
34147 PyObject *swig_obj[1] ;
34148
34149 if (!args) SWIG_fail;
34150 swig_obj[0] = args;
34151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34152 if (!SWIG_IsOK(res1)) {
34153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34154 }
34155 arg1 = reinterpret_cast< wxWindow * >(argp1);
34156 {
34157 PyThreadState* __tstate = wxPyBeginAllowThreads();
34158 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34159 wxPyEndAllowThreads(__tstate);
34160 if (PyErr_Occurred()) SWIG_fail;
34161 }
34162 {
34163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34164 }
34165 return resultobj;
34166 fail:
34167 return NULL;
34168 }
34169
34170
34171 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34172 PyObject *resultobj = 0;
34173 wxWindow *arg1 = (wxWindow *) 0 ;
34174 wxWindow *arg2 = (wxWindow *) 0 ;
34175 bool result;
34176 void *argp1 = 0 ;
34177 int res1 = 0 ;
34178 void *argp2 = 0 ;
34179 int res2 = 0 ;
34180 PyObject * obj0 = 0 ;
34181 PyObject * obj1 = 0 ;
34182 char * kwnames[] = {
34183 (char *) "self",(char *) "newParent", NULL
34184 };
34185
34186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34188 if (!SWIG_IsOK(res1)) {
34189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34190 }
34191 arg1 = reinterpret_cast< wxWindow * >(argp1);
34192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34193 if (!SWIG_IsOK(res2)) {
34194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34195 }
34196 arg2 = reinterpret_cast< wxWindow * >(argp2);
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 result = (bool)(arg1)->Reparent(arg2);
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 {
34204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34205 }
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34213 PyObject *resultobj = 0;
34214 wxWindow *arg1 = (wxWindow *) 0 ;
34215 wxWindow *arg2 = (wxWindow *) 0 ;
34216 void *argp1 = 0 ;
34217 int res1 = 0 ;
34218 void *argp2 = 0 ;
34219 int res2 = 0 ;
34220 PyObject * obj0 = 0 ;
34221 PyObject * obj1 = 0 ;
34222 char * kwnames[] = {
34223 (char *) "self",(char *) "child", NULL
34224 };
34225
34226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34228 if (!SWIG_IsOK(res1)) {
34229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34230 }
34231 arg1 = reinterpret_cast< wxWindow * >(argp1);
34232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34233 if (!SWIG_IsOK(res2)) {
34234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34235 }
34236 arg2 = reinterpret_cast< wxWindow * >(argp2);
34237 {
34238 PyThreadState* __tstate = wxPyBeginAllowThreads();
34239 (arg1)->AddChild(arg2);
34240 wxPyEndAllowThreads(__tstate);
34241 if (PyErr_Occurred()) SWIG_fail;
34242 }
34243 resultobj = SWIG_Py_Void();
34244 return resultobj;
34245 fail:
34246 return NULL;
34247 }
34248
34249
34250 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34251 PyObject *resultobj = 0;
34252 wxWindow *arg1 = (wxWindow *) 0 ;
34253 wxWindow *arg2 = (wxWindow *) 0 ;
34254 void *argp1 = 0 ;
34255 int res1 = 0 ;
34256 void *argp2 = 0 ;
34257 int res2 = 0 ;
34258 PyObject * obj0 = 0 ;
34259 PyObject * obj1 = 0 ;
34260 char * kwnames[] = {
34261 (char *) "self",(char *) "child", NULL
34262 };
34263
34264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34266 if (!SWIG_IsOK(res1)) {
34267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34268 }
34269 arg1 = reinterpret_cast< wxWindow * >(argp1);
34270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34271 if (!SWIG_IsOK(res2)) {
34272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34273 }
34274 arg2 = reinterpret_cast< wxWindow * >(argp2);
34275 {
34276 PyThreadState* __tstate = wxPyBeginAllowThreads();
34277 (arg1)->RemoveChild(arg2);
34278 wxPyEndAllowThreads(__tstate);
34279 if (PyErr_Occurred()) SWIG_fail;
34280 }
34281 resultobj = SWIG_Py_Void();
34282 return resultobj;
34283 fail:
34284 return NULL;
34285 }
34286
34287
34288 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34289 PyObject *resultobj = 0;
34290 wxWindow *arg1 = (wxWindow *) 0 ;
34291 bool arg2 ;
34292 void *argp1 = 0 ;
34293 int res1 = 0 ;
34294 bool val2 ;
34295 int ecode2 = 0 ;
34296 PyObject * obj0 = 0 ;
34297 PyObject * obj1 = 0 ;
34298 char * kwnames[] = {
34299 (char *) "self",(char *) "on", NULL
34300 };
34301
34302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34304 if (!SWIG_IsOK(res1)) {
34305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34306 }
34307 arg1 = reinterpret_cast< wxWindow * >(argp1);
34308 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34309 if (!SWIG_IsOK(ecode2)) {
34310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34311 }
34312 arg2 = static_cast< bool >(val2);
34313 {
34314 PyThreadState* __tstate = wxPyBeginAllowThreads();
34315 (arg1)->SetDoubleBuffered(arg2);
34316 wxPyEndAllowThreads(__tstate);
34317 if (PyErr_Occurred()) SWIG_fail;
34318 }
34319 resultobj = SWIG_Py_Void();
34320 return resultobj;
34321 fail:
34322 return NULL;
34323 }
34324
34325
34326 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34327 PyObject *resultobj = 0;
34328 wxWindow *arg1 = (wxWindow *) 0 ;
34329 long arg2 ;
34330 wxWindow *result = 0 ;
34331 void *argp1 = 0 ;
34332 int res1 = 0 ;
34333 long val2 ;
34334 int ecode2 = 0 ;
34335 PyObject * obj0 = 0 ;
34336 PyObject * obj1 = 0 ;
34337 char * kwnames[] = {
34338 (char *) "self",(char *) "winid", NULL
34339 };
34340
34341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34343 if (!SWIG_IsOK(res1)) {
34344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34345 }
34346 arg1 = reinterpret_cast< wxWindow * >(argp1);
34347 ecode2 = SWIG_AsVal_long(obj1, &val2);
34348 if (!SWIG_IsOK(ecode2)) {
34349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34350 }
34351 arg2 = static_cast< long >(val2);
34352 {
34353 PyThreadState* __tstate = wxPyBeginAllowThreads();
34354 result = (wxWindow *)(arg1)->FindWindow(arg2);
34355 wxPyEndAllowThreads(__tstate);
34356 if (PyErr_Occurred()) SWIG_fail;
34357 }
34358 {
34359 resultobj = wxPyMake_wxObject(result, 0);
34360 }
34361 return resultobj;
34362 fail:
34363 return NULL;
34364 }
34365
34366
34367 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34368 PyObject *resultobj = 0;
34369 wxWindow *arg1 = (wxWindow *) 0 ;
34370 wxString *arg2 = 0 ;
34371 wxWindow *result = 0 ;
34372 void *argp1 = 0 ;
34373 int res1 = 0 ;
34374 bool temp2 = false ;
34375 PyObject * obj0 = 0 ;
34376 PyObject * obj1 = 0 ;
34377 char * kwnames[] = {
34378 (char *) "self",(char *) "name", NULL
34379 };
34380
34381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34383 if (!SWIG_IsOK(res1)) {
34384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34385 }
34386 arg1 = reinterpret_cast< wxWindow * >(argp1);
34387 {
34388 arg2 = wxString_in_helper(obj1);
34389 if (arg2 == NULL) SWIG_fail;
34390 temp2 = true;
34391 }
34392 {
34393 PyThreadState* __tstate = wxPyBeginAllowThreads();
34394 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34395 wxPyEndAllowThreads(__tstate);
34396 if (PyErr_Occurred()) SWIG_fail;
34397 }
34398 {
34399 resultobj = wxPyMake_wxObject(result, 0);
34400 }
34401 {
34402 if (temp2)
34403 delete arg2;
34404 }
34405 return resultobj;
34406 fail:
34407 {
34408 if (temp2)
34409 delete arg2;
34410 }
34411 return NULL;
34412 }
34413
34414
34415 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34416 PyObject *resultobj = 0;
34417 wxWindow *arg1 = (wxWindow *) 0 ;
34418 wxEvtHandler *result = 0 ;
34419 void *argp1 = 0 ;
34420 int res1 = 0 ;
34421 PyObject *swig_obj[1] ;
34422
34423 if (!args) SWIG_fail;
34424 swig_obj[0] = args;
34425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34426 if (!SWIG_IsOK(res1)) {
34427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34428 }
34429 arg1 = reinterpret_cast< wxWindow * >(argp1);
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34433 wxPyEndAllowThreads(__tstate);
34434 if (PyErr_Occurred()) SWIG_fail;
34435 }
34436 {
34437 resultobj = wxPyMake_wxObject(result, 0);
34438 }
34439 return resultobj;
34440 fail:
34441 return NULL;
34442 }
34443
34444
34445 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34446 PyObject *resultobj = 0;
34447 wxWindow *arg1 = (wxWindow *) 0 ;
34448 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34449 void *argp1 = 0 ;
34450 int res1 = 0 ;
34451 void *argp2 = 0 ;
34452 int res2 = 0 ;
34453 PyObject * obj0 = 0 ;
34454 PyObject * obj1 = 0 ;
34455 char * kwnames[] = {
34456 (char *) "self",(char *) "handler", NULL
34457 };
34458
34459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34461 if (!SWIG_IsOK(res1)) {
34462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34463 }
34464 arg1 = reinterpret_cast< wxWindow * >(argp1);
34465 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34466 if (!SWIG_IsOK(res2)) {
34467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34468 }
34469 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34470 {
34471 PyThreadState* __tstate = wxPyBeginAllowThreads();
34472 (arg1)->SetEventHandler(arg2);
34473 wxPyEndAllowThreads(__tstate);
34474 if (PyErr_Occurred()) SWIG_fail;
34475 }
34476 resultobj = SWIG_Py_Void();
34477 return resultobj;
34478 fail:
34479 return NULL;
34480 }
34481
34482
34483 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34484 PyObject *resultobj = 0;
34485 wxWindow *arg1 = (wxWindow *) 0 ;
34486 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34487 void *argp1 = 0 ;
34488 int res1 = 0 ;
34489 void *argp2 = 0 ;
34490 int res2 = 0 ;
34491 PyObject * obj0 = 0 ;
34492 PyObject * obj1 = 0 ;
34493 char * kwnames[] = {
34494 (char *) "self",(char *) "handler", NULL
34495 };
34496
34497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34499 if (!SWIG_IsOK(res1)) {
34500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34501 }
34502 arg1 = reinterpret_cast< wxWindow * >(argp1);
34503 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34504 if (!SWIG_IsOK(res2)) {
34505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34506 }
34507 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34508 {
34509 PyThreadState* __tstate = wxPyBeginAllowThreads();
34510 (arg1)->PushEventHandler(arg2);
34511 wxPyEndAllowThreads(__tstate);
34512 if (PyErr_Occurred()) SWIG_fail;
34513 }
34514 resultobj = SWIG_Py_Void();
34515 return resultobj;
34516 fail:
34517 return NULL;
34518 }
34519
34520
34521 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34522 PyObject *resultobj = 0;
34523 wxWindow *arg1 = (wxWindow *) 0 ;
34524 bool arg2 = (bool) false ;
34525 wxEvtHandler *result = 0 ;
34526 void *argp1 = 0 ;
34527 int res1 = 0 ;
34528 bool val2 ;
34529 int ecode2 = 0 ;
34530 PyObject * obj0 = 0 ;
34531 PyObject * obj1 = 0 ;
34532 char * kwnames[] = {
34533 (char *) "self",(char *) "deleteHandler", NULL
34534 };
34535
34536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34538 if (!SWIG_IsOK(res1)) {
34539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34540 }
34541 arg1 = reinterpret_cast< wxWindow * >(argp1);
34542 if (obj1) {
34543 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34544 if (!SWIG_IsOK(ecode2)) {
34545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34546 }
34547 arg2 = static_cast< bool >(val2);
34548 }
34549 {
34550 PyThreadState* __tstate = wxPyBeginAllowThreads();
34551 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34552 wxPyEndAllowThreads(__tstate);
34553 if (PyErr_Occurred()) SWIG_fail;
34554 }
34555 {
34556 resultobj = wxPyMake_wxObject(result, 0);
34557 }
34558 return resultobj;
34559 fail:
34560 return NULL;
34561 }
34562
34563
34564 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34565 PyObject *resultobj = 0;
34566 wxWindow *arg1 = (wxWindow *) 0 ;
34567 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34568 bool result;
34569 void *argp1 = 0 ;
34570 int res1 = 0 ;
34571 void *argp2 = 0 ;
34572 int res2 = 0 ;
34573 PyObject * obj0 = 0 ;
34574 PyObject * obj1 = 0 ;
34575 char * kwnames[] = {
34576 (char *) "self",(char *) "handler", NULL
34577 };
34578
34579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34581 if (!SWIG_IsOK(res1)) {
34582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34583 }
34584 arg1 = reinterpret_cast< wxWindow * >(argp1);
34585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34586 if (!SWIG_IsOK(res2)) {
34587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34588 }
34589 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34590 {
34591 PyThreadState* __tstate = wxPyBeginAllowThreads();
34592 result = (bool)(arg1)->RemoveEventHandler(arg2);
34593 wxPyEndAllowThreads(__tstate);
34594 if (PyErr_Occurred()) SWIG_fail;
34595 }
34596 {
34597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34598 }
34599 return resultobj;
34600 fail:
34601 return NULL;
34602 }
34603
34604
34605 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34606 PyObject *resultobj = 0;
34607 wxWindow *arg1 = (wxWindow *) 0 ;
34608 wxValidator *arg2 = 0 ;
34609 void *argp1 = 0 ;
34610 int res1 = 0 ;
34611 void *argp2 = 0 ;
34612 int res2 = 0 ;
34613 PyObject * obj0 = 0 ;
34614 PyObject * obj1 = 0 ;
34615 char * kwnames[] = {
34616 (char *) "self",(char *) "validator", NULL
34617 };
34618
34619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34621 if (!SWIG_IsOK(res1)) {
34622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34623 }
34624 arg1 = reinterpret_cast< wxWindow * >(argp1);
34625 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34626 if (!SWIG_IsOK(res2)) {
34627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34628 }
34629 if (!argp2) {
34630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34631 }
34632 arg2 = reinterpret_cast< wxValidator * >(argp2);
34633 {
34634 PyThreadState* __tstate = wxPyBeginAllowThreads();
34635 (arg1)->SetValidator((wxValidator const &)*arg2);
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 resultobj = SWIG_Py_Void();
34640 return resultobj;
34641 fail:
34642 return NULL;
34643 }
34644
34645
34646 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34647 PyObject *resultobj = 0;
34648 wxWindow *arg1 = (wxWindow *) 0 ;
34649 wxValidator *result = 0 ;
34650 void *argp1 = 0 ;
34651 int res1 = 0 ;
34652 PyObject *swig_obj[1] ;
34653
34654 if (!args) SWIG_fail;
34655 swig_obj[0] = args;
34656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34657 if (!SWIG_IsOK(res1)) {
34658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34659 }
34660 arg1 = reinterpret_cast< wxWindow * >(argp1);
34661 {
34662 PyThreadState* __tstate = wxPyBeginAllowThreads();
34663 result = (wxValidator *)(arg1)->GetValidator();
34664 wxPyEndAllowThreads(__tstate);
34665 if (PyErr_Occurred()) SWIG_fail;
34666 }
34667 {
34668 resultobj = wxPyMake_wxObject(result, (bool)0);
34669 }
34670 return resultobj;
34671 fail:
34672 return NULL;
34673 }
34674
34675
34676 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34677 PyObject *resultobj = 0;
34678 wxWindow *arg1 = (wxWindow *) 0 ;
34679 bool result;
34680 void *argp1 = 0 ;
34681 int res1 = 0 ;
34682 PyObject *swig_obj[1] ;
34683
34684 if (!args) SWIG_fail;
34685 swig_obj[0] = args;
34686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34687 if (!SWIG_IsOK(res1)) {
34688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34689 }
34690 arg1 = reinterpret_cast< wxWindow * >(argp1);
34691 {
34692 PyThreadState* __tstate = wxPyBeginAllowThreads();
34693 result = (bool)(arg1)->Validate();
34694 wxPyEndAllowThreads(__tstate);
34695 if (PyErr_Occurred()) SWIG_fail;
34696 }
34697 {
34698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34699 }
34700 return resultobj;
34701 fail:
34702 return NULL;
34703 }
34704
34705
34706 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34707 PyObject *resultobj = 0;
34708 wxWindow *arg1 = (wxWindow *) 0 ;
34709 bool result;
34710 void *argp1 = 0 ;
34711 int res1 = 0 ;
34712 PyObject *swig_obj[1] ;
34713
34714 if (!args) SWIG_fail;
34715 swig_obj[0] = args;
34716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34717 if (!SWIG_IsOK(res1)) {
34718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34719 }
34720 arg1 = reinterpret_cast< wxWindow * >(argp1);
34721 {
34722 PyThreadState* __tstate = wxPyBeginAllowThreads();
34723 result = (bool)(arg1)->TransferDataToWindow();
34724 wxPyEndAllowThreads(__tstate);
34725 if (PyErr_Occurred()) SWIG_fail;
34726 }
34727 {
34728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34729 }
34730 return resultobj;
34731 fail:
34732 return NULL;
34733 }
34734
34735
34736 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34737 PyObject *resultobj = 0;
34738 wxWindow *arg1 = (wxWindow *) 0 ;
34739 bool result;
34740 void *argp1 = 0 ;
34741 int res1 = 0 ;
34742 PyObject *swig_obj[1] ;
34743
34744 if (!args) SWIG_fail;
34745 swig_obj[0] = args;
34746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34747 if (!SWIG_IsOK(res1)) {
34748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34749 }
34750 arg1 = reinterpret_cast< wxWindow * >(argp1);
34751 {
34752 PyThreadState* __tstate = wxPyBeginAllowThreads();
34753 result = (bool)(arg1)->TransferDataFromWindow();
34754 wxPyEndAllowThreads(__tstate);
34755 if (PyErr_Occurred()) SWIG_fail;
34756 }
34757 {
34758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34759 }
34760 return resultobj;
34761 fail:
34762 return NULL;
34763 }
34764
34765
34766 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34767 PyObject *resultobj = 0;
34768 wxWindow *arg1 = (wxWindow *) 0 ;
34769 void *argp1 = 0 ;
34770 int res1 = 0 ;
34771 PyObject *swig_obj[1] ;
34772
34773 if (!args) SWIG_fail;
34774 swig_obj[0] = args;
34775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34776 if (!SWIG_IsOK(res1)) {
34777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34778 }
34779 arg1 = reinterpret_cast< wxWindow * >(argp1);
34780 {
34781 PyThreadState* __tstate = wxPyBeginAllowThreads();
34782 (arg1)->InitDialog();
34783 wxPyEndAllowThreads(__tstate);
34784 if (PyErr_Occurred()) SWIG_fail;
34785 }
34786 resultobj = SWIG_Py_Void();
34787 return resultobj;
34788 fail:
34789 return NULL;
34790 }
34791
34792
34793 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34794 PyObject *resultobj = 0;
34795 wxWindow *arg1 = (wxWindow *) 0 ;
34796 wxAcceleratorTable *arg2 = 0 ;
34797 void *argp1 = 0 ;
34798 int res1 = 0 ;
34799 void *argp2 = 0 ;
34800 int res2 = 0 ;
34801 PyObject * obj0 = 0 ;
34802 PyObject * obj1 = 0 ;
34803 char * kwnames[] = {
34804 (char *) "self",(char *) "accel", NULL
34805 };
34806
34807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34809 if (!SWIG_IsOK(res1)) {
34810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34811 }
34812 arg1 = reinterpret_cast< wxWindow * >(argp1);
34813 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34814 if (!SWIG_IsOK(res2)) {
34815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34816 }
34817 if (!argp2) {
34818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34819 }
34820 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34824 wxPyEndAllowThreads(__tstate);
34825 if (PyErr_Occurred()) SWIG_fail;
34826 }
34827 resultobj = SWIG_Py_Void();
34828 return resultobj;
34829 fail:
34830 return NULL;
34831 }
34832
34833
34834 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34835 PyObject *resultobj = 0;
34836 wxWindow *arg1 = (wxWindow *) 0 ;
34837 wxAcceleratorTable *result = 0 ;
34838 void *argp1 = 0 ;
34839 int res1 = 0 ;
34840 PyObject *swig_obj[1] ;
34841
34842 if (!args) SWIG_fail;
34843 swig_obj[0] = args;
34844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34845 if (!SWIG_IsOK(res1)) {
34846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34847 }
34848 arg1 = reinterpret_cast< wxWindow * >(argp1);
34849 {
34850 PyThreadState* __tstate = wxPyBeginAllowThreads();
34851 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34852 wxPyEndAllowThreads(__tstate);
34853 if (PyErr_Occurred()) SWIG_fail;
34854 }
34855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34856 return resultobj;
34857 fail:
34858 return NULL;
34859 }
34860
34861
34862 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34863 PyObject *resultobj = 0;
34864 wxWindow *arg1 = (wxWindow *) 0 ;
34865 int arg2 ;
34866 int arg3 ;
34867 int arg4 ;
34868 bool result;
34869 void *argp1 = 0 ;
34870 int res1 = 0 ;
34871 int val2 ;
34872 int ecode2 = 0 ;
34873 int val3 ;
34874 int ecode3 = 0 ;
34875 int val4 ;
34876 int ecode4 = 0 ;
34877 PyObject * obj0 = 0 ;
34878 PyObject * obj1 = 0 ;
34879 PyObject * obj2 = 0 ;
34880 PyObject * obj3 = 0 ;
34881 char * kwnames[] = {
34882 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34883 };
34884
34885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34887 if (!SWIG_IsOK(res1)) {
34888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34889 }
34890 arg1 = reinterpret_cast< wxWindow * >(argp1);
34891 ecode2 = SWIG_AsVal_int(obj1, &val2);
34892 if (!SWIG_IsOK(ecode2)) {
34893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34894 }
34895 arg2 = static_cast< int >(val2);
34896 ecode3 = SWIG_AsVal_int(obj2, &val3);
34897 if (!SWIG_IsOK(ecode3)) {
34898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34899 }
34900 arg3 = static_cast< int >(val3);
34901 ecode4 = SWIG_AsVal_int(obj3, &val4);
34902 if (!SWIG_IsOK(ecode4)) {
34903 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34904 }
34905 arg4 = static_cast< int >(val4);
34906 {
34907 PyThreadState* __tstate = wxPyBeginAllowThreads();
34908 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34909 wxPyEndAllowThreads(__tstate);
34910 if (PyErr_Occurred()) SWIG_fail;
34911 }
34912 {
34913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34914 }
34915 return resultobj;
34916 fail:
34917 return NULL;
34918 }
34919
34920
34921 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34922 PyObject *resultobj = 0;
34923 wxWindow *arg1 = (wxWindow *) 0 ;
34924 int arg2 ;
34925 bool result;
34926 void *argp1 = 0 ;
34927 int res1 = 0 ;
34928 int val2 ;
34929 int ecode2 = 0 ;
34930 PyObject * obj0 = 0 ;
34931 PyObject * obj1 = 0 ;
34932 char * kwnames[] = {
34933 (char *) "self",(char *) "hotkeyId", NULL
34934 };
34935
34936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34938 if (!SWIG_IsOK(res1)) {
34939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34940 }
34941 arg1 = reinterpret_cast< wxWindow * >(argp1);
34942 ecode2 = SWIG_AsVal_int(obj1, &val2);
34943 if (!SWIG_IsOK(ecode2)) {
34944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34945 }
34946 arg2 = static_cast< int >(val2);
34947 {
34948 PyThreadState* __tstate = wxPyBeginAllowThreads();
34949 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34950 wxPyEndAllowThreads(__tstate);
34951 if (PyErr_Occurred()) SWIG_fail;
34952 }
34953 {
34954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34955 }
34956 return resultobj;
34957 fail:
34958 return NULL;
34959 }
34960
34961
34962 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34963 PyObject *resultobj = 0;
34964 wxWindow *arg1 = (wxWindow *) 0 ;
34965 wxPoint *arg2 = 0 ;
34966 wxPoint result;
34967 void *argp1 = 0 ;
34968 int res1 = 0 ;
34969 wxPoint temp2 ;
34970 PyObject * obj0 = 0 ;
34971 PyObject * obj1 = 0 ;
34972 char * kwnames[] = {
34973 (char *) "self",(char *) "pt", NULL
34974 };
34975
34976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34978 if (!SWIG_IsOK(res1)) {
34979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34980 }
34981 arg1 = reinterpret_cast< wxWindow * >(argp1);
34982 {
34983 arg2 = &temp2;
34984 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34985 }
34986 {
34987 PyThreadState* __tstate = wxPyBeginAllowThreads();
34988 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34989 wxPyEndAllowThreads(__tstate);
34990 if (PyErr_Occurred()) SWIG_fail;
34991 }
34992 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34993 return resultobj;
34994 fail:
34995 return NULL;
34996 }
34997
34998
34999 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35000 PyObject *resultobj = 0;
35001 wxWindow *arg1 = (wxWindow *) 0 ;
35002 wxSize *arg2 = 0 ;
35003 wxSize result;
35004 void *argp1 = 0 ;
35005 int res1 = 0 ;
35006 wxSize temp2 ;
35007 PyObject * obj0 = 0 ;
35008 PyObject * obj1 = 0 ;
35009 char * kwnames[] = {
35010 (char *) "self",(char *) "sz", NULL
35011 };
35012
35013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35015 if (!SWIG_IsOK(res1)) {
35016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35017 }
35018 arg1 = reinterpret_cast< wxWindow * >(argp1);
35019 {
35020 arg2 = &temp2;
35021 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35022 }
35023 {
35024 PyThreadState* __tstate = wxPyBeginAllowThreads();
35025 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35026 wxPyEndAllowThreads(__tstate);
35027 if (PyErr_Occurred()) SWIG_fail;
35028 }
35029 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35030 return resultobj;
35031 fail:
35032 return NULL;
35033 }
35034
35035
35036 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35037 PyObject *resultobj = 0;
35038 wxWindow *arg1 = (wxWindow *) 0 ;
35039 wxPoint *arg2 = 0 ;
35040 wxPoint result;
35041 void *argp1 = 0 ;
35042 int res1 = 0 ;
35043 wxPoint temp2 ;
35044 PyObject * obj0 = 0 ;
35045 PyObject * obj1 = 0 ;
35046 char * kwnames[] = {
35047 (char *) "self",(char *) "pt", NULL
35048 };
35049
35050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 {
35057 arg2 = &temp2;
35058 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35059 }
35060 {
35061 PyThreadState* __tstate = wxPyBeginAllowThreads();
35062 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35063 wxPyEndAllowThreads(__tstate);
35064 if (PyErr_Occurred()) SWIG_fail;
35065 }
35066 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35067 return resultobj;
35068 fail:
35069 return NULL;
35070 }
35071
35072
35073 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35074 PyObject *resultobj = 0;
35075 wxWindow *arg1 = (wxWindow *) 0 ;
35076 wxSize *arg2 = 0 ;
35077 wxSize result;
35078 void *argp1 = 0 ;
35079 int res1 = 0 ;
35080 wxSize temp2 ;
35081 PyObject * obj0 = 0 ;
35082 PyObject * obj1 = 0 ;
35083 char * kwnames[] = {
35084 (char *) "self",(char *) "sz", NULL
35085 };
35086
35087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35089 if (!SWIG_IsOK(res1)) {
35090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35091 }
35092 arg1 = reinterpret_cast< wxWindow * >(argp1);
35093 {
35094 arg2 = &temp2;
35095 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35096 }
35097 {
35098 PyThreadState* __tstate = wxPyBeginAllowThreads();
35099 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35100 wxPyEndAllowThreads(__tstate);
35101 if (PyErr_Occurred()) SWIG_fail;
35102 }
35103 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35104 return resultobj;
35105 fail:
35106 return NULL;
35107 }
35108
35109
35110 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35111 PyObject *resultobj = 0;
35112 wxWindow *arg1 = (wxWindow *) 0 ;
35113 wxPoint *arg2 = 0 ;
35114 wxPoint result;
35115 void *argp1 = 0 ;
35116 int res1 = 0 ;
35117 wxPoint temp2 ;
35118 PyObject * obj0 = 0 ;
35119 PyObject * obj1 = 0 ;
35120 char * kwnames[] = {
35121 (char *) "self",(char *) "pt", NULL
35122 };
35123
35124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35126 if (!SWIG_IsOK(res1)) {
35127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35128 }
35129 arg1 = reinterpret_cast< wxWindow * >(argp1);
35130 {
35131 arg2 = &temp2;
35132 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35133 }
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35137 wxPyEndAllowThreads(__tstate);
35138 if (PyErr_Occurred()) SWIG_fail;
35139 }
35140 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35141 return resultobj;
35142 fail:
35143 return NULL;
35144 }
35145
35146
35147 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35148 PyObject *resultobj = 0;
35149 wxWindow *arg1 = (wxWindow *) 0 ;
35150 wxSize *arg2 = 0 ;
35151 wxSize result;
35152 void *argp1 = 0 ;
35153 int res1 = 0 ;
35154 wxSize temp2 ;
35155 PyObject * obj0 = 0 ;
35156 PyObject * obj1 = 0 ;
35157 char * kwnames[] = {
35158 (char *) "self",(char *) "sz", NULL
35159 };
35160
35161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35163 if (!SWIG_IsOK(res1)) {
35164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35165 }
35166 arg1 = reinterpret_cast< wxWindow * >(argp1);
35167 {
35168 arg2 = &temp2;
35169 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35170 }
35171 {
35172 PyThreadState* __tstate = wxPyBeginAllowThreads();
35173 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35174 wxPyEndAllowThreads(__tstate);
35175 if (PyErr_Occurred()) SWIG_fail;
35176 }
35177 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35178 return resultobj;
35179 fail:
35180 return NULL;
35181 }
35182
35183
35184 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35185 PyObject *resultobj = 0;
35186 wxWindow *arg1 = (wxWindow *) 0 ;
35187 int arg2 ;
35188 int arg3 ;
35189 void *argp1 = 0 ;
35190 int res1 = 0 ;
35191 int val2 ;
35192 int ecode2 = 0 ;
35193 int val3 ;
35194 int ecode3 = 0 ;
35195 PyObject * obj0 = 0 ;
35196 PyObject * obj1 = 0 ;
35197 PyObject * obj2 = 0 ;
35198 char * kwnames[] = {
35199 (char *) "self",(char *) "x",(char *) "y", NULL
35200 };
35201
35202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35204 if (!SWIG_IsOK(res1)) {
35205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35206 }
35207 arg1 = reinterpret_cast< wxWindow * >(argp1);
35208 ecode2 = SWIG_AsVal_int(obj1, &val2);
35209 if (!SWIG_IsOK(ecode2)) {
35210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35211 }
35212 arg2 = static_cast< int >(val2);
35213 ecode3 = SWIG_AsVal_int(obj2, &val3);
35214 if (!SWIG_IsOK(ecode3)) {
35215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35216 }
35217 arg3 = static_cast< int >(val3);
35218 {
35219 PyThreadState* __tstate = wxPyBeginAllowThreads();
35220 (arg1)->WarpPointer(arg2,arg3);
35221 wxPyEndAllowThreads(__tstate);
35222 if (PyErr_Occurred()) SWIG_fail;
35223 }
35224 resultobj = SWIG_Py_Void();
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35232 PyObject *resultobj = 0;
35233 wxWindow *arg1 = (wxWindow *) 0 ;
35234 void *argp1 = 0 ;
35235 int res1 = 0 ;
35236 PyObject *swig_obj[1] ;
35237
35238 if (!args) SWIG_fail;
35239 swig_obj[0] = args;
35240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35241 if (!SWIG_IsOK(res1)) {
35242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35243 }
35244 arg1 = reinterpret_cast< wxWindow * >(argp1);
35245 {
35246 PyThreadState* __tstate = wxPyBeginAllowThreads();
35247 (arg1)->CaptureMouse();
35248 wxPyEndAllowThreads(__tstate);
35249 if (PyErr_Occurred()) SWIG_fail;
35250 }
35251 resultobj = SWIG_Py_Void();
35252 return resultobj;
35253 fail:
35254 return NULL;
35255 }
35256
35257
35258 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35259 PyObject *resultobj = 0;
35260 wxWindow *arg1 = (wxWindow *) 0 ;
35261 void *argp1 = 0 ;
35262 int res1 = 0 ;
35263 PyObject *swig_obj[1] ;
35264
35265 if (!args) SWIG_fail;
35266 swig_obj[0] = args;
35267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35268 if (!SWIG_IsOK(res1)) {
35269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35270 }
35271 arg1 = reinterpret_cast< wxWindow * >(argp1);
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 (arg1)->ReleaseMouse();
35275 wxPyEndAllowThreads(__tstate);
35276 if (PyErr_Occurred()) SWIG_fail;
35277 }
35278 resultobj = SWIG_Py_Void();
35279 return resultobj;
35280 fail:
35281 return NULL;
35282 }
35283
35284
35285 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35286 PyObject *resultobj = 0;
35287 wxWindow *result = 0 ;
35288
35289 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35290 {
35291 if (!wxPyCheckForApp()) SWIG_fail;
35292 PyThreadState* __tstate = wxPyBeginAllowThreads();
35293 result = (wxWindow *)wxWindow::GetCapture();
35294 wxPyEndAllowThreads(__tstate);
35295 if (PyErr_Occurred()) SWIG_fail;
35296 }
35297 {
35298 resultobj = wxPyMake_wxObject(result, 0);
35299 }
35300 return resultobj;
35301 fail:
35302 return NULL;
35303 }
35304
35305
35306 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35307 PyObject *resultobj = 0;
35308 wxWindow *arg1 = (wxWindow *) 0 ;
35309 bool result;
35310 void *argp1 = 0 ;
35311 int res1 = 0 ;
35312 PyObject *swig_obj[1] ;
35313
35314 if (!args) SWIG_fail;
35315 swig_obj[0] = args;
35316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35317 if (!SWIG_IsOK(res1)) {
35318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35319 }
35320 arg1 = reinterpret_cast< wxWindow * >(argp1);
35321 {
35322 PyThreadState* __tstate = wxPyBeginAllowThreads();
35323 result = (bool)((wxWindow const *)arg1)->HasCapture();
35324 wxPyEndAllowThreads(__tstate);
35325 if (PyErr_Occurred()) SWIG_fail;
35326 }
35327 {
35328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35329 }
35330 return resultobj;
35331 fail:
35332 return NULL;
35333 }
35334
35335
35336 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35337 PyObject *resultobj = 0;
35338 wxWindow *arg1 = (wxWindow *) 0 ;
35339 bool arg2 = (bool) true ;
35340 wxRect *arg3 = (wxRect *) NULL ;
35341 void *argp1 = 0 ;
35342 int res1 = 0 ;
35343 bool val2 ;
35344 int ecode2 = 0 ;
35345 void *argp3 = 0 ;
35346 int res3 = 0 ;
35347 PyObject * obj0 = 0 ;
35348 PyObject * obj1 = 0 ;
35349 PyObject * obj2 = 0 ;
35350 char * kwnames[] = {
35351 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35352 };
35353
35354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35356 if (!SWIG_IsOK(res1)) {
35357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35358 }
35359 arg1 = reinterpret_cast< wxWindow * >(argp1);
35360 if (obj1) {
35361 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35362 if (!SWIG_IsOK(ecode2)) {
35363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35364 }
35365 arg2 = static_cast< bool >(val2);
35366 }
35367 if (obj2) {
35368 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35369 if (!SWIG_IsOK(res3)) {
35370 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35371 }
35372 arg3 = reinterpret_cast< wxRect * >(argp3);
35373 }
35374 {
35375 PyThreadState* __tstate = wxPyBeginAllowThreads();
35376 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35377 wxPyEndAllowThreads(__tstate);
35378 if (PyErr_Occurred()) SWIG_fail;
35379 }
35380 resultobj = SWIG_Py_Void();
35381 return resultobj;
35382 fail:
35383 return NULL;
35384 }
35385
35386
35387 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35388 PyObject *resultobj = 0;
35389 wxWindow *arg1 = (wxWindow *) 0 ;
35390 wxRect *arg2 = 0 ;
35391 bool arg3 = (bool) true ;
35392 void *argp1 = 0 ;
35393 int res1 = 0 ;
35394 wxRect temp2 ;
35395 bool val3 ;
35396 int ecode3 = 0 ;
35397 PyObject * obj0 = 0 ;
35398 PyObject * obj1 = 0 ;
35399 PyObject * obj2 = 0 ;
35400 char * kwnames[] = {
35401 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35402 };
35403
35404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35406 if (!SWIG_IsOK(res1)) {
35407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35408 }
35409 arg1 = reinterpret_cast< wxWindow * >(argp1);
35410 {
35411 arg2 = &temp2;
35412 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35413 }
35414 if (obj2) {
35415 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35416 if (!SWIG_IsOK(ecode3)) {
35417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35418 }
35419 arg3 = static_cast< bool >(val3);
35420 }
35421 {
35422 PyThreadState* __tstate = wxPyBeginAllowThreads();
35423 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35424 wxPyEndAllowThreads(__tstate);
35425 if (PyErr_Occurred()) SWIG_fail;
35426 }
35427 resultobj = SWIG_Py_Void();
35428 return resultobj;
35429 fail:
35430 return NULL;
35431 }
35432
35433
35434 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35435 PyObject *resultobj = 0;
35436 wxWindow *arg1 = (wxWindow *) 0 ;
35437 void *argp1 = 0 ;
35438 int res1 = 0 ;
35439 PyObject *swig_obj[1] ;
35440
35441 if (!args) SWIG_fail;
35442 swig_obj[0] = args;
35443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35444 if (!SWIG_IsOK(res1)) {
35445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35446 }
35447 arg1 = reinterpret_cast< wxWindow * >(argp1);
35448 {
35449 PyThreadState* __tstate = wxPyBeginAllowThreads();
35450 (arg1)->Update();
35451 wxPyEndAllowThreads(__tstate);
35452 if (PyErr_Occurred()) SWIG_fail;
35453 }
35454 resultobj = SWIG_Py_Void();
35455 return resultobj;
35456 fail:
35457 return NULL;
35458 }
35459
35460
35461 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35462 PyObject *resultobj = 0;
35463 wxWindow *arg1 = (wxWindow *) 0 ;
35464 void *argp1 = 0 ;
35465 int res1 = 0 ;
35466 PyObject *swig_obj[1] ;
35467
35468 if (!args) SWIG_fail;
35469 swig_obj[0] = args;
35470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35471 if (!SWIG_IsOK(res1)) {
35472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35473 }
35474 arg1 = reinterpret_cast< wxWindow * >(argp1);
35475 {
35476 PyThreadState* __tstate = wxPyBeginAllowThreads();
35477 (arg1)->ClearBackground();
35478 wxPyEndAllowThreads(__tstate);
35479 if (PyErr_Occurred()) SWIG_fail;
35480 }
35481 resultobj = SWIG_Py_Void();
35482 return resultobj;
35483 fail:
35484 return NULL;
35485 }
35486
35487
35488 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35489 PyObject *resultobj = 0;
35490 wxWindow *arg1 = (wxWindow *) 0 ;
35491 void *argp1 = 0 ;
35492 int res1 = 0 ;
35493 PyObject *swig_obj[1] ;
35494
35495 if (!args) SWIG_fail;
35496 swig_obj[0] = args;
35497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35498 if (!SWIG_IsOK(res1)) {
35499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35500 }
35501 arg1 = reinterpret_cast< wxWindow * >(argp1);
35502 {
35503 PyThreadState* __tstate = wxPyBeginAllowThreads();
35504 (arg1)->Freeze();
35505 wxPyEndAllowThreads(__tstate);
35506 if (PyErr_Occurred()) SWIG_fail;
35507 }
35508 resultobj = SWIG_Py_Void();
35509 return resultobj;
35510 fail:
35511 return NULL;
35512 }
35513
35514
35515 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35516 PyObject *resultobj = 0;
35517 wxWindow *arg1 = (wxWindow *) 0 ;
35518 bool result;
35519 void *argp1 = 0 ;
35520 int res1 = 0 ;
35521 PyObject *swig_obj[1] ;
35522
35523 if (!args) SWIG_fail;
35524 swig_obj[0] = args;
35525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35526 if (!SWIG_IsOK(res1)) {
35527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35528 }
35529 arg1 = reinterpret_cast< wxWindow * >(argp1);
35530 {
35531 PyThreadState* __tstate = wxPyBeginAllowThreads();
35532 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 {
35537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35538 }
35539 return resultobj;
35540 fail:
35541 return NULL;
35542 }
35543
35544
35545 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35546 PyObject *resultobj = 0;
35547 wxWindow *arg1 = (wxWindow *) 0 ;
35548 void *argp1 = 0 ;
35549 int res1 = 0 ;
35550 PyObject *swig_obj[1] ;
35551
35552 if (!args) SWIG_fail;
35553 swig_obj[0] = args;
35554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35555 if (!SWIG_IsOK(res1)) {
35556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35557 }
35558 arg1 = reinterpret_cast< wxWindow * >(argp1);
35559 {
35560 PyThreadState* __tstate = wxPyBeginAllowThreads();
35561 (arg1)->Thaw();
35562 wxPyEndAllowThreads(__tstate);
35563 if (PyErr_Occurred()) SWIG_fail;
35564 }
35565 resultobj = SWIG_Py_Void();
35566 return resultobj;
35567 fail:
35568 return NULL;
35569 }
35570
35571
35572 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35573 PyObject *resultobj = 0;
35574 wxWindow *arg1 = (wxWindow *) 0 ;
35575 wxDC *arg2 = 0 ;
35576 void *argp1 = 0 ;
35577 int res1 = 0 ;
35578 void *argp2 = 0 ;
35579 int res2 = 0 ;
35580 PyObject * obj0 = 0 ;
35581 PyObject * obj1 = 0 ;
35582 char * kwnames[] = {
35583 (char *) "self",(char *) "dc", NULL
35584 };
35585
35586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35588 if (!SWIG_IsOK(res1)) {
35589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35590 }
35591 arg1 = reinterpret_cast< wxWindow * >(argp1);
35592 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35593 if (!SWIG_IsOK(res2)) {
35594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35595 }
35596 if (!argp2) {
35597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35598 }
35599 arg2 = reinterpret_cast< wxDC * >(argp2);
35600 {
35601 PyThreadState* __tstate = wxPyBeginAllowThreads();
35602 (arg1)->PrepareDC(*arg2);
35603 wxPyEndAllowThreads(__tstate);
35604 if (PyErr_Occurred()) SWIG_fail;
35605 }
35606 resultobj = SWIG_Py_Void();
35607 return resultobj;
35608 fail:
35609 return NULL;
35610 }
35611
35612
35613 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35614 PyObject *resultobj = 0;
35615 wxWindow *arg1 = (wxWindow *) 0 ;
35616 wxRegion *result = 0 ;
35617 void *argp1 = 0 ;
35618 int res1 = 0 ;
35619 PyObject *swig_obj[1] ;
35620
35621 if (!args) SWIG_fail;
35622 swig_obj[0] = args;
35623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35624 if (!SWIG_IsOK(res1)) {
35625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35626 }
35627 arg1 = reinterpret_cast< wxWindow * >(argp1);
35628 {
35629 PyThreadState* __tstate = wxPyBeginAllowThreads();
35630 {
35631 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35632 result = (wxRegion *) &_result_ref;
35633 }
35634 wxPyEndAllowThreads(__tstate);
35635 if (PyErr_Occurred()) SWIG_fail;
35636 }
35637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35638 return resultobj;
35639 fail:
35640 return NULL;
35641 }
35642
35643
35644 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35645 PyObject *resultobj = 0;
35646 wxWindow *arg1 = (wxWindow *) 0 ;
35647 wxRect result;
35648 void *argp1 = 0 ;
35649 int res1 = 0 ;
35650 PyObject *swig_obj[1] ;
35651
35652 if (!args) SWIG_fail;
35653 swig_obj[0] = args;
35654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35655 if (!SWIG_IsOK(res1)) {
35656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35657 }
35658 arg1 = reinterpret_cast< wxWindow * >(argp1);
35659 {
35660 PyThreadState* __tstate = wxPyBeginAllowThreads();
35661 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35662 wxPyEndAllowThreads(__tstate);
35663 if (PyErr_Occurred()) SWIG_fail;
35664 }
35665 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35666 return resultobj;
35667 fail:
35668 return NULL;
35669 }
35670
35671
35672 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35673 PyObject *resultobj = 0;
35674 wxWindow *arg1 = (wxWindow *) 0 ;
35675 int arg2 ;
35676 int arg3 ;
35677 int arg4 = (int) 1 ;
35678 int arg5 = (int) 1 ;
35679 bool result;
35680 void *argp1 = 0 ;
35681 int res1 = 0 ;
35682 int val2 ;
35683 int ecode2 = 0 ;
35684 int val3 ;
35685 int ecode3 = 0 ;
35686 int val4 ;
35687 int ecode4 = 0 ;
35688 int val5 ;
35689 int ecode5 = 0 ;
35690 PyObject * obj0 = 0 ;
35691 PyObject * obj1 = 0 ;
35692 PyObject * obj2 = 0 ;
35693 PyObject * obj3 = 0 ;
35694 PyObject * obj4 = 0 ;
35695 char * kwnames[] = {
35696 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35697 };
35698
35699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35703 }
35704 arg1 = reinterpret_cast< wxWindow * >(argp1);
35705 ecode2 = SWIG_AsVal_int(obj1, &val2);
35706 if (!SWIG_IsOK(ecode2)) {
35707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35708 }
35709 arg2 = static_cast< int >(val2);
35710 ecode3 = SWIG_AsVal_int(obj2, &val3);
35711 if (!SWIG_IsOK(ecode3)) {
35712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35713 }
35714 arg3 = static_cast< int >(val3);
35715 if (obj3) {
35716 ecode4 = SWIG_AsVal_int(obj3, &val4);
35717 if (!SWIG_IsOK(ecode4)) {
35718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35719 }
35720 arg4 = static_cast< int >(val4);
35721 }
35722 if (obj4) {
35723 ecode5 = SWIG_AsVal_int(obj4, &val5);
35724 if (!SWIG_IsOK(ecode5)) {
35725 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35726 }
35727 arg5 = static_cast< int >(val5);
35728 }
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35732 wxPyEndAllowThreads(__tstate);
35733 if (PyErr_Occurred()) SWIG_fail;
35734 }
35735 {
35736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35737 }
35738 return resultobj;
35739 fail:
35740 return NULL;
35741 }
35742
35743
35744 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35745 PyObject *resultobj = 0;
35746 wxWindow *arg1 = (wxWindow *) 0 ;
35747 wxPoint *arg2 = 0 ;
35748 bool result;
35749 void *argp1 = 0 ;
35750 int res1 = 0 ;
35751 wxPoint temp2 ;
35752 PyObject * obj0 = 0 ;
35753 PyObject * obj1 = 0 ;
35754 char * kwnames[] = {
35755 (char *) "self",(char *) "pt", NULL
35756 };
35757
35758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35760 if (!SWIG_IsOK(res1)) {
35761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35762 }
35763 arg1 = reinterpret_cast< wxWindow * >(argp1);
35764 {
35765 arg2 = &temp2;
35766 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35767 }
35768 {
35769 PyThreadState* __tstate = wxPyBeginAllowThreads();
35770 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35771 wxPyEndAllowThreads(__tstate);
35772 if (PyErr_Occurred()) SWIG_fail;
35773 }
35774 {
35775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35776 }
35777 return resultobj;
35778 fail:
35779 return NULL;
35780 }
35781
35782
35783 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35784 PyObject *resultobj = 0;
35785 wxWindow *arg1 = (wxWindow *) 0 ;
35786 wxRect *arg2 = 0 ;
35787 bool result;
35788 void *argp1 = 0 ;
35789 int res1 = 0 ;
35790 wxRect temp2 ;
35791 PyObject * obj0 = 0 ;
35792 PyObject * obj1 = 0 ;
35793 char * kwnames[] = {
35794 (char *) "self",(char *) "rect", NULL
35795 };
35796
35797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35799 if (!SWIG_IsOK(res1)) {
35800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35801 }
35802 arg1 = reinterpret_cast< wxWindow * >(argp1);
35803 {
35804 arg2 = &temp2;
35805 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35806 }
35807 {
35808 PyThreadState* __tstate = wxPyBeginAllowThreads();
35809 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35810 wxPyEndAllowThreads(__tstate);
35811 if (PyErr_Occurred()) SWIG_fail;
35812 }
35813 {
35814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35815 }
35816 return resultobj;
35817 fail:
35818 return NULL;
35819 }
35820
35821
35822 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35823 PyObject *resultobj = 0;
35824 wxWindow *arg1 = (wxWindow *) 0 ;
35825 SwigValueWrapper<wxVisualAttributes > result;
35826 void *argp1 = 0 ;
35827 int res1 = 0 ;
35828 PyObject *swig_obj[1] ;
35829
35830 if (!args) SWIG_fail;
35831 swig_obj[0] = args;
35832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35833 if (!SWIG_IsOK(res1)) {
35834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35835 }
35836 arg1 = reinterpret_cast< wxWindow * >(argp1);
35837 {
35838 PyThreadState* __tstate = wxPyBeginAllowThreads();
35839 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35840 wxPyEndAllowThreads(__tstate);
35841 if (PyErr_Occurred()) SWIG_fail;
35842 }
35843 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35844 return resultobj;
35845 fail:
35846 return NULL;
35847 }
35848
35849
35850 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35851 PyObject *resultobj = 0;
35852 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35853 SwigValueWrapper<wxVisualAttributes > result;
35854 int val1 ;
35855 int ecode1 = 0 ;
35856 PyObject * obj0 = 0 ;
35857 char * kwnames[] = {
35858 (char *) "variant", NULL
35859 };
35860
35861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35862 if (obj0) {
35863 ecode1 = SWIG_AsVal_int(obj0, &val1);
35864 if (!SWIG_IsOK(ecode1)) {
35865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35866 }
35867 arg1 = static_cast< wxWindowVariant >(val1);
35868 }
35869 {
35870 if (!wxPyCheckForApp()) SWIG_fail;
35871 PyThreadState* __tstate = wxPyBeginAllowThreads();
35872 result = wxWindow::GetClassDefaultAttributes(arg1);
35873 wxPyEndAllowThreads(__tstate);
35874 if (PyErr_Occurred()) SWIG_fail;
35875 }
35876 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35877 return resultobj;
35878 fail:
35879 return NULL;
35880 }
35881
35882
35883 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35884 PyObject *resultobj = 0;
35885 wxWindow *arg1 = (wxWindow *) 0 ;
35886 wxColour *arg2 = 0 ;
35887 bool result;
35888 void *argp1 = 0 ;
35889 int res1 = 0 ;
35890 wxColour temp2 ;
35891 PyObject * obj0 = 0 ;
35892 PyObject * obj1 = 0 ;
35893 char * kwnames[] = {
35894 (char *) "self",(char *) "colour", NULL
35895 };
35896
35897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35899 if (!SWIG_IsOK(res1)) {
35900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35901 }
35902 arg1 = reinterpret_cast< wxWindow * >(argp1);
35903 {
35904 arg2 = &temp2;
35905 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35906 }
35907 {
35908 PyThreadState* __tstate = wxPyBeginAllowThreads();
35909 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35910 wxPyEndAllowThreads(__tstate);
35911 if (PyErr_Occurred()) SWIG_fail;
35912 }
35913 {
35914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35915 }
35916 return resultobj;
35917 fail:
35918 return NULL;
35919 }
35920
35921
35922 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35923 PyObject *resultobj = 0;
35924 wxWindow *arg1 = (wxWindow *) 0 ;
35925 wxColour *arg2 = 0 ;
35926 void *argp1 = 0 ;
35927 int res1 = 0 ;
35928 wxColour temp2 ;
35929 PyObject * obj0 = 0 ;
35930 PyObject * obj1 = 0 ;
35931 char * kwnames[] = {
35932 (char *) "self",(char *) "colour", NULL
35933 };
35934
35935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35937 if (!SWIG_IsOK(res1)) {
35938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35939 }
35940 arg1 = reinterpret_cast< wxWindow * >(argp1);
35941 {
35942 arg2 = &temp2;
35943 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35944 }
35945 {
35946 PyThreadState* __tstate = wxPyBeginAllowThreads();
35947 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35948 wxPyEndAllowThreads(__tstate);
35949 if (PyErr_Occurred()) SWIG_fail;
35950 }
35951 resultobj = SWIG_Py_Void();
35952 return resultobj;
35953 fail:
35954 return NULL;
35955 }
35956
35957
35958 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35959 PyObject *resultobj = 0;
35960 wxWindow *arg1 = (wxWindow *) 0 ;
35961 wxColour *arg2 = 0 ;
35962 bool result;
35963 void *argp1 = 0 ;
35964 int res1 = 0 ;
35965 wxColour temp2 ;
35966 PyObject * obj0 = 0 ;
35967 PyObject * obj1 = 0 ;
35968 char * kwnames[] = {
35969 (char *) "self",(char *) "colour", NULL
35970 };
35971
35972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35974 if (!SWIG_IsOK(res1)) {
35975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35976 }
35977 arg1 = reinterpret_cast< wxWindow * >(argp1);
35978 {
35979 arg2 = &temp2;
35980 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35981 }
35982 {
35983 PyThreadState* __tstate = wxPyBeginAllowThreads();
35984 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35985 wxPyEndAllowThreads(__tstate);
35986 if (PyErr_Occurred()) SWIG_fail;
35987 }
35988 {
35989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35990 }
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35998 PyObject *resultobj = 0;
35999 wxWindow *arg1 = (wxWindow *) 0 ;
36000 wxColour *arg2 = 0 ;
36001 void *argp1 = 0 ;
36002 int res1 = 0 ;
36003 wxColour temp2 ;
36004 PyObject * obj0 = 0 ;
36005 PyObject * obj1 = 0 ;
36006 char * kwnames[] = {
36007 (char *) "self",(char *) "colour", NULL
36008 };
36009
36010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36012 if (!SWIG_IsOK(res1)) {
36013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36014 }
36015 arg1 = reinterpret_cast< wxWindow * >(argp1);
36016 {
36017 arg2 = &temp2;
36018 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36019 }
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 resultobj = SWIG_Py_Void();
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36034 PyObject *resultobj = 0;
36035 wxWindow *arg1 = (wxWindow *) 0 ;
36036 wxColour result;
36037 void *argp1 = 0 ;
36038 int res1 = 0 ;
36039 PyObject *swig_obj[1] ;
36040
36041 if (!args) SWIG_fail;
36042 swig_obj[0] = args;
36043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36044 if (!SWIG_IsOK(res1)) {
36045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36046 }
36047 arg1 = reinterpret_cast< wxWindow * >(argp1);
36048 {
36049 PyThreadState* __tstate = wxPyBeginAllowThreads();
36050 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36051 wxPyEndAllowThreads(__tstate);
36052 if (PyErr_Occurred()) SWIG_fail;
36053 }
36054 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36062 PyObject *resultobj = 0;
36063 wxWindow *arg1 = (wxWindow *) 0 ;
36064 wxColour result;
36065 void *argp1 = 0 ;
36066 int res1 = 0 ;
36067 PyObject *swig_obj[1] ;
36068
36069 if (!args) SWIG_fail;
36070 swig_obj[0] = args;
36071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36072 if (!SWIG_IsOK(res1)) {
36073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36074 }
36075 arg1 = reinterpret_cast< wxWindow * >(argp1);
36076 {
36077 PyThreadState* __tstate = wxPyBeginAllowThreads();
36078 result = ((wxWindow const *)arg1)->GetForegroundColour();
36079 wxPyEndAllowThreads(__tstate);
36080 if (PyErr_Occurred()) SWIG_fail;
36081 }
36082 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36083 return resultobj;
36084 fail:
36085 return NULL;
36086 }
36087
36088
36089 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36090 PyObject *resultobj = 0;
36091 wxWindow *arg1 = (wxWindow *) 0 ;
36092 bool result;
36093 void *argp1 = 0 ;
36094 int res1 = 0 ;
36095 PyObject *swig_obj[1] ;
36096
36097 if (!args) SWIG_fail;
36098 swig_obj[0] = args;
36099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36100 if (!SWIG_IsOK(res1)) {
36101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36102 }
36103 arg1 = reinterpret_cast< wxWindow * >(argp1);
36104 {
36105 PyThreadState* __tstate = wxPyBeginAllowThreads();
36106 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36107 wxPyEndAllowThreads(__tstate);
36108 if (PyErr_Occurred()) SWIG_fail;
36109 }
36110 {
36111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36112 }
36113 return resultobj;
36114 fail:
36115 return NULL;
36116 }
36117
36118
36119 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36120 PyObject *resultobj = 0;
36121 wxWindow *arg1 = (wxWindow *) 0 ;
36122 bool result;
36123 void *argp1 = 0 ;
36124 int res1 = 0 ;
36125 PyObject *swig_obj[1] ;
36126
36127 if (!args) SWIG_fail;
36128 swig_obj[0] = args;
36129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36130 if (!SWIG_IsOK(res1)) {
36131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36132 }
36133 arg1 = reinterpret_cast< wxWindow * >(argp1);
36134 {
36135 PyThreadState* __tstate = wxPyBeginAllowThreads();
36136 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36137 wxPyEndAllowThreads(__tstate);
36138 if (PyErr_Occurred()) SWIG_fail;
36139 }
36140 {
36141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36142 }
36143 return resultobj;
36144 fail:
36145 return NULL;
36146 }
36147
36148
36149 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36150 PyObject *resultobj = 0;
36151 wxWindow *arg1 = (wxWindow *) 0 ;
36152 wxBackgroundStyle arg2 ;
36153 bool result;
36154 void *argp1 = 0 ;
36155 int res1 = 0 ;
36156 int val2 ;
36157 int ecode2 = 0 ;
36158 PyObject * obj0 = 0 ;
36159 PyObject * obj1 = 0 ;
36160 char * kwnames[] = {
36161 (char *) "self",(char *) "style", NULL
36162 };
36163
36164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36166 if (!SWIG_IsOK(res1)) {
36167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36168 }
36169 arg1 = reinterpret_cast< wxWindow * >(argp1);
36170 ecode2 = SWIG_AsVal_int(obj1, &val2);
36171 if (!SWIG_IsOK(ecode2)) {
36172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36173 }
36174 arg2 = static_cast< wxBackgroundStyle >(val2);
36175 {
36176 PyThreadState* __tstate = wxPyBeginAllowThreads();
36177 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 {
36182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36183 }
36184 return resultobj;
36185 fail:
36186 return NULL;
36187 }
36188
36189
36190 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36191 PyObject *resultobj = 0;
36192 wxWindow *arg1 = (wxWindow *) 0 ;
36193 wxBackgroundStyle result;
36194 void *argp1 = 0 ;
36195 int res1 = 0 ;
36196 PyObject *swig_obj[1] ;
36197
36198 if (!args) SWIG_fail;
36199 swig_obj[0] = args;
36200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36201 if (!SWIG_IsOK(res1)) {
36202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36203 }
36204 arg1 = reinterpret_cast< wxWindow * >(argp1);
36205 {
36206 PyThreadState* __tstate = wxPyBeginAllowThreads();
36207 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36208 wxPyEndAllowThreads(__tstate);
36209 if (PyErr_Occurred()) SWIG_fail;
36210 }
36211 resultobj = SWIG_From_int(static_cast< int >(result));
36212 return resultobj;
36213 fail:
36214 return NULL;
36215 }
36216
36217
36218 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36219 PyObject *resultobj = 0;
36220 wxWindow *arg1 = (wxWindow *) 0 ;
36221 bool result;
36222 void *argp1 = 0 ;
36223 int res1 = 0 ;
36224 PyObject *swig_obj[1] ;
36225
36226 if (!args) SWIG_fail;
36227 swig_obj[0] = args;
36228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36229 if (!SWIG_IsOK(res1)) {
36230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36231 }
36232 arg1 = reinterpret_cast< wxWindow * >(argp1);
36233 {
36234 PyThreadState* __tstate = wxPyBeginAllowThreads();
36235 result = (bool)(arg1)->HasTransparentBackground();
36236 wxPyEndAllowThreads(__tstate);
36237 if (PyErr_Occurred()) SWIG_fail;
36238 }
36239 {
36240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36241 }
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36249 PyObject *resultobj = 0;
36250 wxWindow *arg1 = (wxWindow *) 0 ;
36251 wxCursor *arg2 = 0 ;
36252 bool result;
36253 void *argp1 = 0 ;
36254 int res1 = 0 ;
36255 void *argp2 = 0 ;
36256 int res2 = 0 ;
36257 PyObject * obj0 = 0 ;
36258 PyObject * obj1 = 0 ;
36259 char * kwnames[] = {
36260 (char *) "self",(char *) "cursor", NULL
36261 };
36262
36263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36265 if (!SWIG_IsOK(res1)) {
36266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36267 }
36268 arg1 = reinterpret_cast< wxWindow * >(argp1);
36269 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36270 if (!SWIG_IsOK(res2)) {
36271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36272 }
36273 if (!argp2) {
36274 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36275 }
36276 arg2 = reinterpret_cast< wxCursor * >(argp2);
36277 {
36278 PyThreadState* __tstate = wxPyBeginAllowThreads();
36279 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36280 wxPyEndAllowThreads(__tstate);
36281 if (PyErr_Occurred()) SWIG_fail;
36282 }
36283 {
36284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36285 }
36286 return resultobj;
36287 fail:
36288 return NULL;
36289 }
36290
36291
36292 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36293 PyObject *resultobj = 0;
36294 wxWindow *arg1 = (wxWindow *) 0 ;
36295 wxCursor result;
36296 void *argp1 = 0 ;
36297 int res1 = 0 ;
36298 PyObject *swig_obj[1] ;
36299
36300 if (!args) SWIG_fail;
36301 swig_obj[0] = args;
36302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36303 if (!SWIG_IsOK(res1)) {
36304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36305 }
36306 arg1 = reinterpret_cast< wxWindow * >(argp1);
36307 {
36308 PyThreadState* __tstate = wxPyBeginAllowThreads();
36309 result = (arg1)->GetCursor();
36310 wxPyEndAllowThreads(__tstate);
36311 if (PyErr_Occurred()) SWIG_fail;
36312 }
36313 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36314 return resultobj;
36315 fail:
36316 return NULL;
36317 }
36318
36319
36320 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36321 PyObject *resultobj = 0;
36322 wxWindow *arg1 = (wxWindow *) 0 ;
36323 wxFont *arg2 = 0 ;
36324 bool result;
36325 void *argp1 = 0 ;
36326 int res1 = 0 ;
36327 void *argp2 = 0 ;
36328 int res2 = 0 ;
36329 PyObject * obj0 = 0 ;
36330 PyObject * obj1 = 0 ;
36331 char * kwnames[] = {
36332 (char *) "self",(char *) "font", NULL
36333 };
36334
36335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36337 if (!SWIG_IsOK(res1)) {
36338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36339 }
36340 arg1 = reinterpret_cast< wxWindow * >(argp1);
36341 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36342 if (!SWIG_IsOK(res2)) {
36343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36344 }
36345 if (!argp2) {
36346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36347 }
36348 arg2 = reinterpret_cast< wxFont * >(argp2);
36349 {
36350 PyThreadState* __tstate = wxPyBeginAllowThreads();
36351 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36352 wxPyEndAllowThreads(__tstate);
36353 if (PyErr_Occurred()) SWIG_fail;
36354 }
36355 {
36356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36357 }
36358 return resultobj;
36359 fail:
36360 return NULL;
36361 }
36362
36363
36364 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36365 PyObject *resultobj = 0;
36366 wxWindow *arg1 = (wxWindow *) 0 ;
36367 wxFont *arg2 = 0 ;
36368 void *argp1 = 0 ;
36369 int res1 = 0 ;
36370 void *argp2 = 0 ;
36371 int res2 = 0 ;
36372 PyObject * obj0 = 0 ;
36373 PyObject * obj1 = 0 ;
36374 char * kwnames[] = {
36375 (char *) "self",(char *) "font", NULL
36376 };
36377
36378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36380 if (!SWIG_IsOK(res1)) {
36381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36382 }
36383 arg1 = reinterpret_cast< wxWindow * >(argp1);
36384 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36385 if (!SWIG_IsOK(res2)) {
36386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36387 }
36388 if (!argp2) {
36389 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36390 }
36391 arg2 = reinterpret_cast< wxFont * >(argp2);
36392 {
36393 PyThreadState* __tstate = wxPyBeginAllowThreads();
36394 (arg1)->SetOwnFont((wxFont const &)*arg2);
36395 wxPyEndAllowThreads(__tstate);
36396 if (PyErr_Occurred()) SWIG_fail;
36397 }
36398 resultobj = SWIG_Py_Void();
36399 return resultobj;
36400 fail:
36401 return NULL;
36402 }
36403
36404
36405 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36406 PyObject *resultobj = 0;
36407 wxWindow *arg1 = (wxWindow *) 0 ;
36408 wxFont result;
36409 void *argp1 = 0 ;
36410 int res1 = 0 ;
36411 PyObject *swig_obj[1] ;
36412
36413 if (!args) SWIG_fail;
36414 swig_obj[0] = args;
36415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36416 if (!SWIG_IsOK(res1)) {
36417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36418 }
36419 arg1 = reinterpret_cast< wxWindow * >(argp1);
36420 {
36421 PyThreadState* __tstate = wxPyBeginAllowThreads();
36422 result = (arg1)->GetFont();
36423 wxPyEndAllowThreads(__tstate);
36424 if (PyErr_Occurred()) SWIG_fail;
36425 }
36426 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36427 return resultobj;
36428 fail:
36429 return NULL;
36430 }
36431
36432
36433 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36434 PyObject *resultobj = 0;
36435 wxWindow *arg1 = (wxWindow *) 0 ;
36436 wxCaret *arg2 = (wxCaret *) 0 ;
36437 void *argp1 = 0 ;
36438 int res1 = 0 ;
36439 int res2 = 0 ;
36440 PyObject * obj0 = 0 ;
36441 PyObject * obj1 = 0 ;
36442 char * kwnames[] = {
36443 (char *) "self",(char *) "caret", NULL
36444 };
36445
36446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36448 if (!SWIG_IsOK(res1)) {
36449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36450 }
36451 arg1 = reinterpret_cast< wxWindow * >(argp1);
36452 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36453 if (!SWIG_IsOK(res2)) {
36454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36455 }
36456 {
36457 PyThreadState* __tstate = wxPyBeginAllowThreads();
36458 (arg1)->SetCaret(arg2);
36459 wxPyEndAllowThreads(__tstate);
36460 if (PyErr_Occurred()) SWIG_fail;
36461 }
36462 resultobj = SWIG_Py_Void();
36463 return resultobj;
36464 fail:
36465 return NULL;
36466 }
36467
36468
36469 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36470 PyObject *resultobj = 0;
36471 wxWindow *arg1 = (wxWindow *) 0 ;
36472 wxCaret *result = 0 ;
36473 void *argp1 = 0 ;
36474 int res1 = 0 ;
36475 PyObject *swig_obj[1] ;
36476
36477 if (!args) SWIG_fail;
36478 swig_obj[0] = args;
36479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36480 if (!SWIG_IsOK(res1)) {
36481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36482 }
36483 arg1 = reinterpret_cast< wxWindow * >(argp1);
36484 {
36485 PyThreadState* __tstate = wxPyBeginAllowThreads();
36486 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36487 wxPyEndAllowThreads(__tstate);
36488 if (PyErr_Occurred()) SWIG_fail;
36489 }
36490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36491 return resultobj;
36492 fail:
36493 return NULL;
36494 }
36495
36496
36497 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36498 PyObject *resultobj = 0;
36499 wxWindow *arg1 = (wxWindow *) 0 ;
36500 int result;
36501 void *argp1 = 0 ;
36502 int res1 = 0 ;
36503 PyObject *swig_obj[1] ;
36504
36505 if (!args) SWIG_fail;
36506 swig_obj[0] = args;
36507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36508 if (!SWIG_IsOK(res1)) {
36509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36510 }
36511 arg1 = reinterpret_cast< wxWindow * >(argp1);
36512 {
36513 PyThreadState* __tstate = wxPyBeginAllowThreads();
36514 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36515 wxPyEndAllowThreads(__tstate);
36516 if (PyErr_Occurred()) SWIG_fail;
36517 }
36518 resultobj = SWIG_From_int(static_cast< int >(result));
36519 return resultobj;
36520 fail:
36521 return NULL;
36522 }
36523
36524
36525 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36526 PyObject *resultobj = 0;
36527 wxWindow *arg1 = (wxWindow *) 0 ;
36528 int result;
36529 void *argp1 = 0 ;
36530 int res1 = 0 ;
36531 PyObject *swig_obj[1] ;
36532
36533 if (!args) SWIG_fail;
36534 swig_obj[0] = args;
36535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36536 if (!SWIG_IsOK(res1)) {
36537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36538 }
36539 arg1 = reinterpret_cast< wxWindow * >(argp1);
36540 {
36541 PyThreadState* __tstate = wxPyBeginAllowThreads();
36542 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36543 wxPyEndAllowThreads(__tstate);
36544 if (PyErr_Occurred()) SWIG_fail;
36545 }
36546 resultobj = SWIG_From_int(static_cast< int >(result));
36547 return resultobj;
36548 fail:
36549 return NULL;
36550 }
36551
36552
36553 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36554 PyObject *resultobj = 0;
36555 wxWindow *arg1 = (wxWindow *) 0 ;
36556 wxString *arg2 = 0 ;
36557 int *arg3 = (int *) 0 ;
36558 int *arg4 = (int *) 0 ;
36559 void *argp1 = 0 ;
36560 int res1 = 0 ;
36561 bool temp2 = false ;
36562 int temp3 ;
36563 int res3 = SWIG_TMPOBJ ;
36564 int temp4 ;
36565 int res4 = SWIG_TMPOBJ ;
36566 PyObject * obj0 = 0 ;
36567 PyObject * obj1 = 0 ;
36568 char * kwnames[] = {
36569 (char *) "self",(char *) "string", NULL
36570 };
36571
36572 arg3 = &temp3;
36573 arg4 = &temp4;
36574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36576 if (!SWIG_IsOK(res1)) {
36577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36578 }
36579 arg1 = reinterpret_cast< wxWindow * >(argp1);
36580 {
36581 arg2 = wxString_in_helper(obj1);
36582 if (arg2 == NULL) SWIG_fail;
36583 temp2 = true;
36584 }
36585 {
36586 PyThreadState* __tstate = wxPyBeginAllowThreads();
36587 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36588 wxPyEndAllowThreads(__tstate);
36589 if (PyErr_Occurred()) SWIG_fail;
36590 }
36591 resultobj = SWIG_Py_Void();
36592 if (SWIG_IsTmpObj(res3)) {
36593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36594 } else {
36595 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36597 }
36598 if (SWIG_IsTmpObj(res4)) {
36599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36600 } else {
36601 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36603 }
36604 {
36605 if (temp2)
36606 delete arg2;
36607 }
36608 return resultobj;
36609 fail:
36610 {
36611 if (temp2)
36612 delete arg2;
36613 }
36614 return NULL;
36615 }
36616
36617
36618 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36619 PyObject *resultobj = 0;
36620 wxWindow *arg1 = (wxWindow *) 0 ;
36621 wxString *arg2 = 0 ;
36622 int *arg3 = (int *) 0 ;
36623 int *arg4 = (int *) 0 ;
36624 int *arg5 = (int *) 0 ;
36625 int *arg6 = (int *) 0 ;
36626 wxFont *arg7 = (wxFont *) NULL ;
36627 void *argp1 = 0 ;
36628 int res1 = 0 ;
36629 bool temp2 = false ;
36630 int temp3 ;
36631 int res3 = SWIG_TMPOBJ ;
36632 int temp4 ;
36633 int res4 = SWIG_TMPOBJ ;
36634 int temp5 ;
36635 int res5 = SWIG_TMPOBJ ;
36636 int temp6 ;
36637 int res6 = SWIG_TMPOBJ ;
36638 void *argp7 = 0 ;
36639 int res7 = 0 ;
36640 PyObject * obj0 = 0 ;
36641 PyObject * obj1 = 0 ;
36642 PyObject * obj2 = 0 ;
36643 char * kwnames[] = {
36644 (char *) "self",(char *) "string",(char *) "font", NULL
36645 };
36646
36647 arg3 = &temp3;
36648 arg4 = &temp4;
36649 arg5 = &temp5;
36650 arg6 = &temp6;
36651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36653 if (!SWIG_IsOK(res1)) {
36654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36655 }
36656 arg1 = reinterpret_cast< wxWindow * >(argp1);
36657 {
36658 arg2 = wxString_in_helper(obj1);
36659 if (arg2 == NULL) SWIG_fail;
36660 temp2 = true;
36661 }
36662 if (obj2) {
36663 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36664 if (!SWIG_IsOK(res7)) {
36665 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36666 }
36667 arg7 = reinterpret_cast< wxFont * >(argp7);
36668 }
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36672 wxPyEndAllowThreads(__tstate);
36673 if (PyErr_Occurred()) SWIG_fail;
36674 }
36675 resultobj = SWIG_Py_Void();
36676 if (SWIG_IsTmpObj(res3)) {
36677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36678 } else {
36679 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36681 }
36682 if (SWIG_IsTmpObj(res4)) {
36683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36684 } else {
36685 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36687 }
36688 if (SWIG_IsTmpObj(res5)) {
36689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36690 } else {
36691 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36693 }
36694 if (SWIG_IsTmpObj(res6)) {
36695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36696 } else {
36697 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36699 }
36700 {
36701 if (temp2)
36702 delete arg2;
36703 }
36704 return resultobj;
36705 fail:
36706 {
36707 if (temp2)
36708 delete arg2;
36709 }
36710 return NULL;
36711 }
36712
36713
36714 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36715 PyObject *resultobj = 0;
36716 wxWindow *arg1 = (wxWindow *) 0 ;
36717 int *arg2 = (int *) 0 ;
36718 int *arg3 = (int *) 0 ;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721 int temp2 ;
36722 int res2 = 0 ;
36723 int temp3 ;
36724 int res3 = 0 ;
36725 PyObject * obj0 = 0 ;
36726 PyObject * obj1 = 0 ;
36727 PyObject * obj2 = 0 ;
36728 char * kwnames[] = {
36729 (char *) "self",(char *) "x",(char *) "y", NULL
36730 };
36731
36732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36734 if (!SWIG_IsOK(res1)) {
36735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36736 }
36737 arg1 = reinterpret_cast< wxWindow * >(argp1);
36738 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36739 int val;
36740 int ecode = SWIG_AsVal_int(obj1, &val);
36741 if (!SWIG_IsOK(ecode)) {
36742 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36743 }
36744 temp2 = static_cast< int >(val);
36745 arg2 = &temp2;
36746 res2 = SWIG_AddTmpMask(ecode);
36747 }
36748 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36749 int val;
36750 int ecode = SWIG_AsVal_int(obj2, &val);
36751 if (!SWIG_IsOK(ecode)) {
36752 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36753 }
36754 temp3 = static_cast< int >(val);
36755 arg3 = &temp3;
36756 res3 = SWIG_AddTmpMask(ecode);
36757 }
36758 {
36759 PyThreadState* __tstate = wxPyBeginAllowThreads();
36760 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36761 wxPyEndAllowThreads(__tstate);
36762 if (PyErr_Occurred()) SWIG_fail;
36763 }
36764 resultobj = SWIG_Py_Void();
36765 if (SWIG_IsTmpObj(res2)) {
36766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36767 } else {
36768 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36770 }
36771 if (SWIG_IsTmpObj(res3)) {
36772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36773 } else {
36774 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36776 }
36777 return resultobj;
36778 fail:
36779 return NULL;
36780 }
36781
36782
36783 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36784 PyObject *resultobj = 0;
36785 wxWindow *arg1 = (wxWindow *) 0 ;
36786 int *arg2 = (int *) 0 ;
36787 int *arg3 = (int *) 0 ;
36788 void *argp1 = 0 ;
36789 int res1 = 0 ;
36790 int temp2 ;
36791 int res2 = 0 ;
36792 int temp3 ;
36793 int res3 = 0 ;
36794 PyObject * obj0 = 0 ;
36795 PyObject * obj1 = 0 ;
36796 PyObject * obj2 = 0 ;
36797 char * kwnames[] = {
36798 (char *) "self",(char *) "x",(char *) "y", NULL
36799 };
36800
36801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36803 if (!SWIG_IsOK(res1)) {
36804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36805 }
36806 arg1 = reinterpret_cast< wxWindow * >(argp1);
36807 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36808 int val;
36809 int ecode = SWIG_AsVal_int(obj1, &val);
36810 if (!SWIG_IsOK(ecode)) {
36811 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36812 }
36813 temp2 = static_cast< int >(val);
36814 arg2 = &temp2;
36815 res2 = SWIG_AddTmpMask(ecode);
36816 }
36817 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36818 int val;
36819 int ecode = SWIG_AsVal_int(obj2, &val);
36820 if (!SWIG_IsOK(ecode)) {
36821 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36822 }
36823 temp3 = static_cast< int >(val);
36824 arg3 = &temp3;
36825 res3 = SWIG_AddTmpMask(ecode);
36826 }
36827 {
36828 PyThreadState* __tstate = wxPyBeginAllowThreads();
36829 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36830 wxPyEndAllowThreads(__tstate);
36831 if (PyErr_Occurred()) SWIG_fail;
36832 }
36833 resultobj = SWIG_Py_Void();
36834 if (SWIG_IsTmpObj(res2)) {
36835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36836 } else {
36837 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36839 }
36840 if (SWIG_IsTmpObj(res3)) {
36841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36842 } else {
36843 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36845 }
36846 return resultobj;
36847 fail:
36848 return NULL;
36849 }
36850
36851
36852 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36853 PyObject *resultobj = 0;
36854 wxWindow *arg1 = (wxWindow *) 0 ;
36855 wxPoint *arg2 = 0 ;
36856 wxPoint result;
36857 void *argp1 = 0 ;
36858 int res1 = 0 ;
36859 wxPoint temp2 ;
36860 PyObject * obj0 = 0 ;
36861 PyObject * obj1 = 0 ;
36862 char * kwnames[] = {
36863 (char *) "self",(char *) "pt", NULL
36864 };
36865
36866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36868 if (!SWIG_IsOK(res1)) {
36869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36870 }
36871 arg1 = reinterpret_cast< wxWindow * >(argp1);
36872 {
36873 arg2 = &temp2;
36874 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36875 }
36876 {
36877 PyThreadState* __tstate = wxPyBeginAllowThreads();
36878 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36879 wxPyEndAllowThreads(__tstate);
36880 if (PyErr_Occurred()) SWIG_fail;
36881 }
36882 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36883 return resultobj;
36884 fail:
36885 return NULL;
36886 }
36887
36888
36889 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36890 PyObject *resultobj = 0;
36891 wxWindow *arg1 = (wxWindow *) 0 ;
36892 wxPoint *arg2 = 0 ;
36893 wxPoint result;
36894 void *argp1 = 0 ;
36895 int res1 = 0 ;
36896 wxPoint temp2 ;
36897 PyObject * obj0 = 0 ;
36898 PyObject * obj1 = 0 ;
36899 char * kwnames[] = {
36900 (char *) "self",(char *) "pt", NULL
36901 };
36902
36903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36905 if (!SWIG_IsOK(res1)) {
36906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36907 }
36908 arg1 = reinterpret_cast< wxWindow * >(argp1);
36909 {
36910 arg2 = &temp2;
36911 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36912 }
36913 {
36914 PyThreadState* __tstate = wxPyBeginAllowThreads();
36915 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36916 wxPyEndAllowThreads(__tstate);
36917 if (PyErr_Occurred()) SWIG_fail;
36918 }
36919 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36920 return resultobj;
36921 fail:
36922 return NULL;
36923 }
36924
36925
36926 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36927 PyObject *resultobj = 0;
36928 wxWindow *arg1 = (wxWindow *) 0 ;
36929 int arg2 ;
36930 int arg3 ;
36931 wxHitTest result;
36932 void *argp1 = 0 ;
36933 int res1 = 0 ;
36934 int val2 ;
36935 int ecode2 = 0 ;
36936 int val3 ;
36937 int ecode3 = 0 ;
36938 PyObject * obj0 = 0 ;
36939 PyObject * obj1 = 0 ;
36940 PyObject * obj2 = 0 ;
36941 char * kwnames[] = {
36942 (char *) "self",(char *) "x",(char *) "y", NULL
36943 };
36944
36945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36947 if (!SWIG_IsOK(res1)) {
36948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36949 }
36950 arg1 = reinterpret_cast< wxWindow * >(argp1);
36951 ecode2 = SWIG_AsVal_int(obj1, &val2);
36952 if (!SWIG_IsOK(ecode2)) {
36953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36954 }
36955 arg2 = static_cast< int >(val2);
36956 ecode3 = SWIG_AsVal_int(obj2, &val3);
36957 if (!SWIG_IsOK(ecode3)) {
36958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36959 }
36960 arg3 = static_cast< int >(val3);
36961 {
36962 PyThreadState* __tstate = wxPyBeginAllowThreads();
36963 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36964 wxPyEndAllowThreads(__tstate);
36965 if (PyErr_Occurred()) SWIG_fail;
36966 }
36967 resultobj = SWIG_From_int(static_cast< int >(result));
36968 return resultobj;
36969 fail:
36970 return NULL;
36971 }
36972
36973
36974 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36975 PyObject *resultobj = 0;
36976 wxWindow *arg1 = (wxWindow *) 0 ;
36977 wxPoint *arg2 = 0 ;
36978 wxHitTest result;
36979 void *argp1 = 0 ;
36980 int res1 = 0 ;
36981 wxPoint temp2 ;
36982 PyObject * obj0 = 0 ;
36983 PyObject * obj1 = 0 ;
36984 char * kwnames[] = {
36985 (char *) "self",(char *) "pt", NULL
36986 };
36987
36988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36990 if (!SWIG_IsOK(res1)) {
36991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36992 }
36993 arg1 = reinterpret_cast< wxWindow * >(argp1);
36994 {
36995 arg2 = &temp2;
36996 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36997 }
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 resultobj = SWIG_From_int(static_cast< int >(result));
37005 return resultobj;
37006 fail:
37007 return NULL;
37008 }
37009
37010
37011 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37012 PyObject *resultobj = 0;
37013 wxWindow *arg1 = (wxWindow *) 0 ;
37014 long arg2 ;
37015 wxBorder result;
37016 void *argp1 = 0 ;
37017 int res1 = 0 ;
37018 long val2 ;
37019 int ecode2 = 0 ;
37020
37021 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37023 if (!SWIG_IsOK(res1)) {
37024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37025 }
37026 arg1 = reinterpret_cast< wxWindow * >(argp1);
37027 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37028 if (!SWIG_IsOK(ecode2)) {
37029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37030 }
37031 arg2 = static_cast< long >(val2);
37032 {
37033 PyThreadState* __tstate = wxPyBeginAllowThreads();
37034 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 resultobj = SWIG_From_int(static_cast< int >(result));
37039 return resultobj;
37040 fail:
37041 return NULL;
37042 }
37043
37044
37045 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37046 PyObject *resultobj = 0;
37047 wxWindow *arg1 = (wxWindow *) 0 ;
37048 wxBorder result;
37049 void *argp1 = 0 ;
37050 int res1 = 0 ;
37051
37052 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37054 if (!SWIG_IsOK(res1)) {
37055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37056 }
37057 arg1 = reinterpret_cast< wxWindow * >(argp1);
37058 {
37059 PyThreadState* __tstate = wxPyBeginAllowThreads();
37060 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37061 wxPyEndAllowThreads(__tstate);
37062 if (PyErr_Occurred()) SWIG_fail;
37063 }
37064 resultobj = SWIG_From_int(static_cast< int >(result));
37065 return resultobj;
37066 fail:
37067 return NULL;
37068 }
37069
37070
37071 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37072 int argc;
37073 PyObject *argv[3];
37074
37075 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37076 --argc;
37077 if (argc == 1) {
37078 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37079 }
37080 if (argc == 2) {
37081 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37082 }
37083
37084 fail:
37085 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37086 return NULL;
37087 }
37088
37089
37090 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37091 PyObject *resultobj = 0;
37092 wxWindow *arg1 = (wxWindow *) 0 ;
37093 long arg2 = (long) wxUPDATE_UI_NONE ;
37094 void *argp1 = 0 ;
37095 int res1 = 0 ;
37096 long val2 ;
37097 int ecode2 = 0 ;
37098 PyObject * obj0 = 0 ;
37099 PyObject * obj1 = 0 ;
37100 char * kwnames[] = {
37101 (char *) "self",(char *) "flags", NULL
37102 };
37103
37104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37106 if (!SWIG_IsOK(res1)) {
37107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37108 }
37109 arg1 = reinterpret_cast< wxWindow * >(argp1);
37110 if (obj1) {
37111 ecode2 = SWIG_AsVal_long(obj1, &val2);
37112 if (!SWIG_IsOK(ecode2)) {
37113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37114 }
37115 arg2 = static_cast< long >(val2);
37116 }
37117 {
37118 PyThreadState* __tstate = wxPyBeginAllowThreads();
37119 (arg1)->UpdateWindowUI(arg2);
37120 wxPyEndAllowThreads(__tstate);
37121 if (PyErr_Occurred()) SWIG_fail;
37122 }
37123 resultobj = SWIG_Py_Void();
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj = 0;
37132 wxWindow *arg1 = (wxWindow *) 0 ;
37133 wxMenu *arg2 = (wxMenu *) 0 ;
37134 int arg3 = (int) -1 ;
37135 int arg4 = (int) -1 ;
37136 bool result;
37137 void *argp1 = 0 ;
37138 int res1 = 0 ;
37139 void *argp2 = 0 ;
37140 int res2 = 0 ;
37141 int val3 ;
37142 int ecode3 = 0 ;
37143 int val4 ;
37144 int ecode4 = 0 ;
37145 PyObject * obj0 = 0 ;
37146 PyObject * obj1 = 0 ;
37147 PyObject * obj2 = 0 ;
37148 PyObject * obj3 = 0 ;
37149 char * kwnames[] = {
37150 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37151 };
37152
37153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37155 if (!SWIG_IsOK(res1)) {
37156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37157 }
37158 arg1 = reinterpret_cast< wxWindow * >(argp1);
37159 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37160 if (!SWIG_IsOK(res2)) {
37161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37162 }
37163 arg2 = reinterpret_cast< wxMenu * >(argp2);
37164 if (obj2) {
37165 ecode3 = SWIG_AsVal_int(obj2, &val3);
37166 if (!SWIG_IsOK(ecode3)) {
37167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37168 }
37169 arg3 = static_cast< int >(val3);
37170 }
37171 if (obj3) {
37172 ecode4 = SWIG_AsVal_int(obj3, &val4);
37173 if (!SWIG_IsOK(ecode4)) {
37174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37175 }
37176 arg4 = static_cast< int >(val4);
37177 }
37178 {
37179 PyThreadState* __tstate = wxPyBeginAllowThreads();
37180 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37181 wxPyEndAllowThreads(__tstate);
37182 if (PyErr_Occurred()) SWIG_fail;
37183 }
37184 {
37185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37186 }
37187 return resultobj;
37188 fail:
37189 return NULL;
37190 }
37191
37192
37193 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37194 PyObject *resultobj = 0;
37195 wxWindow *arg1 = (wxWindow *) 0 ;
37196 wxMenu *arg2 = (wxMenu *) 0 ;
37197 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37198 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37199 bool result;
37200 void *argp1 = 0 ;
37201 int res1 = 0 ;
37202 void *argp2 = 0 ;
37203 int res2 = 0 ;
37204 wxPoint temp3 ;
37205 PyObject * obj0 = 0 ;
37206 PyObject * obj1 = 0 ;
37207 PyObject * obj2 = 0 ;
37208 char * kwnames[] = {
37209 (char *) "self",(char *) "menu",(char *) "pos", NULL
37210 };
37211
37212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37214 if (!SWIG_IsOK(res1)) {
37215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37216 }
37217 arg1 = reinterpret_cast< wxWindow * >(argp1);
37218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37219 if (!SWIG_IsOK(res2)) {
37220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37221 }
37222 arg2 = reinterpret_cast< wxMenu * >(argp2);
37223 if (obj2) {
37224 {
37225 arg3 = &temp3;
37226 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37227 }
37228 }
37229 {
37230 PyThreadState* __tstate = wxPyBeginAllowThreads();
37231 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37232 wxPyEndAllowThreads(__tstate);
37233 if (PyErr_Occurred()) SWIG_fail;
37234 }
37235 {
37236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37237 }
37238 return resultobj;
37239 fail:
37240 return NULL;
37241 }
37242
37243
37244 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37245 PyObject *resultobj = 0;
37246 wxWindow *arg1 = (wxWindow *) 0 ;
37247 bool result;
37248 void *argp1 = 0 ;
37249 int res1 = 0 ;
37250 PyObject *swig_obj[1] ;
37251
37252 if (!args) SWIG_fail;
37253 swig_obj[0] = args;
37254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37255 if (!SWIG_IsOK(res1)) {
37256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37257 }
37258 arg1 = reinterpret_cast< wxWindow * >(argp1);
37259 {
37260 PyThreadState* __tstate = wxPyBeginAllowThreads();
37261 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37262 wxPyEndAllowThreads(__tstate);
37263 if (PyErr_Occurred()) SWIG_fail;
37264 }
37265 {
37266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37267 }
37268 return resultobj;
37269 fail:
37270 return NULL;
37271 }
37272
37273
37274 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37275 PyObject *resultobj = 0;
37276 wxWindow *arg1 = (wxWindow *) 0 ;
37277 long result;
37278 void *argp1 = 0 ;
37279 int res1 = 0 ;
37280 PyObject *swig_obj[1] ;
37281
37282 if (!args) SWIG_fail;
37283 swig_obj[0] = args;
37284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37285 if (!SWIG_IsOK(res1)) {
37286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37287 }
37288 arg1 = reinterpret_cast< wxWindow * >(argp1);
37289 {
37290 PyThreadState* __tstate = wxPyBeginAllowThreads();
37291 result = (long)wxWindow_GetHandle(arg1);
37292 wxPyEndAllowThreads(__tstate);
37293 if (PyErr_Occurred()) SWIG_fail;
37294 }
37295 resultobj = SWIG_From_long(static_cast< long >(result));
37296 return resultobj;
37297 fail:
37298 return NULL;
37299 }
37300
37301
37302 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37303 PyObject *resultobj = 0;
37304 wxWindow *arg1 = (wxWindow *) 0 ;
37305 long arg2 ;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 long val2 ;
37309 int ecode2 = 0 ;
37310 PyObject * obj0 = 0 ;
37311 PyObject * obj1 = 0 ;
37312 char * kwnames[] = {
37313 (char *) "self",(char *) "handle", NULL
37314 };
37315
37316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37318 if (!SWIG_IsOK(res1)) {
37319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37320 }
37321 arg1 = reinterpret_cast< wxWindow * >(argp1);
37322 ecode2 = SWIG_AsVal_long(obj1, &val2);
37323 if (!SWIG_IsOK(ecode2)) {
37324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37325 }
37326 arg2 = static_cast< long >(val2);
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 wxWindow_AssociateHandle(arg1,arg2);
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 resultobj = SWIG_Py_Void();
37334 return resultobj;
37335 fail:
37336 return NULL;
37337 }
37338
37339
37340 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37341 PyObject *resultobj = 0;
37342 wxWindow *arg1 = (wxWindow *) 0 ;
37343 void *argp1 = 0 ;
37344 int res1 = 0 ;
37345 PyObject *swig_obj[1] ;
37346
37347 if (!args) SWIG_fail;
37348 swig_obj[0] = args;
37349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37350 if (!SWIG_IsOK(res1)) {
37351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37352 }
37353 arg1 = reinterpret_cast< wxWindow * >(argp1);
37354 {
37355 PyThreadState* __tstate = wxPyBeginAllowThreads();
37356 (arg1)->DissociateHandle();
37357 wxPyEndAllowThreads(__tstate);
37358 if (PyErr_Occurred()) SWIG_fail;
37359 }
37360 resultobj = SWIG_Py_Void();
37361 return resultobj;
37362 fail:
37363 return NULL;
37364 }
37365
37366
37367 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37368 PyObject *resultobj = 0;
37369 wxWindow *arg1 = (wxWindow *) 0 ;
37370 int arg2 ;
37371 bool result;
37372 void *argp1 = 0 ;
37373 int res1 = 0 ;
37374 int val2 ;
37375 int ecode2 = 0 ;
37376 PyObject * obj0 = 0 ;
37377 PyObject * obj1 = 0 ;
37378 char * kwnames[] = {
37379 (char *) "self",(char *) "orient", NULL
37380 };
37381
37382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37384 if (!SWIG_IsOK(res1)) {
37385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37386 }
37387 arg1 = reinterpret_cast< wxWindow * >(argp1);
37388 ecode2 = SWIG_AsVal_int(obj1, &val2);
37389 if (!SWIG_IsOK(ecode2)) {
37390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37391 }
37392 arg2 = static_cast< int >(val2);
37393 {
37394 PyThreadState* __tstate = wxPyBeginAllowThreads();
37395 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37396 wxPyEndAllowThreads(__tstate);
37397 if (PyErr_Occurred()) SWIG_fail;
37398 }
37399 {
37400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37401 }
37402 return resultobj;
37403 fail:
37404 return NULL;
37405 }
37406
37407
37408 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37409 PyObject *resultobj = 0;
37410 wxWindow *arg1 = (wxWindow *) 0 ;
37411 int arg2 ;
37412 int arg3 ;
37413 int arg4 ;
37414 int arg5 ;
37415 bool arg6 = (bool) true ;
37416 void *argp1 = 0 ;
37417 int res1 = 0 ;
37418 int val2 ;
37419 int ecode2 = 0 ;
37420 int val3 ;
37421 int ecode3 = 0 ;
37422 int val4 ;
37423 int ecode4 = 0 ;
37424 int val5 ;
37425 int ecode5 = 0 ;
37426 bool val6 ;
37427 int ecode6 = 0 ;
37428 PyObject * obj0 = 0 ;
37429 PyObject * obj1 = 0 ;
37430 PyObject * obj2 = 0 ;
37431 PyObject * obj3 = 0 ;
37432 PyObject * obj4 = 0 ;
37433 PyObject * obj5 = 0 ;
37434 char * kwnames[] = {
37435 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37436 };
37437
37438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37440 if (!SWIG_IsOK(res1)) {
37441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37442 }
37443 arg1 = reinterpret_cast< wxWindow * >(argp1);
37444 ecode2 = SWIG_AsVal_int(obj1, &val2);
37445 if (!SWIG_IsOK(ecode2)) {
37446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37447 }
37448 arg2 = static_cast< int >(val2);
37449 ecode3 = SWIG_AsVal_int(obj2, &val3);
37450 if (!SWIG_IsOK(ecode3)) {
37451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37452 }
37453 arg3 = static_cast< int >(val3);
37454 ecode4 = SWIG_AsVal_int(obj3, &val4);
37455 if (!SWIG_IsOK(ecode4)) {
37456 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37457 }
37458 arg4 = static_cast< int >(val4);
37459 ecode5 = SWIG_AsVal_int(obj4, &val5);
37460 if (!SWIG_IsOK(ecode5)) {
37461 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37462 }
37463 arg5 = static_cast< int >(val5);
37464 if (obj5) {
37465 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37466 if (!SWIG_IsOK(ecode6)) {
37467 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37468 }
37469 arg6 = static_cast< bool >(val6);
37470 }
37471 {
37472 PyThreadState* __tstate = wxPyBeginAllowThreads();
37473 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37474 wxPyEndAllowThreads(__tstate);
37475 if (PyErr_Occurred()) SWIG_fail;
37476 }
37477 resultobj = SWIG_Py_Void();
37478 return resultobj;
37479 fail:
37480 return NULL;
37481 }
37482
37483
37484 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37485 PyObject *resultobj = 0;
37486 wxWindow *arg1 = (wxWindow *) 0 ;
37487 int arg2 ;
37488 int arg3 ;
37489 bool arg4 = (bool) true ;
37490 void *argp1 = 0 ;
37491 int res1 = 0 ;
37492 int val2 ;
37493 int ecode2 = 0 ;
37494 int val3 ;
37495 int ecode3 = 0 ;
37496 bool val4 ;
37497 int ecode4 = 0 ;
37498 PyObject * obj0 = 0 ;
37499 PyObject * obj1 = 0 ;
37500 PyObject * obj2 = 0 ;
37501 PyObject * obj3 = 0 ;
37502 char * kwnames[] = {
37503 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37504 };
37505
37506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37508 if (!SWIG_IsOK(res1)) {
37509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37510 }
37511 arg1 = reinterpret_cast< wxWindow * >(argp1);
37512 ecode2 = SWIG_AsVal_int(obj1, &val2);
37513 if (!SWIG_IsOK(ecode2)) {
37514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37515 }
37516 arg2 = static_cast< int >(val2);
37517 ecode3 = SWIG_AsVal_int(obj2, &val3);
37518 if (!SWIG_IsOK(ecode3)) {
37519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37520 }
37521 arg3 = static_cast< int >(val3);
37522 if (obj3) {
37523 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37524 if (!SWIG_IsOK(ecode4)) {
37525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37526 }
37527 arg4 = static_cast< bool >(val4);
37528 }
37529 {
37530 PyThreadState* __tstate = wxPyBeginAllowThreads();
37531 (arg1)->SetScrollPos(arg2,arg3,arg4);
37532 wxPyEndAllowThreads(__tstate);
37533 if (PyErr_Occurred()) SWIG_fail;
37534 }
37535 resultobj = SWIG_Py_Void();
37536 return resultobj;
37537 fail:
37538 return NULL;
37539 }
37540
37541
37542 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37543 PyObject *resultobj = 0;
37544 wxWindow *arg1 = (wxWindow *) 0 ;
37545 int arg2 ;
37546 int result;
37547 void *argp1 = 0 ;
37548 int res1 = 0 ;
37549 int val2 ;
37550 int ecode2 = 0 ;
37551 PyObject * obj0 = 0 ;
37552 PyObject * obj1 = 0 ;
37553 char * kwnames[] = {
37554 (char *) "self",(char *) "orientation", NULL
37555 };
37556
37557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37559 if (!SWIG_IsOK(res1)) {
37560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37561 }
37562 arg1 = reinterpret_cast< wxWindow * >(argp1);
37563 ecode2 = SWIG_AsVal_int(obj1, &val2);
37564 if (!SWIG_IsOK(ecode2)) {
37565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37566 }
37567 arg2 = static_cast< int >(val2);
37568 {
37569 PyThreadState* __tstate = wxPyBeginAllowThreads();
37570 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37571 wxPyEndAllowThreads(__tstate);
37572 if (PyErr_Occurred()) SWIG_fail;
37573 }
37574 resultobj = SWIG_From_int(static_cast< int >(result));
37575 return resultobj;
37576 fail:
37577 return NULL;
37578 }
37579
37580
37581 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37582 PyObject *resultobj = 0;
37583 wxWindow *arg1 = (wxWindow *) 0 ;
37584 int arg2 ;
37585 int result;
37586 void *argp1 = 0 ;
37587 int res1 = 0 ;
37588 int val2 ;
37589 int ecode2 = 0 ;
37590 PyObject * obj0 = 0 ;
37591 PyObject * obj1 = 0 ;
37592 char * kwnames[] = {
37593 (char *) "self",(char *) "orientation", NULL
37594 };
37595
37596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37598 if (!SWIG_IsOK(res1)) {
37599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37600 }
37601 arg1 = reinterpret_cast< wxWindow * >(argp1);
37602 ecode2 = SWIG_AsVal_int(obj1, &val2);
37603 if (!SWIG_IsOK(ecode2)) {
37604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37605 }
37606 arg2 = static_cast< int >(val2);
37607 {
37608 PyThreadState* __tstate = wxPyBeginAllowThreads();
37609 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37610 wxPyEndAllowThreads(__tstate);
37611 if (PyErr_Occurred()) SWIG_fail;
37612 }
37613 resultobj = SWIG_From_int(static_cast< int >(result));
37614 return resultobj;
37615 fail:
37616 return NULL;
37617 }
37618
37619
37620 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37621 PyObject *resultobj = 0;
37622 wxWindow *arg1 = (wxWindow *) 0 ;
37623 int arg2 ;
37624 int result;
37625 void *argp1 = 0 ;
37626 int res1 = 0 ;
37627 int val2 ;
37628 int ecode2 = 0 ;
37629 PyObject * obj0 = 0 ;
37630 PyObject * obj1 = 0 ;
37631 char * kwnames[] = {
37632 (char *) "self",(char *) "orientation", NULL
37633 };
37634
37635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37637 if (!SWIG_IsOK(res1)) {
37638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37639 }
37640 arg1 = reinterpret_cast< wxWindow * >(argp1);
37641 ecode2 = SWIG_AsVal_int(obj1, &val2);
37642 if (!SWIG_IsOK(ecode2)) {
37643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37644 }
37645 arg2 = static_cast< int >(val2);
37646 {
37647 PyThreadState* __tstate = wxPyBeginAllowThreads();
37648 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37649 wxPyEndAllowThreads(__tstate);
37650 if (PyErr_Occurred()) SWIG_fail;
37651 }
37652 resultobj = SWIG_From_int(static_cast< int >(result));
37653 return resultobj;
37654 fail:
37655 return NULL;
37656 }
37657
37658
37659 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37660 PyObject *resultobj = 0;
37661 wxWindow *arg1 = (wxWindow *) 0 ;
37662 int arg2 ;
37663 int arg3 ;
37664 wxRect *arg4 = (wxRect *) NULL ;
37665 void *argp1 = 0 ;
37666 int res1 = 0 ;
37667 int val2 ;
37668 int ecode2 = 0 ;
37669 int val3 ;
37670 int ecode3 = 0 ;
37671 void *argp4 = 0 ;
37672 int res4 = 0 ;
37673 PyObject * obj0 = 0 ;
37674 PyObject * obj1 = 0 ;
37675 PyObject * obj2 = 0 ;
37676 PyObject * obj3 = 0 ;
37677 char * kwnames[] = {
37678 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37679 };
37680
37681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37683 if (!SWIG_IsOK(res1)) {
37684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37685 }
37686 arg1 = reinterpret_cast< wxWindow * >(argp1);
37687 ecode2 = SWIG_AsVal_int(obj1, &val2);
37688 if (!SWIG_IsOK(ecode2)) {
37689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37690 }
37691 arg2 = static_cast< int >(val2);
37692 ecode3 = SWIG_AsVal_int(obj2, &val3);
37693 if (!SWIG_IsOK(ecode3)) {
37694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37695 }
37696 arg3 = static_cast< int >(val3);
37697 if (obj3) {
37698 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37699 if (!SWIG_IsOK(res4)) {
37700 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37701 }
37702 arg4 = reinterpret_cast< wxRect * >(argp4);
37703 }
37704 {
37705 PyThreadState* __tstate = wxPyBeginAllowThreads();
37706 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37707 wxPyEndAllowThreads(__tstate);
37708 if (PyErr_Occurred()) SWIG_fail;
37709 }
37710 resultobj = SWIG_Py_Void();
37711 return resultobj;
37712 fail:
37713 return NULL;
37714 }
37715
37716
37717 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37718 PyObject *resultobj = 0;
37719 wxWindow *arg1 = (wxWindow *) 0 ;
37720 int arg2 ;
37721 bool result;
37722 void *argp1 = 0 ;
37723 int res1 = 0 ;
37724 int val2 ;
37725 int ecode2 = 0 ;
37726 PyObject * obj0 = 0 ;
37727 PyObject * obj1 = 0 ;
37728 char * kwnames[] = {
37729 (char *) "self",(char *) "lines", NULL
37730 };
37731
37732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37734 if (!SWIG_IsOK(res1)) {
37735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37736 }
37737 arg1 = reinterpret_cast< wxWindow * >(argp1);
37738 ecode2 = SWIG_AsVal_int(obj1, &val2);
37739 if (!SWIG_IsOK(ecode2)) {
37740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37741 }
37742 arg2 = static_cast< int >(val2);
37743 {
37744 PyThreadState* __tstate = wxPyBeginAllowThreads();
37745 result = (bool)(arg1)->ScrollLines(arg2);
37746 wxPyEndAllowThreads(__tstate);
37747 if (PyErr_Occurred()) SWIG_fail;
37748 }
37749 {
37750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37751 }
37752 return resultobj;
37753 fail:
37754 return NULL;
37755 }
37756
37757
37758 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37759 PyObject *resultobj = 0;
37760 wxWindow *arg1 = (wxWindow *) 0 ;
37761 int arg2 ;
37762 bool result;
37763 void *argp1 = 0 ;
37764 int res1 = 0 ;
37765 int val2 ;
37766 int ecode2 = 0 ;
37767 PyObject * obj0 = 0 ;
37768 PyObject * obj1 = 0 ;
37769 char * kwnames[] = {
37770 (char *) "self",(char *) "pages", NULL
37771 };
37772
37773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37775 if (!SWIG_IsOK(res1)) {
37776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37777 }
37778 arg1 = reinterpret_cast< wxWindow * >(argp1);
37779 ecode2 = SWIG_AsVal_int(obj1, &val2);
37780 if (!SWIG_IsOK(ecode2)) {
37781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37782 }
37783 arg2 = static_cast< int >(val2);
37784 {
37785 PyThreadState* __tstate = wxPyBeginAllowThreads();
37786 result = (bool)(arg1)->ScrollPages(arg2);
37787 wxPyEndAllowThreads(__tstate);
37788 if (PyErr_Occurred()) SWIG_fail;
37789 }
37790 {
37791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37792 }
37793 return resultobj;
37794 fail:
37795 return NULL;
37796 }
37797
37798
37799 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37800 PyObject *resultobj = 0;
37801 wxWindow *arg1 = (wxWindow *) 0 ;
37802 bool result;
37803 void *argp1 = 0 ;
37804 int res1 = 0 ;
37805 PyObject *swig_obj[1] ;
37806
37807 if (!args) SWIG_fail;
37808 swig_obj[0] = args;
37809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37810 if (!SWIG_IsOK(res1)) {
37811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37812 }
37813 arg1 = reinterpret_cast< wxWindow * >(argp1);
37814 {
37815 PyThreadState* __tstate = wxPyBeginAllowThreads();
37816 result = (bool)(arg1)->LineUp();
37817 wxPyEndAllowThreads(__tstate);
37818 if (PyErr_Occurred()) SWIG_fail;
37819 }
37820 {
37821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37822 }
37823 return resultobj;
37824 fail:
37825 return NULL;
37826 }
37827
37828
37829 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37830 PyObject *resultobj = 0;
37831 wxWindow *arg1 = (wxWindow *) 0 ;
37832 bool result;
37833 void *argp1 = 0 ;
37834 int res1 = 0 ;
37835 PyObject *swig_obj[1] ;
37836
37837 if (!args) SWIG_fail;
37838 swig_obj[0] = args;
37839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37840 if (!SWIG_IsOK(res1)) {
37841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37842 }
37843 arg1 = reinterpret_cast< wxWindow * >(argp1);
37844 {
37845 PyThreadState* __tstate = wxPyBeginAllowThreads();
37846 result = (bool)(arg1)->LineDown();
37847 wxPyEndAllowThreads(__tstate);
37848 if (PyErr_Occurred()) SWIG_fail;
37849 }
37850 {
37851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37852 }
37853 return resultobj;
37854 fail:
37855 return NULL;
37856 }
37857
37858
37859 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37860 PyObject *resultobj = 0;
37861 wxWindow *arg1 = (wxWindow *) 0 ;
37862 bool result;
37863 void *argp1 = 0 ;
37864 int res1 = 0 ;
37865 PyObject *swig_obj[1] ;
37866
37867 if (!args) SWIG_fail;
37868 swig_obj[0] = args;
37869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37870 if (!SWIG_IsOK(res1)) {
37871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37872 }
37873 arg1 = reinterpret_cast< wxWindow * >(argp1);
37874 {
37875 PyThreadState* __tstate = wxPyBeginAllowThreads();
37876 result = (bool)(arg1)->PageUp();
37877 wxPyEndAllowThreads(__tstate);
37878 if (PyErr_Occurred()) SWIG_fail;
37879 }
37880 {
37881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37882 }
37883 return resultobj;
37884 fail:
37885 return NULL;
37886 }
37887
37888
37889 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37890 PyObject *resultobj = 0;
37891 wxWindow *arg1 = (wxWindow *) 0 ;
37892 bool result;
37893 void *argp1 = 0 ;
37894 int res1 = 0 ;
37895 PyObject *swig_obj[1] ;
37896
37897 if (!args) SWIG_fail;
37898 swig_obj[0] = args;
37899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37900 if (!SWIG_IsOK(res1)) {
37901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37902 }
37903 arg1 = reinterpret_cast< wxWindow * >(argp1);
37904 {
37905 PyThreadState* __tstate = wxPyBeginAllowThreads();
37906 result = (bool)(arg1)->PageDown();
37907 wxPyEndAllowThreads(__tstate);
37908 if (PyErr_Occurred()) SWIG_fail;
37909 }
37910 {
37911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37912 }
37913 return resultobj;
37914 fail:
37915 return NULL;
37916 }
37917
37918
37919 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37920 PyObject *resultobj = 0;
37921 wxWindow *arg1 = (wxWindow *) 0 ;
37922 wxString *arg2 = 0 ;
37923 void *argp1 = 0 ;
37924 int res1 = 0 ;
37925 bool temp2 = false ;
37926 PyObject * obj0 = 0 ;
37927 PyObject * obj1 = 0 ;
37928 char * kwnames[] = {
37929 (char *) "self",(char *) "text", NULL
37930 };
37931
37932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37934 if (!SWIG_IsOK(res1)) {
37935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37936 }
37937 arg1 = reinterpret_cast< wxWindow * >(argp1);
37938 {
37939 arg2 = wxString_in_helper(obj1);
37940 if (arg2 == NULL) SWIG_fail;
37941 temp2 = true;
37942 }
37943 {
37944 PyThreadState* __tstate = wxPyBeginAllowThreads();
37945 (arg1)->SetHelpText((wxString const &)*arg2);
37946 wxPyEndAllowThreads(__tstate);
37947 if (PyErr_Occurred()) SWIG_fail;
37948 }
37949 resultobj = SWIG_Py_Void();
37950 {
37951 if (temp2)
37952 delete arg2;
37953 }
37954 return resultobj;
37955 fail:
37956 {
37957 if (temp2)
37958 delete arg2;
37959 }
37960 return NULL;
37961 }
37962
37963
37964 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37965 PyObject *resultobj = 0;
37966 wxWindow *arg1 = (wxWindow *) 0 ;
37967 wxString *arg2 = 0 ;
37968 void *argp1 = 0 ;
37969 int res1 = 0 ;
37970 bool temp2 = false ;
37971 PyObject * obj0 = 0 ;
37972 PyObject * obj1 = 0 ;
37973 char * kwnames[] = {
37974 (char *) "self",(char *) "text", NULL
37975 };
37976
37977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37979 if (!SWIG_IsOK(res1)) {
37980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37981 }
37982 arg1 = reinterpret_cast< wxWindow * >(argp1);
37983 {
37984 arg2 = wxString_in_helper(obj1);
37985 if (arg2 == NULL) SWIG_fail;
37986 temp2 = true;
37987 }
37988 {
37989 PyThreadState* __tstate = wxPyBeginAllowThreads();
37990 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37991 wxPyEndAllowThreads(__tstate);
37992 if (PyErr_Occurred()) SWIG_fail;
37993 }
37994 resultobj = SWIG_Py_Void();
37995 {
37996 if (temp2)
37997 delete arg2;
37998 }
37999 return resultobj;
38000 fail:
38001 {
38002 if (temp2)
38003 delete arg2;
38004 }
38005 return NULL;
38006 }
38007
38008
38009 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38010 PyObject *resultobj = 0;
38011 wxWindow *arg1 = (wxWindow *) 0 ;
38012 wxPoint *arg2 = 0 ;
38013 wxHelpEvent::Origin arg3 ;
38014 wxString result;
38015 void *argp1 = 0 ;
38016 int res1 = 0 ;
38017 wxPoint temp2 ;
38018 void *argp3 ;
38019 int res3 = 0 ;
38020 PyObject * obj0 = 0 ;
38021 PyObject * obj1 = 0 ;
38022 PyObject * obj2 = 0 ;
38023 char * kwnames[] = {
38024 (char *) "self",(char *) "pt",(char *) "origin", NULL
38025 };
38026
38027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38029 if (!SWIG_IsOK(res1)) {
38030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38031 }
38032 arg1 = reinterpret_cast< wxWindow * >(argp1);
38033 {
38034 arg2 = &temp2;
38035 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38036 }
38037 {
38038 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38039 if (!SWIG_IsOK(res3)) {
38040 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38041 }
38042 if (!argp3) {
38043 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38044 } else {
38045 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38046 arg3 = *temp;
38047 if (SWIG_IsNewObj(res3)) delete temp;
38048 }
38049 }
38050 {
38051 PyThreadState* __tstate = wxPyBeginAllowThreads();
38052 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38053 wxPyEndAllowThreads(__tstate);
38054 if (PyErr_Occurred()) SWIG_fail;
38055 }
38056 {
38057 #if wxUSE_UNICODE
38058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38059 #else
38060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38061 #endif
38062 }
38063 return resultobj;
38064 fail:
38065 return NULL;
38066 }
38067
38068
38069 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38070 PyObject *resultobj = 0;
38071 wxWindow *arg1 = (wxWindow *) 0 ;
38072 wxString result;
38073 void *argp1 = 0 ;
38074 int res1 = 0 ;
38075 PyObject *swig_obj[1] ;
38076
38077 if (!args) SWIG_fail;
38078 swig_obj[0] = args;
38079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38080 if (!SWIG_IsOK(res1)) {
38081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38082 }
38083 arg1 = reinterpret_cast< wxWindow * >(argp1);
38084 {
38085 PyThreadState* __tstate = wxPyBeginAllowThreads();
38086 result = ((wxWindow const *)arg1)->GetHelpText();
38087 wxPyEndAllowThreads(__tstate);
38088 if (PyErr_Occurred()) SWIG_fail;
38089 }
38090 {
38091 #if wxUSE_UNICODE
38092 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38093 #else
38094 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38095 #endif
38096 }
38097 return resultobj;
38098 fail:
38099 return NULL;
38100 }
38101
38102
38103 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38104 PyObject *resultobj = 0;
38105 wxWindow *arg1 = (wxWindow *) 0 ;
38106 wxString *arg2 = 0 ;
38107 void *argp1 = 0 ;
38108 int res1 = 0 ;
38109 bool temp2 = false ;
38110 PyObject * obj0 = 0 ;
38111 PyObject * obj1 = 0 ;
38112 char * kwnames[] = {
38113 (char *) "self",(char *) "tip", NULL
38114 };
38115
38116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38118 if (!SWIG_IsOK(res1)) {
38119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38120 }
38121 arg1 = reinterpret_cast< wxWindow * >(argp1);
38122 {
38123 arg2 = wxString_in_helper(obj1);
38124 if (arg2 == NULL) SWIG_fail;
38125 temp2 = true;
38126 }
38127 {
38128 PyThreadState* __tstate = wxPyBeginAllowThreads();
38129 (arg1)->SetToolTip((wxString const &)*arg2);
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 resultobj = SWIG_Py_Void();
38134 {
38135 if (temp2)
38136 delete arg2;
38137 }
38138 return resultobj;
38139 fail:
38140 {
38141 if (temp2)
38142 delete arg2;
38143 }
38144 return NULL;
38145 }
38146
38147
38148 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38149 PyObject *resultobj = 0;
38150 wxWindow *arg1 = (wxWindow *) 0 ;
38151 wxToolTip *arg2 = (wxToolTip *) 0 ;
38152 void *argp1 = 0 ;
38153 int res1 = 0 ;
38154 int res2 = 0 ;
38155 PyObject * obj0 = 0 ;
38156 PyObject * obj1 = 0 ;
38157 char * kwnames[] = {
38158 (char *) "self",(char *) "tip", NULL
38159 };
38160
38161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38163 if (!SWIG_IsOK(res1)) {
38164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38165 }
38166 arg1 = reinterpret_cast< wxWindow * >(argp1);
38167 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38168 if (!SWIG_IsOK(res2)) {
38169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38170 }
38171 {
38172 PyThreadState* __tstate = wxPyBeginAllowThreads();
38173 (arg1)->SetToolTip(arg2);
38174 wxPyEndAllowThreads(__tstate);
38175 if (PyErr_Occurred()) SWIG_fail;
38176 }
38177 resultobj = SWIG_Py_Void();
38178 return resultobj;
38179 fail:
38180 return NULL;
38181 }
38182
38183
38184 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38185 PyObject *resultobj = 0;
38186 wxWindow *arg1 = (wxWindow *) 0 ;
38187 wxToolTip *result = 0 ;
38188 void *argp1 = 0 ;
38189 int res1 = 0 ;
38190 PyObject *swig_obj[1] ;
38191
38192 if (!args) SWIG_fail;
38193 swig_obj[0] = args;
38194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38195 if (!SWIG_IsOK(res1)) {
38196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38197 }
38198 arg1 = reinterpret_cast< wxWindow * >(argp1);
38199 {
38200 PyThreadState* __tstate = wxPyBeginAllowThreads();
38201 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38202 wxPyEndAllowThreads(__tstate);
38203 if (PyErr_Occurred()) SWIG_fail;
38204 }
38205 {
38206 resultobj = wxPyMake_wxObject(result, (bool)0);
38207 }
38208 return resultobj;
38209 fail:
38210 return NULL;
38211 }
38212
38213
38214 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38215 PyObject *resultobj = 0;
38216 wxWindow *arg1 = (wxWindow *) 0 ;
38217 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38218 void *argp1 = 0 ;
38219 int res1 = 0 ;
38220 int res2 = 0 ;
38221 PyObject * obj0 = 0 ;
38222 PyObject * obj1 = 0 ;
38223 char * kwnames[] = {
38224 (char *) "self",(char *) "dropTarget", NULL
38225 };
38226
38227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38229 if (!SWIG_IsOK(res1)) {
38230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38231 }
38232 arg1 = reinterpret_cast< wxWindow * >(argp1);
38233 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38234 if (!SWIG_IsOK(res2)) {
38235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38236 }
38237 {
38238 PyThreadState* __tstate = wxPyBeginAllowThreads();
38239 (arg1)->SetDropTarget(arg2);
38240 wxPyEndAllowThreads(__tstate);
38241 if (PyErr_Occurred()) SWIG_fail;
38242 }
38243 resultobj = SWIG_Py_Void();
38244 return resultobj;
38245 fail:
38246 return NULL;
38247 }
38248
38249
38250 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38251 PyObject *resultobj = 0;
38252 wxWindow *arg1 = (wxWindow *) 0 ;
38253 wxPyDropTarget *result = 0 ;
38254 void *argp1 = 0 ;
38255 int res1 = 0 ;
38256 PyObject *swig_obj[1] ;
38257
38258 if (!args) SWIG_fail;
38259 swig_obj[0] = args;
38260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38261 if (!SWIG_IsOK(res1)) {
38262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38263 }
38264 arg1 = reinterpret_cast< wxWindow * >(argp1);
38265 {
38266 PyThreadState* __tstate = wxPyBeginAllowThreads();
38267 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38268 wxPyEndAllowThreads(__tstate);
38269 if (PyErr_Occurred()) SWIG_fail;
38270 }
38271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38272 return resultobj;
38273 fail:
38274 return NULL;
38275 }
38276
38277
38278 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38279 PyObject *resultobj = 0;
38280 wxWindow *arg1 = (wxWindow *) 0 ;
38281 bool arg2 ;
38282 void *argp1 = 0 ;
38283 int res1 = 0 ;
38284 bool val2 ;
38285 int ecode2 = 0 ;
38286 PyObject * obj0 = 0 ;
38287 PyObject * obj1 = 0 ;
38288 char * kwnames[] = {
38289 (char *) "self",(char *) "accept", NULL
38290 };
38291
38292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38294 if (!SWIG_IsOK(res1)) {
38295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38296 }
38297 arg1 = reinterpret_cast< wxWindow * >(argp1);
38298 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38299 if (!SWIG_IsOK(ecode2)) {
38300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38301 }
38302 arg2 = static_cast< bool >(val2);
38303 {
38304 PyThreadState* __tstate = wxPyBeginAllowThreads();
38305 wxWindow_DragAcceptFiles(arg1,arg2);
38306 wxPyEndAllowThreads(__tstate);
38307 if (PyErr_Occurred()) SWIG_fail;
38308 }
38309 resultobj = SWIG_Py_Void();
38310 return resultobj;
38311 fail:
38312 return NULL;
38313 }
38314
38315
38316 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38317 PyObject *resultobj = 0;
38318 wxWindow *arg1 = (wxWindow *) 0 ;
38319 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38320 void *argp1 = 0 ;
38321 int res1 = 0 ;
38322 int res2 = 0 ;
38323 PyObject * obj0 = 0 ;
38324 PyObject * obj1 = 0 ;
38325 char * kwnames[] = {
38326 (char *) "self",(char *) "constraints", NULL
38327 };
38328
38329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38331 if (!SWIG_IsOK(res1)) {
38332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38333 }
38334 arg1 = reinterpret_cast< wxWindow * >(argp1);
38335 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38336 if (!SWIG_IsOK(res2)) {
38337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38338 }
38339 {
38340 PyThreadState* __tstate = wxPyBeginAllowThreads();
38341 (arg1)->SetConstraints(arg2);
38342 wxPyEndAllowThreads(__tstate);
38343 if (PyErr_Occurred()) SWIG_fail;
38344 }
38345 resultobj = SWIG_Py_Void();
38346 return resultobj;
38347 fail:
38348 return NULL;
38349 }
38350
38351
38352 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38353 PyObject *resultobj = 0;
38354 wxWindow *arg1 = (wxWindow *) 0 ;
38355 wxLayoutConstraints *result = 0 ;
38356 void *argp1 = 0 ;
38357 int res1 = 0 ;
38358 PyObject *swig_obj[1] ;
38359
38360 if (!args) SWIG_fail;
38361 swig_obj[0] = args;
38362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38363 if (!SWIG_IsOK(res1)) {
38364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38365 }
38366 arg1 = reinterpret_cast< wxWindow * >(argp1);
38367 {
38368 PyThreadState* __tstate = wxPyBeginAllowThreads();
38369 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38370 wxPyEndAllowThreads(__tstate);
38371 if (PyErr_Occurred()) SWIG_fail;
38372 }
38373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38374 return resultobj;
38375 fail:
38376 return NULL;
38377 }
38378
38379
38380 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38381 PyObject *resultobj = 0;
38382 wxWindow *arg1 = (wxWindow *) 0 ;
38383 bool arg2 ;
38384 void *argp1 = 0 ;
38385 int res1 = 0 ;
38386 bool val2 ;
38387 int ecode2 = 0 ;
38388 PyObject * obj0 = 0 ;
38389 PyObject * obj1 = 0 ;
38390 char * kwnames[] = {
38391 (char *) "self",(char *) "autoLayout", NULL
38392 };
38393
38394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38396 if (!SWIG_IsOK(res1)) {
38397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38398 }
38399 arg1 = reinterpret_cast< wxWindow * >(argp1);
38400 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38401 if (!SWIG_IsOK(ecode2)) {
38402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38403 }
38404 arg2 = static_cast< bool >(val2);
38405 {
38406 PyThreadState* __tstate = wxPyBeginAllowThreads();
38407 (arg1)->SetAutoLayout(arg2);
38408 wxPyEndAllowThreads(__tstate);
38409 if (PyErr_Occurred()) SWIG_fail;
38410 }
38411 resultobj = SWIG_Py_Void();
38412 return resultobj;
38413 fail:
38414 return NULL;
38415 }
38416
38417
38418 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38419 PyObject *resultobj = 0;
38420 wxWindow *arg1 = (wxWindow *) 0 ;
38421 bool result;
38422 void *argp1 = 0 ;
38423 int res1 = 0 ;
38424 PyObject *swig_obj[1] ;
38425
38426 if (!args) SWIG_fail;
38427 swig_obj[0] = args;
38428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38429 if (!SWIG_IsOK(res1)) {
38430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38431 }
38432 arg1 = reinterpret_cast< wxWindow * >(argp1);
38433 {
38434 PyThreadState* __tstate = wxPyBeginAllowThreads();
38435 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38436 wxPyEndAllowThreads(__tstate);
38437 if (PyErr_Occurred()) SWIG_fail;
38438 }
38439 {
38440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38441 }
38442 return resultobj;
38443 fail:
38444 return NULL;
38445 }
38446
38447
38448 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38449 PyObject *resultobj = 0;
38450 wxWindow *arg1 = (wxWindow *) 0 ;
38451 bool result;
38452 void *argp1 = 0 ;
38453 int res1 = 0 ;
38454 PyObject *swig_obj[1] ;
38455
38456 if (!args) SWIG_fail;
38457 swig_obj[0] = args;
38458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38459 if (!SWIG_IsOK(res1)) {
38460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38461 }
38462 arg1 = reinterpret_cast< wxWindow * >(argp1);
38463 {
38464 PyThreadState* __tstate = wxPyBeginAllowThreads();
38465 result = (bool)(arg1)->Layout();
38466 wxPyEndAllowThreads(__tstate);
38467 if (PyErr_Occurred()) SWIG_fail;
38468 }
38469 {
38470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38471 }
38472 return resultobj;
38473 fail:
38474 return NULL;
38475 }
38476
38477
38478 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38479 PyObject *resultobj = 0;
38480 wxWindow *arg1 = (wxWindow *) 0 ;
38481 wxSizer *arg2 = (wxSizer *) 0 ;
38482 bool arg3 = (bool) true ;
38483 void *argp1 = 0 ;
38484 int res1 = 0 ;
38485 int res2 = 0 ;
38486 bool val3 ;
38487 int ecode3 = 0 ;
38488 PyObject * obj0 = 0 ;
38489 PyObject * obj1 = 0 ;
38490 PyObject * obj2 = 0 ;
38491 char * kwnames[] = {
38492 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38493 };
38494
38495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38497 if (!SWIG_IsOK(res1)) {
38498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38499 }
38500 arg1 = reinterpret_cast< wxWindow * >(argp1);
38501 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38502 if (!SWIG_IsOK(res2)) {
38503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38504 }
38505 if (obj2) {
38506 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38507 if (!SWIG_IsOK(ecode3)) {
38508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38509 }
38510 arg3 = static_cast< bool >(val3);
38511 }
38512 {
38513 PyThreadState* __tstate = wxPyBeginAllowThreads();
38514 (arg1)->SetSizer(arg2,arg3);
38515 wxPyEndAllowThreads(__tstate);
38516 if (PyErr_Occurred()) SWIG_fail;
38517 }
38518 resultobj = SWIG_Py_Void();
38519 return resultobj;
38520 fail:
38521 return NULL;
38522 }
38523
38524
38525 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38526 PyObject *resultobj = 0;
38527 wxWindow *arg1 = (wxWindow *) 0 ;
38528 wxSizer *arg2 = (wxSizer *) 0 ;
38529 bool arg3 = (bool) true ;
38530 void *argp1 = 0 ;
38531 int res1 = 0 ;
38532 int res2 = 0 ;
38533 bool val3 ;
38534 int ecode3 = 0 ;
38535 PyObject * obj0 = 0 ;
38536 PyObject * obj1 = 0 ;
38537 PyObject * obj2 = 0 ;
38538 char * kwnames[] = {
38539 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38540 };
38541
38542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38544 if (!SWIG_IsOK(res1)) {
38545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38546 }
38547 arg1 = reinterpret_cast< wxWindow * >(argp1);
38548 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38549 if (!SWIG_IsOK(res2)) {
38550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38551 }
38552 if (obj2) {
38553 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38554 if (!SWIG_IsOK(ecode3)) {
38555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38556 }
38557 arg3 = static_cast< bool >(val3);
38558 }
38559 {
38560 PyThreadState* __tstate = wxPyBeginAllowThreads();
38561 (arg1)->SetSizerAndFit(arg2,arg3);
38562 wxPyEndAllowThreads(__tstate);
38563 if (PyErr_Occurred()) SWIG_fail;
38564 }
38565 resultobj = SWIG_Py_Void();
38566 return resultobj;
38567 fail:
38568 return NULL;
38569 }
38570
38571
38572 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38573 PyObject *resultobj = 0;
38574 wxWindow *arg1 = (wxWindow *) 0 ;
38575 wxSizer *result = 0 ;
38576 void *argp1 = 0 ;
38577 int res1 = 0 ;
38578 PyObject *swig_obj[1] ;
38579
38580 if (!args) SWIG_fail;
38581 swig_obj[0] = args;
38582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38583 if (!SWIG_IsOK(res1)) {
38584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38585 }
38586 arg1 = reinterpret_cast< wxWindow * >(argp1);
38587 {
38588 PyThreadState* __tstate = wxPyBeginAllowThreads();
38589 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38590 wxPyEndAllowThreads(__tstate);
38591 if (PyErr_Occurred()) SWIG_fail;
38592 }
38593 {
38594 resultobj = wxPyMake_wxObject(result, (bool)0);
38595 }
38596 return resultobj;
38597 fail:
38598 return NULL;
38599 }
38600
38601
38602 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38603 PyObject *resultobj = 0;
38604 wxWindow *arg1 = (wxWindow *) 0 ;
38605 wxSizer *arg2 = (wxSizer *) 0 ;
38606 void *argp1 = 0 ;
38607 int res1 = 0 ;
38608 void *argp2 = 0 ;
38609 int res2 = 0 ;
38610 PyObject * obj0 = 0 ;
38611 PyObject * obj1 = 0 ;
38612 char * kwnames[] = {
38613 (char *) "self",(char *) "sizer", NULL
38614 };
38615
38616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38618 if (!SWIG_IsOK(res1)) {
38619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38620 }
38621 arg1 = reinterpret_cast< wxWindow * >(argp1);
38622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38623 if (!SWIG_IsOK(res2)) {
38624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38625 }
38626 arg2 = reinterpret_cast< wxSizer * >(argp2);
38627 {
38628 PyThreadState* __tstate = wxPyBeginAllowThreads();
38629 (arg1)->SetContainingSizer(arg2);
38630 wxPyEndAllowThreads(__tstate);
38631 if (PyErr_Occurred()) SWIG_fail;
38632 }
38633 resultobj = SWIG_Py_Void();
38634 return resultobj;
38635 fail:
38636 return NULL;
38637 }
38638
38639
38640 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38641 PyObject *resultobj = 0;
38642 wxWindow *arg1 = (wxWindow *) 0 ;
38643 wxSizer *result = 0 ;
38644 void *argp1 = 0 ;
38645 int res1 = 0 ;
38646 PyObject *swig_obj[1] ;
38647
38648 if (!args) SWIG_fail;
38649 swig_obj[0] = args;
38650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38651 if (!SWIG_IsOK(res1)) {
38652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38653 }
38654 arg1 = reinterpret_cast< wxWindow * >(argp1);
38655 {
38656 PyThreadState* __tstate = wxPyBeginAllowThreads();
38657 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38658 wxPyEndAllowThreads(__tstate);
38659 if (PyErr_Occurred()) SWIG_fail;
38660 }
38661 {
38662 resultobj = wxPyMake_wxObject(result, (bool)0);
38663 }
38664 return resultobj;
38665 fail:
38666 return NULL;
38667 }
38668
38669
38670 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38671 PyObject *resultobj = 0;
38672 wxWindow *arg1 = (wxWindow *) 0 ;
38673 void *argp1 = 0 ;
38674 int res1 = 0 ;
38675 PyObject *swig_obj[1] ;
38676
38677 if (!args) SWIG_fail;
38678 swig_obj[0] = args;
38679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38680 if (!SWIG_IsOK(res1)) {
38681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38682 }
38683 arg1 = reinterpret_cast< wxWindow * >(argp1);
38684 {
38685 PyThreadState* __tstate = wxPyBeginAllowThreads();
38686 (arg1)->InheritAttributes();
38687 wxPyEndAllowThreads(__tstate);
38688 if (PyErr_Occurred()) SWIG_fail;
38689 }
38690 resultobj = SWIG_Py_Void();
38691 return resultobj;
38692 fail:
38693 return NULL;
38694 }
38695
38696
38697 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38698 PyObject *resultobj = 0;
38699 wxWindow *arg1 = (wxWindow *) 0 ;
38700 bool result;
38701 void *argp1 = 0 ;
38702 int res1 = 0 ;
38703 PyObject *swig_obj[1] ;
38704
38705 if (!args) SWIG_fail;
38706 swig_obj[0] = args;
38707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38708 if (!SWIG_IsOK(res1)) {
38709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38710 }
38711 arg1 = reinterpret_cast< wxWindow * >(argp1);
38712 {
38713 PyThreadState* __tstate = wxPyBeginAllowThreads();
38714 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38715 wxPyEndAllowThreads(__tstate);
38716 if (PyErr_Occurred()) SWIG_fail;
38717 }
38718 {
38719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38720 }
38721 return resultobj;
38722 fail:
38723 return NULL;
38724 }
38725
38726
38727 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38728 PyObject *resultobj = 0;
38729 wxWindow *arg1 = (wxWindow *) 0 ;
38730 bool result;
38731 void *argp1 = 0 ;
38732 int res1 = 0 ;
38733 PyObject *swig_obj[1] ;
38734
38735 if (!args) SWIG_fail;
38736 swig_obj[0] = args;
38737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38738 if (!SWIG_IsOK(res1)) {
38739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38740 }
38741 arg1 = reinterpret_cast< wxWindow * >(argp1);
38742 {
38743 PyThreadState* __tstate = wxPyBeginAllowThreads();
38744 result = (bool)(arg1)->CanSetTransparent();
38745 wxPyEndAllowThreads(__tstate);
38746 if (PyErr_Occurred()) SWIG_fail;
38747 }
38748 {
38749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38750 }
38751 return resultobj;
38752 fail:
38753 return NULL;
38754 }
38755
38756
38757 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38758 PyObject *resultobj = 0;
38759 wxWindow *arg1 = (wxWindow *) 0 ;
38760 byte arg2 ;
38761 bool result;
38762 void *argp1 = 0 ;
38763 int res1 = 0 ;
38764 unsigned char val2 ;
38765 int ecode2 = 0 ;
38766 PyObject * obj0 = 0 ;
38767 PyObject * obj1 = 0 ;
38768 char * kwnames[] = {
38769 (char *) "self",(char *) "alpha", NULL
38770 };
38771
38772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38774 if (!SWIG_IsOK(res1)) {
38775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38776 }
38777 arg1 = reinterpret_cast< wxWindow * >(argp1);
38778 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38779 if (!SWIG_IsOK(ecode2)) {
38780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38781 }
38782 arg2 = static_cast< byte >(val2);
38783 {
38784 PyThreadState* __tstate = wxPyBeginAllowThreads();
38785 result = (bool)(arg1)->SetTransparent(arg2);
38786 wxPyEndAllowThreads(__tstate);
38787 if (PyErr_Occurred()) SWIG_fail;
38788 }
38789 {
38790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38791 }
38792 return resultobj;
38793 fail:
38794 return NULL;
38795 }
38796
38797
38798 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38799 PyObject *obj;
38800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38801 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38802 return SWIG_Py_Void();
38803 }
38804
38805 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38806 return SWIG_Python_InitShadowInstance(args);
38807 }
38808
38809 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38810 PyObject *resultobj = 0;
38811 long arg1 ;
38812 wxWindow *arg2 = (wxWindow *) NULL ;
38813 wxWindow *result = 0 ;
38814 long val1 ;
38815 int ecode1 = 0 ;
38816 void *argp2 = 0 ;
38817 int res2 = 0 ;
38818 PyObject * obj0 = 0 ;
38819 PyObject * obj1 = 0 ;
38820 char * kwnames[] = {
38821 (char *) "id",(char *) "parent", NULL
38822 };
38823
38824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38825 ecode1 = SWIG_AsVal_long(obj0, &val1);
38826 if (!SWIG_IsOK(ecode1)) {
38827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38828 }
38829 arg1 = static_cast< long >(val1);
38830 if (obj1) {
38831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38832 if (!SWIG_IsOK(res2)) {
38833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38834 }
38835 arg2 = reinterpret_cast< wxWindow * >(argp2);
38836 }
38837 {
38838 if (!wxPyCheckForApp()) SWIG_fail;
38839 PyThreadState* __tstate = wxPyBeginAllowThreads();
38840 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38841 wxPyEndAllowThreads(__tstate);
38842 if (PyErr_Occurred()) SWIG_fail;
38843 }
38844 {
38845 resultobj = wxPyMake_wxObject(result, 0);
38846 }
38847 return resultobj;
38848 fail:
38849 return NULL;
38850 }
38851
38852
38853 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38854 PyObject *resultobj = 0;
38855 wxString *arg1 = 0 ;
38856 wxWindow *arg2 = (wxWindow *) NULL ;
38857 wxWindow *result = 0 ;
38858 bool temp1 = false ;
38859 void *argp2 = 0 ;
38860 int res2 = 0 ;
38861 PyObject * obj0 = 0 ;
38862 PyObject * obj1 = 0 ;
38863 char * kwnames[] = {
38864 (char *) "name",(char *) "parent", NULL
38865 };
38866
38867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38868 {
38869 arg1 = wxString_in_helper(obj0);
38870 if (arg1 == NULL) SWIG_fail;
38871 temp1 = true;
38872 }
38873 if (obj1) {
38874 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38875 if (!SWIG_IsOK(res2)) {
38876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38877 }
38878 arg2 = reinterpret_cast< wxWindow * >(argp2);
38879 }
38880 {
38881 if (!wxPyCheckForApp()) SWIG_fail;
38882 PyThreadState* __tstate = wxPyBeginAllowThreads();
38883 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38884 wxPyEndAllowThreads(__tstate);
38885 if (PyErr_Occurred()) SWIG_fail;
38886 }
38887 {
38888 resultobj = wxPyMake_wxObject(result, 0);
38889 }
38890 {
38891 if (temp1)
38892 delete arg1;
38893 }
38894 return resultobj;
38895 fail:
38896 {
38897 if (temp1)
38898 delete arg1;
38899 }
38900 return NULL;
38901 }
38902
38903
38904 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38905 PyObject *resultobj = 0;
38906 wxString *arg1 = 0 ;
38907 wxWindow *arg2 = (wxWindow *) NULL ;
38908 wxWindow *result = 0 ;
38909 bool temp1 = false ;
38910 void *argp2 = 0 ;
38911 int res2 = 0 ;
38912 PyObject * obj0 = 0 ;
38913 PyObject * obj1 = 0 ;
38914 char * kwnames[] = {
38915 (char *) "label",(char *) "parent", NULL
38916 };
38917
38918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38919 {
38920 arg1 = wxString_in_helper(obj0);
38921 if (arg1 == NULL) SWIG_fail;
38922 temp1 = true;
38923 }
38924 if (obj1) {
38925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38926 if (!SWIG_IsOK(res2)) {
38927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38928 }
38929 arg2 = reinterpret_cast< wxWindow * >(argp2);
38930 }
38931 {
38932 if (!wxPyCheckForApp()) SWIG_fail;
38933 PyThreadState* __tstate = wxPyBeginAllowThreads();
38934 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38935 wxPyEndAllowThreads(__tstate);
38936 if (PyErr_Occurred()) SWIG_fail;
38937 }
38938 {
38939 resultobj = wxPyMake_wxObject(result, 0);
38940 }
38941 {
38942 if (temp1)
38943 delete arg1;
38944 }
38945 return resultobj;
38946 fail:
38947 {
38948 if (temp1)
38949 delete arg1;
38950 }
38951 return NULL;
38952 }
38953
38954
38955 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38956 PyObject *resultobj = 0;
38957 wxWindow *arg1 = (wxWindow *) 0 ;
38958 unsigned long arg2 ;
38959 wxWindow *result = 0 ;
38960 void *argp1 = 0 ;
38961 int res1 = 0 ;
38962 unsigned long val2 ;
38963 int ecode2 = 0 ;
38964 PyObject * obj0 = 0 ;
38965 PyObject * obj1 = 0 ;
38966 char * kwnames[] = {
38967 (char *) "parent",(char *) "_hWnd", NULL
38968 };
38969
38970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38972 if (!SWIG_IsOK(res1)) {
38973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38974 }
38975 arg1 = reinterpret_cast< wxWindow * >(argp1);
38976 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38977 if (!SWIG_IsOK(ecode2)) {
38978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38979 }
38980 arg2 = static_cast< unsigned long >(val2);
38981 {
38982 PyThreadState* __tstate = wxPyBeginAllowThreads();
38983 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38984 wxPyEndAllowThreads(__tstate);
38985 if (PyErr_Occurred()) SWIG_fail;
38986 }
38987 {
38988 resultobj = wxPyMake_wxObject(result, 0);
38989 }
38990 return resultobj;
38991 fail:
38992 return NULL;
38993 }
38994
38995
38996 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38997 PyObject *resultobj = 0;
38998 PyObject *result = 0 ;
38999
39000 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39001 {
39002 PyThreadState* __tstate = wxPyBeginAllowThreads();
39003 result = (PyObject *)GetTopLevelWindows();
39004 wxPyEndAllowThreads(__tstate);
39005 if (PyErr_Occurred()) SWIG_fail;
39006 }
39007 resultobj = result;
39008 return resultobj;
39009 fail:
39010 return NULL;
39011 }
39012
39013
39014 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39015 PyObject *resultobj = 0;
39016 wxValidator *result = 0 ;
39017
39018 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39019 {
39020 PyThreadState* __tstate = wxPyBeginAllowThreads();
39021 result = (wxValidator *)new wxValidator();
39022 wxPyEndAllowThreads(__tstate);
39023 if (PyErr_Occurred()) SWIG_fail;
39024 }
39025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39026 return resultobj;
39027 fail:
39028 return NULL;
39029 }
39030
39031
39032 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39033 PyObject *resultobj = 0;
39034 wxValidator *arg1 = (wxValidator *) 0 ;
39035 wxValidator *result = 0 ;
39036 void *argp1 = 0 ;
39037 int res1 = 0 ;
39038 PyObject *swig_obj[1] ;
39039
39040 if (!args) SWIG_fail;
39041 swig_obj[0] = args;
39042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39043 if (!SWIG_IsOK(res1)) {
39044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39045 }
39046 arg1 = reinterpret_cast< wxValidator * >(argp1);
39047 {
39048 PyThreadState* __tstate = wxPyBeginAllowThreads();
39049 result = (wxValidator *)(arg1)->Clone();
39050 wxPyEndAllowThreads(__tstate);
39051 if (PyErr_Occurred()) SWIG_fail;
39052 }
39053 {
39054 resultobj = wxPyMake_wxObject(result, 0);
39055 }
39056 return resultobj;
39057 fail:
39058 return NULL;
39059 }
39060
39061
39062 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39063 PyObject *resultobj = 0;
39064 wxValidator *arg1 = (wxValidator *) 0 ;
39065 wxWindow *arg2 = (wxWindow *) 0 ;
39066 bool result;
39067 void *argp1 = 0 ;
39068 int res1 = 0 ;
39069 void *argp2 = 0 ;
39070 int res2 = 0 ;
39071 PyObject * obj0 = 0 ;
39072 PyObject * obj1 = 0 ;
39073 char * kwnames[] = {
39074 (char *) "self",(char *) "parent", NULL
39075 };
39076
39077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39079 if (!SWIG_IsOK(res1)) {
39080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39081 }
39082 arg1 = reinterpret_cast< wxValidator * >(argp1);
39083 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39084 if (!SWIG_IsOK(res2)) {
39085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39086 }
39087 arg2 = reinterpret_cast< wxWindow * >(argp2);
39088 {
39089 PyThreadState* __tstate = wxPyBeginAllowThreads();
39090 result = (bool)(arg1)->Validate(arg2);
39091 wxPyEndAllowThreads(__tstate);
39092 if (PyErr_Occurred()) SWIG_fail;
39093 }
39094 {
39095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39096 }
39097 return resultobj;
39098 fail:
39099 return NULL;
39100 }
39101
39102
39103 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39104 PyObject *resultobj = 0;
39105 wxValidator *arg1 = (wxValidator *) 0 ;
39106 bool result;
39107 void *argp1 = 0 ;
39108 int res1 = 0 ;
39109 PyObject *swig_obj[1] ;
39110
39111 if (!args) SWIG_fail;
39112 swig_obj[0] = args;
39113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39114 if (!SWIG_IsOK(res1)) {
39115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39116 }
39117 arg1 = reinterpret_cast< wxValidator * >(argp1);
39118 {
39119 PyThreadState* __tstate = wxPyBeginAllowThreads();
39120 result = (bool)(arg1)->TransferToWindow();
39121 wxPyEndAllowThreads(__tstate);
39122 if (PyErr_Occurred()) SWIG_fail;
39123 }
39124 {
39125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39126 }
39127 return resultobj;
39128 fail:
39129 return NULL;
39130 }
39131
39132
39133 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39134 PyObject *resultobj = 0;
39135 wxValidator *arg1 = (wxValidator *) 0 ;
39136 bool result;
39137 void *argp1 = 0 ;
39138 int res1 = 0 ;
39139 PyObject *swig_obj[1] ;
39140
39141 if (!args) SWIG_fail;
39142 swig_obj[0] = args;
39143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39144 if (!SWIG_IsOK(res1)) {
39145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39146 }
39147 arg1 = reinterpret_cast< wxValidator * >(argp1);
39148 {
39149 PyThreadState* __tstate = wxPyBeginAllowThreads();
39150 result = (bool)(arg1)->TransferFromWindow();
39151 wxPyEndAllowThreads(__tstate);
39152 if (PyErr_Occurred()) SWIG_fail;
39153 }
39154 {
39155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39156 }
39157 return resultobj;
39158 fail:
39159 return NULL;
39160 }
39161
39162
39163 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39164 PyObject *resultobj = 0;
39165 wxValidator *arg1 = (wxValidator *) 0 ;
39166 wxWindow *result = 0 ;
39167 void *argp1 = 0 ;
39168 int res1 = 0 ;
39169 PyObject *swig_obj[1] ;
39170
39171 if (!args) SWIG_fail;
39172 swig_obj[0] = args;
39173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39174 if (!SWIG_IsOK(res1)) {
39175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39176 }
39177 arg1 = reinterpret_cast< wxValidator * >(argp1);
39178 {
39179 PyThreadState* __tstate = wxPyBeginAllowThreads();
39180 result = (wxWindow *)(arg1)->GetWindow();
39181 wxPyEndAllowThreads(__tstate);
39182 if (PyErr_Occurred()) SWIG_fail;
39183 }
39184 {
39185 resultobj = wxPyMake_wxObject(result, 0);
39186 }
39187 return resultobj;
39188 fail:
39189 return NULL;
39190 }
39191
39192
39193 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39194 PyObject *resultobj = 0;
39195 wxValidator *arg1 = (wxValidator *) 0 ;
39196 wxWindow *arg2 = (wxWindow *) 0 ;
39197 void *argp1 = 0 ;
39198 int res1 = 0 ;
39199 void *argp2 = 0 ;
39200 int res2 = 0 ;
39201 PyObject * obj0 = 0 ;
39202 PyObject * obj1 = 0 ;
39203 char * kwnames[] = {
39204 (char *) "self",(char *) "window", NULL
39205 };
39206
39207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39209 if (!SWIG_IsOK(res1)) {
39210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39211 }
39212 arg1 = reinterpret_cast< wxValidator * >(argp1);
39213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39214 if (!SWIG_IsOK(res2)) {
39215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39216 }
39217 arg2 = reinterpret_cast< wxWindow * >(argp2);
39218 {
39219 PyThreadState* __tstate = wxPyBeginAllowThreads();
39220 (arg1)->SetWindow(arg2);
39221 wxPyEndAllowThreads(__tstate);
39222 if (PyErr_Occurred()) SWIG_fail;
39223 }
39224 resultobj = SWIG_Py_Void();
39225 return resultobj;
39226 fail:
39227 return NULL;
39228 }
39229
39230
39231 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39232 PyObject *resultobj = 0;
39233 bool result;
39234
39235 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39236 {
39237 PyThreadState* __tstate = wxPyBeginAllowThreads();
39238 result = (bool)wxValidator::IsSilent();
39239 wxPyEndAllowThreads(__tstate);
39240 if (PyErr_Occurred()) SWIG_fail;
39241 }
39242 {
39243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39244 }
39245 return resultobj;
39246 fail:
39247 return NULL;
39248 }
39249
39250
39251 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39252 PyObject *resultobj = 0;
39253 int arg1 = (int) true ;
39254 int val1 ;
39255 int ecode1 = 0 ;
39256 PyObject * obj0 = 0 ;
39257 char * kwnames[] = {
39258 (char *) "doIt", NULL
39259 };
39260
39261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39262 if (obj0) {
39263 ecode1 = SWIG_AsVal_int(obj0, &val1);
39264 if (!SWIG_IsOK(ecode1)) {
39265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39266 }
39267 arg1 = static_cast< int >(val1);
39268 }
39269 {
39270 PyThreadState* __tstate = wxPyBeginAllowThreads();
39271 wxValidator::SetBellOnError(arg1);
39272 wxPyEndAllowThreads(__tstate);
39273 if (PyErr_Occurred()) SWIG_fail;
39274 }
39275 resultobj = SWIG_Py_Void();
39276 return resultobj;
39277 fail:
39278 return NULL;
39279 }
39280
39281
39282 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39283 PyObject *obj;
39284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39285 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39286 return SWIG_Py_Void();
39287 }
39288
39289 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39290 return SWIG_Python_InitShadowInstance(args);
39291 }
39292
39293 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39294 PyObject *resultobj = 0;
39295 wxPyValidator *result = 0 ;
39296
39297 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39298 {
39299 PyThreadState* __tstate = wxPyBeginAllowThreads();
39300 result = (wxPyValidator *)new wxPyValidator();
39301 wxPyEndAllowThreads(__tstate);
39302 if (PyErr_Occurred()) SWIG_fail;
39303 }
39304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39305 return resultobj;
39306 fail:
39307 return NULL;
39308 }
39309
39310
39311 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39312 PyObject *resultobj = 0;
39313 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39314 PyObject *arg2 = (PyObject *) 0 ;
39315 PyObject *arg3 = (PyObject *) 0 ;
39316 int arg4 = (int) true ;
39317 void *argp1 = 0 ;
39318 int res1 = 0 ;
39319 int val4 ;
39320 int ecode4 = 0 ;
39321 PyObject * obj0 = 0 ;
39322 PyObject * obj1 = 0 ;
39323 PyObject * obj2 = 0 ;
39324 PyObject * obj3 = 0 ;
39325 char * kwnames[] = {
39326 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39327 };
39328
39329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39331 if (!SWIG_IsOK(res1)) {
39332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39333 }
39334 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39335 arg2 = obj1;
39336 arg3 = obj2;
39337 if (obj3) {
39338 ecode4 = SWIG_AsVal_int(obj3, &val4);
39339 if (!SWIG_IsOK(ecode4)) {
39340 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39341 }
39342 arg4 = static_cast< int >(val4);
39343 }
39344 {
39345 PyThreadState* __tstate = wxPyBeginAllowThreads();
39346 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39347 wxPyEndAllowThreads(__tstate);
39348 if (PyErr_Occurred()) SWIG_fail;
39349 }
39350 resultobj = SWIG_Py_Void();
39351 return resultobj;
39352 fail:
39353 return NULL;
39354 }
39355
39356
39357 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39358 PyObject *obj;
39359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39360 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39361 return SWIG_Py_Void();
39362 }
39363
39364 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39365 return SWIG_Python_InitShadowInstance(args);
39366 }
39367
39368 SWIGINTERN int DefaultValidator_set(PyObject *) {
39369 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39370 return 1;
39371 }
39372
39373
39374 SWIGINTERN PyObject *DefaultValidator_get(void) {
39375 PyObject *pyobj = 0;
39376
39377 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39378 return pyobj;
39379 }
39380
39381
39382 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39383 PyObject *resultobj = 0;
39384 wxString const &arg1_defvalue = wxPyEmptyString ;
39385 wxString *arg1 = (wxString *) &arg1_defvalue ;
39386 long arg2 = (long) 0 ;
39387 wxMenu *result = 0 ;
39388 bool temp1 = false ;
39389 long val2 ;
39390 int ecode2 = 0 ;
39391 PyObject * obj0 = 0 ;
39392 PyObject * obj1 = 0 ;
39393 char * kwnames[] = {
39394 (char *) "title",(char *) "style", NULL
39395 };
39396
39397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39398 if (obj0) {
39399 {
39400 arg1 = wxString_in_helper(obj0);
39401 if (arg1 == NULL) SWIG_fail;
39402 temp1 = true;
39403 }
39404 }
39405 if (obj1) {
39406 ecode2 = SWIG_AsVal_long(obj1, &val2);
39407 if (!SWIG_IsOK(ecode2)) {
39408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39409 }
39410 arg2 = static_cast< long >(val2);
39411 }
39412 {
39413 if (!wxPyCheckForApp()) SWIG_fail;
39414 PyThreadState* __tstate = wxPyBeginAllowThreads();
39415 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39416 wxPyEndAllowThreads(__tstate);
39417 if (PyErr_Occurred()) SWIG_fail;
39418 }
39419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39420 {
39421 if (temp1)
39422 delete arg1;
39423 }
39424 return resultobj;
39425 fail:
39426 {
39427 if (temp1)
39428 delete arg1;
39429 }
39430 return NULL;
39431 }
39432
39433
39434 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39435 PyObject *resultobj = 0;
39436 wxMenu *arg1 = (wxMenu *) 0 ;
39437 int arg2 ;
39438 wxString const &arg3_defvalue = wxPyEmptyString ;
39439 wxString *arg3 = (wxString *) &arg3_defvalue ;
39440 wxString const &arg4_defvalue = wxPyEmptyString ;
39441 wxString *arg4 = (wxString *) &arg4_defvalue ;
39442 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39443 wxMenuItem *result = 0 ;
39444 void *argp1 = 0 ;
39445 int res1 = 0 ;
39446 int val2 ;
39447 int ecode2 = 0 ;
39448 bool temp3 = false ;
39449 bool temp4 = false ;
39450 int val5 ;
39451 int ecode5 = 0 ;
39452 PyObject * obj0 = 0 ;
39453 PyObject * obj1 = 0 ;
39454 PyObject * obj2 = 0 ;
39455 PyObject * obj3 = 0 ;
39456 PyObject * obj4 = 0 ;
39457 char * kwnames[] = {
39458 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39459 };
39460
39461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39463 if (!SWIG_IsOK(res1)) {
39464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39465 }
39466 arg1 = reinterpret_cast< wxMenu * >(argp1);
39467 ecode2 = SWIG_AsVal_int(obj1, &val2);
39468 if (!SWIG_IsOK(ecode2)) {
39469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39470 }
39471 arg2 = static_cast< int >(val2);
39472 if (obj2) {
39473 {
39474 arg3 = wxString_in_helper(obj2);
39475 if (arg3 == NULL) SWIG_fail;
39476 temp3 = true;
39477 }
39478 }
39479 if (obj3) {
39480 {
39481 arg4 = wxString_in_helper(obj3);
39482 if (arg4 == NULL) SWIG_fail;
39483 temp4 = true;
39484 }
39485 }
39486 if (obj4) {
39487 ecode5 = SWIG_AsVal_int(obj4, &val5);
39488 if (!SWIG_IsOK(ecode5)) {
39489 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39490 }
39491 arg5 = static_cast< wxItemKind >(val5);
39492 }
39493 {
39494 PyThreadState* __tstate = wxPyBeginAllowThreads();
39495 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39496 wxPyEndAllowThreads(__tstate);
39497 if (PyErr_Occurred()) SWIG_fail;
39498 }
39499 {
39500 resultobj = wxPyMake_wxObject(result, (bool)0);
39501 }
39502 {
39503 if (temp3)
39504 delete arg3;
39505 }
39506 {
39507 if (temp4)
39508 delete arg4;
39509 }
39510 return resultobj;
39511 fail:
39512 {
39513 if (temp3)
39514 delete arg3;
39515 }
39516 {
39517 if (temp4)
39518 delete arg4;
39519 }
39520 return NULL;
39521 }
39522
39523
39524 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39525 PyObject *resultobj = 0;
39526 wxMenu *arg1 = (wxMenu *) 0 ;
39527 wxMenuItem *result = 0 ;
39528 void *argp1 = 0 ;
39529 int res1 = 0 ;
39530 PyObject *swig_obj[1] ;
39531
39532 if (!args) SWIG_fail;
39533 swig_obj[0] = args;
39534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39535 if (!SWIG_IsOK(res1)) {
39536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39537 }
39538 arg1 = reinterpret_cast< wxMenu * >(argp1);
39539 {
39540 PyThreadState* __tstate = wxPyBeginAllowThreads();
39541 result = (wxMenuItem *)(arg1)->AppendSeparator();
39542 wxPyEndAllowThreads(__tstate);
39543 if (PyErr_Occurred()) SWIG_fail;
39544 }
39545 {
39546 resultobj = wxPyMake_wxObject(result, (bool)0);
39547 }
39548 return resultobj;
39549 fail:
39550 return NULL;
39551 }
39552
39553
39554 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39555 PyObject *resultobj = 0;
39556 wxMenu *arg1 = (wxMenu *) 0 ;
39557 int arg2 ;
39558 wxString *arg3 = 0 ;
39559 wxString const &arg4_defvalue = wxPyEmptyString ;
39560 wxString *arg4 = (wxString *) &arg4_defvalue ;
39561 wxMenuItem *result = 0 ;
39562 void *argp1 = 0 ;
39563 int res1 = 0 ;
39564 int val2 ;
39565 int ecode2 = 0 ;
39566 bool temp3 = false ;
39567 bool temp4 = false ;
39568 PyObject * obj0 = 0 ;
39569 PyObject * obj1 = 0 ;
39570 PyObject * obj2 = 0 ;
39571 PyObject * obj3 = 0 ;
39572 char * kwnames[] = {
39573 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39574 };
39575
39576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39578 if (!SWIG_IsOK(res1)) {
39579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39580 }
39581 arg1 = reinterpret_cast< wxMenu * >(argp1);
39582 ecode2 = SWIG_AsVal_int(obj1, &val2);
39583 if (!SWIG_IsOK(ecode2)) {
39584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39585 }
39586 arg2 = static_cast< int >(val2);
39587 {
39588 arg3 = wxString_in_helper(obj2);
39589 if (arg3 == NULL) SWIG_fail;
39590 temp3 = true;
39591 }
39592 if (obj3) {
39593 {
39594 arg4 = wxString_in_helper(obj3);
39595 if (arg4 == NULL) SWIG_fail;
39596 temp4 = true;
39597 }
39598 }
39599 {
39600 PyThreadState* __tstate = wxPyBeginAllowThreads();
39601 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39602 wxPyEndAllowThreads(__tstate);
39603 if (PyErr_Occurred()) SWIG_fail;
39604 }
39605 {
39606 resultobj = wxPyMake_wxObject(result, (bool)0);
39607 }
39608 {
39609 if (temp3)
39610 delete arg3;
39611 }
39612 {
39613 if (temp4)
39614 delete arg4;
39615 }
39616 return resultobj;
39617 fail:
39618 {
39619 if (temp3)
39620 delete arg3;
39621 }
39622 {
39623 if (temp4)
39624 delete arg4;
39625 }
39626 return NULL;
39627 }
39628
39629
39630 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39631 PyObject *resultobj = 0;
39632 wxMenu *arg1 = (wxMenu *) 0 ;
39633 int arg2 ;
39634 wxString *arg3 = 0 ;
39635 wxString const &arg4_defvalue = wxPyEmptyString ;
39636 wxString *arg4 = (wxString *) &arg4_defvalue ;
39637 wxMenuItem *result = 0 ;
39638 void *argp1 = 0 ;
39639 int res1 = 0 ;
39640 int val2 ;
39641 int ecode2 = 0 ;
39642 bool temp3 = false ;
39643 bool temp4 = false ;
39644 PyObject * obj0 = 0 ;
39645 PyObject * obj1 = 0 ;
39646 PyObject * obj2 = 0 ;
39647 PyObject * obj3 = 0 ;
39648 char * kwnames[] = {
39649 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39650 };
39651
39652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39654 if (!SWIG_IsOK(res1)) {
39655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39656 }
39657 arg1 = reinterpret_cast< wxMenu * >(argp1);
39658 ecode2 = SWIG_AsVal_int(obj1, &val2);
39659 if (!SWIG_IsOK(ecode2)) {
39660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39661 }
39662 arg2 = static_cast< int >(val2);
39663 {
39664 arg3 = wxString_in_helper(obj2);
39665 if (arg3 == NULL) SWIG_fail;
39666 temp3 = true;
39667 }
39668 if (obj3) {
39669 {
39670 arg4 = wxString_in_helper(obj3);
39671 if (arg4 == NULL) SWIG_fail;
39672 temp4 = true;
39673 }
39674 }
39675 {
39676 PyThreadState* __tstate = wxPyBeginAllowThreads();
39677 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39678 wxPyEndAllowThreads(__tstate);
39679 if (PyErr_Occurred()) SWIG_fail;
39680 }
39681 {
39682 resultobj = wxPyMake_wxObject(result, (bool)0);
39683 }
39684 {
39685 if (temp3)
39686 delete arg3;
39687 }
39688 {
39689 if (temp4)
39690 delete arg4;
39691 }
39692 return resultobj;
39693 fail:
39694 {
39695 if (temp3)
39696 delete arg3;
39697 }
39698 {
39699 if (temp4)
39700 delete arg4;
39701 }
39702 return NULL;
39703 }
39704
39705
39706 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39707 PyObject *resultobj = 0;
39708 wxMenu *arg1 = (wxMenu *) 0 ;
39709 int arg2 ;
39710 wxString *arg3 = 0 ;
39711 wxMenu *arg4 = (wxMenu *) 0 ;
39712 wxString const &arg5_defvalue = wxPyEmptyString ;
39713 wxString *arg5 = (wxString *) &arg5_defvalue ;
39714 wxMenuItem *result = 0 ;
39715 void *argp1 = 0 ;
39716 int res1 = 0 ;
39717 int val2 ;
39718 int ecode2 = 0 ;
39719 bool temp3 = false ;
39720 void *argp4 = 0 ;
39721 int res4 = 0 ;
39722 bool temp5 = false ;
39723 PyObject * obj0 = 0 ;
39724 PyObject * obj1 = 0 ;
39725 PyObject * obj2 = 0 ;
39726 PyObject * obj3 = 0 ;
39727 PyObject * obj4 = 0 ;
39728 char * kwnames[] = {
39729 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39730 };
39731
39732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39734 if (!SWIG_IsOK(res1)) {
39735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39736 }
39737 arg1 = reinterpret_cast< wxMenu * >(argp1);
39738 ecode2 = SWIG_AsVal_int(obj1, &val2);
39739 if (!SWIG_IsOK(ecode2)) {
39740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39741 }
39742 arg2 = static_cast< int >(val2);
39743 {
39744 arg3 = wxString_in_helper(obj2);
39745 if (arg3 == NULL) SWIG_fail;
39746 temp3 = true;
39747 }
39748 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39749 if (!SWIG_IsOK(res4)) {
39750 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39751 }
39752 arg4 = reinterpret_cast< wxMenu * >(argp4);
39753 if (obj4) {
39754 {
39755 arg5 = wxString_in_helper(obj4);
39756 if (arg5 == NULL) SWIG_fail;
39757 temp5 = true;
39758 }
39759 }
39760 {
39761 PyThreadState* __tstate = wxPyBeginAllowThreads();
39762 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39763 wxPyEndAllowThreads(__tstate);
39764 if (PyErr_Occurred()) SWIG_fail;
39765 }
39766 {
39767 resultobj = wxPyMake_wxObject(result, (bool)0);
39768 }
39769 {
39770 if (temp3)
39771 delete arg3;
39772 }
39773 {
39774 if (temp5)
39775 delete arg5;
39776 }
39777 return resultobj;
39778 fail:
39779 {
39780 if (temp3)
39781 delete arg3;
39782 }
39783 {
39784 if (temp5)
39785 delete arg5;
39786 }
39787 return NULL;
39788 }
39789
39790
39791 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39792 PyObject *resultobj = 0;
39793 wxMenu *arg1 = (wxMenu *) 0 ;
39794 wxMenu *arg2 = (wxMenu *) 0 ;
39795 wxString *arg3 = 0 ;
39796 wxString const &arg4_defvalue = wxPyEmptyString ;
39797 wxString *arg4 = (wxString *) &arg4_defvalue ;
39798 wxMenuItem *result = 0 ;
39799 void *argp1 = 0 ;
39800 int res1 = 0 ;
39801 void *argp2 = 0 ;
39802 int res2 = 0 ;
39803 bool temp3 = false ;
39804 bool temp4 = false ;
39805 PyObject * obj0 = 0 ;
39806 PyObject * obj1 = 0 ;
39807 PyObject * obj2 = 0 ;
39808 PyObject * obj3 = 0 ;
39809 char * kwnames[] = {
39810 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39811 };
39812
39813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39815 if (!SWIG_IsOK(res1)) {
39816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39817 }
39818 arg1 = reinterpret_cast< wxMenu * >(argp1);
39819 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39820 if (!SWIG_IsOK(res2)) {
39821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39822 }
39823 arg2 = reinterpret_cast< wxMenu * >(argp2);
39824 {
39825 arg3 = wxString_in_helper(obj2);
39826 if (arg3 == NULL) SWIG_fail;
39827 temp3 = true;
39828 }
39829 if (obj3) {
39830 {
39831 arg4 = wxString_in_helper(obj3);
39832 if (arg4 == NULL) SWIG_fail;
39833 temp4 = true;
39834 }
39835 }
39836 {
39837 PyThreadState* __tstate = wxPyBeginAllowThreads();
39838 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39839 wxPyEndAllowThreads(__tstate);
39840 if (PyErr_Occurred()) SWIG_fail;
39841 }
39842 {
39843 resultobj = wxPyMake_wxObject(result, (bool)0);
39844 }
39845 {
39846 if (temp3)
39847 delete arg3;
39848 }
39849 {
39850 if (temp4)
39851 delete arg4;
39852 }
39853 return resultobj;
39854 fail:
39855 {
39856 if (temp3)
39857 delete arg3;
39858 }
39859 {
39860 if (temp4)
39861 delete arg4;
39862 }
39863 return NULL;
39864 }
39865
39866
39867 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39868 PyObject *resultobj = 0;
39869 wxMenu *arg1 = (wxMenu *) 0 ;
39870 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39871 wxMenuItem *result = 0 ;
39872 void *argp1 = 0 ;
39873 int res1 = 0 ;
39874 int res2 = 0 ;
39875 PyObject * obj0 = 0 ;
39876 PyObject * obj1 = 0 ;
39877 char * kwnames[] = {
39878 (char *) "self",(char *) "item", NULL
39879 };
39880
39881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39883 if (!SWIG_IsOK(res1)) {
39884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39885 }
39886 arg1 = reinterpret_cast< wxMenu * >(argp1);
39887 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39888 if (!SWIG_IsOK(res2)) {
39889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39890 }
39891 {
39892 PyThreadState* __tstate = wxPyBeginAllowThreads();
39893 result = (wxMenuItem *)(arg1)->Append(arg2);
39894 wxPyEndAllowThreads(__tstate);
39895 if (PyErr_Occurred()) SWIG_fail;
39896 }
39897 {
39898 resultobj = wxPyMake_wxObject(result, (bool)0);
39899 }
39900 return resultobj;
39901 fail:
39902 return NULL;
39903 }
39904
39905
39906 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39907 PyObject *resultobj = 0;
39908 wxMenu *arg1 = (wxMenu *) 0 ;
39909 size_t arg2 ;
39910 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39911 wxMenuItem *result = 0 ;
39912 void *argp1 = 0 ;
39913 int res1 = 0 ;
39914 size_t val2 ;
39915 int ecode2 = 0 ;
39916 int res3 = 0 ;
39917 PyObject * obj0 = 0 ;
39918 PyObject * obj1 = 0 ;
39919 PyObject * obj2 = 0 ;
39920 char * kwnames[] = {
39921 (char *) "self",(char *) "pos",(char *) "item", NULL
39922 };
39923
39924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39926 if (!SWIG_IsOK(res1)) {
39927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39928 }
39929 arg1 = reinterpret_cast< wxMenu * >(argp1);
39930 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39931 if (!SWIG_IsOK(ecode2)) {
39932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39933 }
39934 arg2 = static_cast< size_t >(val2);
39935 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39936 if (!SWIG_IsOK(res3)) {
39937 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39938 }
39939 {
39940 PyThreadState* __tstate = wxPyBeginAllowThreads();
39941 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 {
39946 resultobj = wxPyMake_wxObject(result, (bool)0);
39947 }
39948 return resultobj;
39949 fail:
39950 return NULL;
39951 }
39952
39953
39954 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39955 PyObject *resultobj = 0;
39956 wxMenu *arg1 = (wxMenu *) 0 ;
39957 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39958 wxMenuItem *result = 0 ;
39959 void *argp1 = 0 ;
39960 int res1 = 0 ;
39961 int res2 = 0 ;
39962 PyObject * obj0 = 0 ;
39963 PyObject * obj1 = 0 ;
39964 char * kwnames[] = {
39965 (char *) "self",(char *) "item", NULL
39966 };
39967
39968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39970 if (!SWIG_IsOK(res1)) {
39971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39972 }
39973 arg1 = reinterpret_cast< wxMenu * >(argp1);
39974 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39975 if (!SWIG_IsOK(res2)) {
39976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39977 }
39978 {
39979 PyThreadState* __tstate = wxPyBeginAllowThreads();
39980 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39981 wxPyEndAllowThreads(__tstate);
39982 if (PyErr_Occurred()) SWIG_fail;
39983 }
39984 {
39985 resultobj = wxPyMake_wxObject(result, (bool)0);
39986 }
39987 return resultobj;
39988 fail:
39989 return NULL;
39990 }
39991
39992
39993 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39994 PyObject *resultobj = 0;
39995 wxMenu *arg1 = (wxMenu *) 0 ;
39996 void *argp1 = 0 ;
39997 int res1 = 0 ;
39998 PyObject *swig_obj[1] ;
39999
40000 if (!args) SWIG_fail;
40001 swig_obj[0] = args;
40002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40003 if (!SWIG_IsOK(res1)) {
40004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40005 }
40006 arg1 = reinterpret_cast< wxMenu * >(argp1);
40007 {
40008 PyThreadState* __tstate = wxPyBeginAllowThreads();
40009 (arg1)->Break();
40010 wxPyEndAllowThreads(__tstate);
40011 if (PyErr_Occurred()) SWIG_fail;
40012 }
40013 resultobj = SWIG_Py_Void();
40014 return resultobj;
40015 fail:
40016 return NULL;
40017 }
40018
40019
40020 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40021 PyObject *resultobj = 0;
40022 wxMenu *arg1 = (wxMenu *) 0 ;
40023 size_t arg2 ;
40024 int arg3 ;
40025 wxString const &arg4_defvalue = wxPyEmptyString ;
40026 wxString *arg4 = (wxString *) &arg4_defvalue ;
40027 wxString const &arg5_defvalue = wxPyEmptyString ;
40028 wxString *arg5 = (wxString *) &arg5_defvalue ;
40029 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40030 wxMenuItem *result = 0 ;
40031 void *argp1 = 0 ;
40032 int res1 = 0 ;
40033 size_t val2 ;
40034 int ecode2 = 0 ;
40035 int val3 ;
40036 int ecode3 = 0 ;
40037 bool temp4 = false ;
40038 bool temp5 = false ;
40039 int val6 ;
40040 int ecode6 = 0 ;
40041 PyObject * obj0 = 0 ;
40042 PyObject * obj1 = 0 ;
40043 PyObject * obj2 = 0 ;
40044 PyObject * obj3 = 0 ;
40045 PyObject * obj4 = 0 ;
40046 PyObject * obj5 = 0 ;
40047 char * kwnames[] = {
40048 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40049 };
40050
40051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40053 if (!SWIG_IsOK(res1)) {
40054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40055 }
40056 arg1 = reinterpret_cast< wxMenu * >(argp1);
40057 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40058 if (!SWIG_IsOK(ecode2)) {
40059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40060 }
40061 arg2 = static_cast< size_t >(val2);
40062 ecode3 = SWIG_AsVal_int(obj2, &val3);
40063 if (!SWIG_IsOK(ecode3)) {
40064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40065 }
40066 arg3 = static_cast< int >(val3);
40067 if (obj3) {
40068 {
40069 arg4 = wxString_in_helper(obj3);
40070 if (arg4 == NULL) SWIG_fail;
40071 temp4 = true;
40072 }
40073 }
40074 if (obj4) {
40075 {
40076 arg5 = wxString_in_helper(obj4);
40077 if (arg5 == NULL) SWIG_fail;
40078 temp5 = true;
40079 }
40080 }
40081 if (obj5) {
40082 ecode6 = SWIG_AsVal_int(obj5, &val6);
40083 if (!SWIG_IsOK(ecode6)) {
40084 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40085 }
40086 arg6 = static_cast< wxItemKind >(val6);
40087 }
40088 {
40089 PyThreadState* __tstate = wxPyBeginAllowThreads();
40090 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40091 wxPyEndAllowThreads(__tstate);
40092 if (PyErr_Occurred()) SWIG_fail;
40093 }
40094 {
40095 resultobj = wxPyMake_wxObject(result, (bool)0);
40096 }
40097 {
40098 if (temp4)
40099 delete arg4;
40100 }
40101 {
40102 if (temp5)
40103 delete arg5;
40104 }
40105 return resultobj;
40106 fail:
40107 {
40108 if (temp4)
40109 delete arg4;
40110 }
40111 {
40112 if (temp5)
40113 delete arg5;
40114 }
40115 return NULL;
40116 }
40117
40118
40119 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40120 PyObject *resultobj = 0;
40121 wxMenu *arg1 = (wxMenu *) 0 ;
40122 size_t arg2 ;
40123 wxMenuItem *result = 0 ;
40124 void *argp1 = 0 ;
40125 int res1 = 0 ;
40126 size_t val2 ;
40127 int ecode2 = 0 ;
40128 PyObject * obj0 = 0 ;
40129 PyObject * obj1 = 0 ;
40130 char * kwnames[] = {
40131 (char *) "self",(char *) "pos", NULL
40132 };
40133
40134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40136 if (!SWIG_IsOK(res1)) {
40137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40138 }
40139 arg1 = reinterpret_cast< wxMenu * >(argp1);
40140 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40141 if (!SWIG_IsOK(ecode2)) {
40142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40143 }
40144 arg2 = static_cast< size_t >(val2);
40145 {
40146 PyThreadState* __tstate = wxPyBeginAllowThreads();
40147 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40148 wxPyEndAllowThreads(__tstate);
40149 if (PyErr_Occurred()) SWIG_fail;
40150 }
40151 {
40152 resultobj = wxPyMake_wxObject(result, (bool)0);
40153 }
40154 return resultobj;
40155 fail:
40156 return NULL;
40157 }
40158
40159
40160 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40161 PyObject *resultobj = 0;
40162 wxMenu *arg1 = (wxMenu *) 0 ;
40163 size_t arg2 ;
40164 int arg3 ;
40165 wxString *arg4 = 0 ;
40166 wxString const &arg5_defvalue = wxPyEmptyString ;
40167 wxString *arg5 = (wxString *) &arg5_defvalue ;
40168 wxMenuItem *result = 0 ;
40169 void *argp1 = 0 ;
40170 int res1 = 0 ;
40171 size_t val2 ;
40172 int ecode2 = 0 ;
40173 int val3 ;
40174 int ecode3 = 0 ;
40175 bool temp4 = false ;
40176 bool temp5 = false ;
40177 PyObject * obj0 = 0 ;
40178 PyObject * obj1 = 0 ;
40179 PyObject * obj2 = 0 ;
40180 PyObject * obj3 = 0 ;
40181 PyObject * obj4 = 0 ;
40182 char * kwnames[] = {
40183 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40184 };
40185
40186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40190 }
40191 arg1 = reinterpret_cast< wxMenu * >(argp1);
40192 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40193 if (!SWIG_IsOK(ecode2)) {
40194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40195 }
40196 arg2 = static_cast< size_t >(val2);
40197 ecode3 = SWIG_AsVal_int(obj2, &val3);
40198 if (!SWIG_IsOK(ecode3)) {
40199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40200 }
40201 arg3 = static_cast< int >(val3);
40202 {
40203 arg4 = wxString_in_helper(obj3);
40204 if (arg4 == NULL) SWIG_fail;
40205 temp4 = true;
40206 }
40207 if (obj4) {
40208 {
40209 arg5 = wxString_in_helper(obj4);
40210 if (arg5 == NULL) SWIG_fail;
40211 temp5 = true;
40212 }
40213 }
40214 {
40215 PyThreadState* __tstate = wxPyBeginAllowThreads();
40216 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40217 wxPyEndAllowThreads(__tstate);
40218 if (PyErr_Occurred()) SWIG_fail;
40219 }
40220 {
40221 resultobj = wxPyMake_wxObject(result, (bool)0);
40222 }
40223 {
40224 if (temp4)
40225 delete arg4;
40226 }
40227 {
40228 if (temp5)
40229 delete arg5;
40230 }
40231 return resultobj;
40232 fail:
40233 {
40234 if (temp4)
40235 delete arg4;
40236 }
40237 {
40238 if (temp5)
40239 delete arg5;
40240 }
40241 return NULL;
40242 }
40243
40244
40245 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40246 PyObject *resultobj = 0;
40247 wxMenu *arg1 = (wxMenu *) 0 ;
40248 size_t arg2 ;
40249 int arg3 ;
40250 wxString *arg4 = 0 ;
40251 wxString const &arg5_defvalue = wxPyEmptyString ;
40252 wxString *arg5 = (wxString *) &arg5_defvalue ;
40253 wxMenuItem *result = 0 ;
40254 void *argp1 = 0 ;
40255 int res1 = 0 ;
40256 size_t val2 ;
40257 int ecode2 = 0 ;
40258 int val3 ;
40259 int ecode3 = 0 ;
40260 bool temp4 = false ;
40261 bool temp5 = false ;
40262 PyObject * obj0 = 0 ;
40263 PyObject * obj1 = 0 ;
40264 PyObject * obj2 = 0 ;
40265 PyObject * obj3 = 0 ;
40266 PyObject * obj4 = 0 ;
40267 char * kwnames[] = {
40268 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40269 };
40270
40271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40273 if (!SWIG_IsOK(res1)) {
40274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40275 }
40276 arg1 = reinterpret_cast< wxMenu * >(argp1);
40277 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40278 if (!SWIG_IsOK(ecode2)) {
40279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40280 }
40281 arg2 = static_cast< size_t >(val2);
40282 ecode3 = SWIG_AsVal_int(obj2, &val3);
40283 if (!SWIG_IsOK(ecode3)) {
40284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40285 }
40286 arg3 = static_cast< int >(val3);
40287 {
40288 arg4 = wxString_in_helper(obj3);
40289 if (arg4 == NULL) SWIG_fail;
40290 temp4 = true;
40291 }
40292 if (obj4) {
40293 {
40294 arg5 = wxString_in_helper(obj4);
40295 if (arg5 == NULL) SWIG_fail;
40296 temp5 = true;
40297 }
40298 }
40299 {
40300 PyThreadState* __tstate = wxPyBeginAllowThreads();
40301 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40302 wxPyEndAllowThreads(__tstate);
40303 if (PyErr_Occurred()) SWIG_fail;
40304 }
40305 {
40306 resultobj = wxPyMake_wxObject(result, (bool)0);
40307 }
40308 {
40309 if (temp4)
40310 delete arg4;
40311 }
40312 {
40313 if (temp5)
40314 delete arg5;
40315 }
40316 return resultobj;
40317 fail:
40318 {
40319 if (temp4)
40320 delete arg4;
40321 }
40322 {
40323 if (temp5)
40324 delete arg5;
40325 }
40326 return NULL;
40327 }
40328
40329
40330 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40331 PyObject *resultobj = 0;
40332 wxMenu *arg1 = (wxMenu *) 0 ;
40333 size_t arg2 ;
40334 int arg3 ;
40335 wxString *arg4 = 0 ;
40336 wxMenu *arg5 = (wxMenu *) 0 ;
40337 wxString const &arg6_defvalue = wxPyEmptyString ;
40338 wxString *arg6 = (wxString *) &arg6_defvalue ;
40339 wxMenuItem *result = 0 ;
40340 void *argp1 = 0 ;
40341 int res1 = 0 ;
40342 size_t val2 ;
40343 int ecode2 = 0 ;
40344 int val3 ;
40345 int ecode3 = 0 ;
40346 bool temp4 = false ;
40347 void *argp5 = 0 ;
40348 int res5 = 0 ;
40349 bool temp6 = false ;
40350 PyObject * obj0 = 0 ;
40351 PyObject * obj1 = 0 ;
40352 PyObject * obj2 = 0 ;
40353 PyObject * obj3 = 0 ;
40354 PyObject * obj4 = 0 ;
40355 PyObject * obj5 = 0 ;
40356 char * kwnames[] = {
40357 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40358 };
40359
40360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40362 if (!SWIG_IsOK(res1)) {
40363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40364 }
40365 arg1 = reinterpret_cast< wxMenu * >(argp1);
40366 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40367 if (!SWIG_IsOK(ecode2)) {
40368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40369 }
40370 arg2 = static_cast< size_t >(val2);
40371 ecode3 = SWIG_AsVal_int(obj2, &val3);
40372 if (!SWIG_IsOK(ecode3)) {
40373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40374 }
40375 arg3 = static_cast< int >(val3);
40376 {
40377 arg4 = wxString_in_helper(obj3);
40378 if (arg4 == NULL) SWIG_fail;
40379 temp4 = true;
40380 }
40381 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40382 if (!SWIG_IsOK(res5)) {
40383 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40384 }
40385 arg5 = reinterpret_cast< wxMenu * >(argp5);
40386 if (obj5) {
40387 {
40388 arg6 = wxString_in_helper(obj5);
40389 if (arg6 == NULL) SWIG_fail;
40390 temp6 = true;
40391 }
40392 }
40393 {
40394 PyThreadState* __tstate = wxPyBeginAllowThreads();
40395 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40396 wxPyEndAllowThreads(__tstate);
40397 if (PyErr_Occurred()) SWIG_fail;
40398 }
40399 {
40400 resultobj = wxPyMake_wxObject(result, (bool)0);
40401 }
40402 {
40403 if (temp4)
40404 delete arg4;
40405 }
40406 {
40407 if (temp6)
40408 delete arg6;
40409 }
40410 return resultobj;
40411 fail:
40412 {
40413 if (temp4)
40414 delete arg4;
40415 }
40416 {
40417 if (temp6)
40418 delete arg6;
40419 }
40420 return NULL;
40421 }
40422
40423
40424 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40425 PyObject *resultobj = 0;
40426 wxMenu *arg1 = (wxMenu *) 0 ;
40427 int arg2 ;
40428 wxString const &arg3_defvalue = wxPyEmptyString ;
40429 wxString *arg3 = (wxString *) &arg3_defvalue ;
40430 wxString const &arg4_defvalue = wxPyEmptyString ;
40431 wxString *arg4 = (wxString *) &arg4_defvalue ;
40432 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40433 wxMenuItem *result = 0 ;
40434 void *argp1 = 0 ;
40435 int res1 = 0 ;
40436 int val2 ;
40437 int ecode2 = 0 ;
40438 bool temp3 = false ;
40439 bool temp4 = false ;
40440 int val5 ;
40441 int ecode5 = 0 ;
40442 PyObject * obj0 = 0 ;
40443 PyObject * obj1 = 0 ;
40444 PyObject * obj2 = 0 ;
40445 PyObject * obj3 = 0 ;
40446 PyObject * obj4 = 0 ;
40447 char * kwnames[] = {
40448 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40449 };
40450
40451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40453 if (!SWIG_IsOK(res1)) {
40454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40455 }
40456 arg1 = reinterpret_cast< wxMenu * >(argp1);
40457 ecode2 = SWIG_AsVal_int(obj1, &val2);
40458 if (!SWIG_IsOK(ecode2)) {
40459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40460 }
40461 arg2 = static_cast< int >(val2);
40462 if (obj2) {
40463 {
40464 arg3 = wxString_in_helper(obj2);
40465 if (arg3 == NULL) SWIG_fail;
40466 temp3 = true;
40467 }
40468 }
40469 if (obj3) {
40470 {
40471 arg4 = wxString_in_helper(obj3);
40472 if (arg4 == NULL) SWIG_fail;
40473 temp4 = true;
40474 }
40475 }
40476 if (obj4) {
40477 ecode5 = SWIG_AsVal_int(obj4, &val5);
40478 if (!SWIG_IsOK(ecode5)) {
40479 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40480 }
40481 arg5 = static_cast< wxItemKind >(val5);
40482 }
40483 {
40484 PyThreadState* __tstate = wxPyBeginAllowThreads();
40485 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40486 wxPyEndAllowThreads(__tstate);
40487 if (PyErr_Occurred()) SWIG_fail;
40488 }
40489 {
40490 resultobj = wxPyMake_wxObject(result, (bool)0);
40491 }
40492 {
40493 if (temp3)
40494 delete arg3;
40495 }
40496 {
40497 if (temp4)
40498 delete arg4;
40499 }
40500 return resultobj;
40501 fail:
40502 {
40503 if (temp3)
40504 delete arg3;
40505 }
40506 {
40507 if (temp4)
40508 delete arg4;
40509 }
40510 return NULL;
40511 }
40512
40513
40514 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40515 PyObject *resultobj = 0;
40516 wxMenu *arg1 = (wxMenu *) 0 ;
40517 wxMenuItem *result = 0 ;
40518 void *argp1 = 0 ;
40519 int res1 = 0 ;
40520 PyObject *swig_obj[1] ;
40521
40522 if (!args) SWIG_fail;
40523 swig_obj[0] = args;
40524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40525 if (!SWIG_IsOK(res1)) {
40526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40527 }
40528 arg1 = reinterpret_cast< wxMenu * >(argp1);
40529 {
40530 PyThreadState* __tstate = wxPyBeginAllowThreads();
40531 result = (wxMenuItem *)(arg1)->PrependSeparator();
40532 wxPyEndAllowThreads(__tstate);
40533 if (PyErr_Occurred()) SWIG_fail;
40534 }
40535 {
40536 resultobj = wxPyMake_wxObject(result, (bool)0);
40537 }
40538 return resultobj;
40539 fail:
40540 return NULL;
40541 }
40542
40543
40544 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40545 PyObject *resultobj = 0;
40546 wxMenu *arg1 = (wxMenu *) 0 ;
40547 int arg2 ;
40548 wxString *arg3 = 0 ;
40549 wxString const &arg4_defvalue = wxPyEmptyString ;
40550 wxString *arg4 = (wxString *) &arg4_defvalue ;
40551 wxMenuItem *result = 0 ;
40552 void *argp1 = 0 ;
40553 int res1 = 0 ;
40554 int val2 ;
40555 int ecode2 = 0 ;
40556 bool temp3 = false ;
40557 bool temp4 = false ;
40558 PyObject * obj0 = 0 ;
40559 PyObject * obj1 = 0 ;
40560 PyObject * obj2 = 0 ;
40561 PyObject * obj3 = 0 ;
40562 char * kwnames[] = {
40563 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40564 };
40565
40566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40568 if (!SWIG_IsOK(res1)) {
40569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40570 }
40571 arg1 = reinterpret_cast< wxMenu * >(argp1);
40572 ecode2 = SWIG_AsVal_int(obj1, &val2);
40573 if (!SWIG_IsOK(ecode2)) {
40574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40575 }
40576 arg2 = static_cast< int >(val2);
40577 {
40578 arg3 = wxString_in_helper(obj2);
40579 if (arg3 == NULL) SWIG_fail;
40580 temp3 = true;
40581 }
40582 if (obj3) {
40583 {
40584 arg4 = wxString_in_helper(obj3);
40585 if (arg4 == NULL) SWIG_fail;
40586 temp4 = true;
40587 }
40588 }
40589 {
40590 PyThreadState* __tstate = wxPyBeginAllowThreads();
40591 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40592 wxPyEndAllowThreads(__tstate);
40593 if (PyErr_Occurred()) SWIG_fail;
40594 }
40595 {
40596 resultobj = wxPyMake_wxObject(result, (bool)0);
40597 }
40598 {
40599 if (temp3)
40600 delete arg3;
40601 }
40602 {
40603 if (temp4)
40604 delete arg4;
40605 }
40606 return resultobj;
40607 fail:
40608 {
40609 if (temp3)
40610 delete arg3;
40611 }
40612 {
40613 if (temp4)
40614 delete arg4;
40615 }
40616 return NULL;
40617 }
40618
40619
40620 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40621 PyObject *resultobj = 0;
40622 wxMenu *arg1 = (wxMenu *) 0 ;
40623 int arg2 ;
40624 wxString *arg3 = 0 ;
40625 wxString const &arg4_defvalue = wxPyEmptyString ;
40626 wxString *arg4 = (wxString *) &arg4_defvalue ;
40627 wxMenuItem *result = 0 ;
40628 void *argp1 = 0 ;
40629 int res1 = 0 ;
40630 int val2 ;
40631 int ecode2 = 0 ;
40632 bool temp3 = false ;
40633 bool temp4 = false ;
40634 PyObject * obj0 = 0 ;
40635 PyObject * obj1 = 0 ;
40636 PyObject * obj2 = 0 ;
40637 PyObject * obj3 = 0 ;
40638 char * kwnames[] = {
40639 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40640 };
40641
40642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40644 if (!SWIG_IsOK(res1)) {
40645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40646 }
40647 arg1 = reinterpret_cast< wxMenu * >(argp1);
40648 ecode2 = SWIG_AsVal_int(obj1, &val2);
40649 if (!SWIG_IsOK(ecode2)) {
40650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40651 }
40652 arg2 = static_cast< int >(val2);
40653 {
40654 arg3 = wxString_in_helper(obj2);
40655 if (arg3 == NULL) SWIG_fail;
40656 temp3 = true;
40657 }
40658 if (obj3) {
40659 {
40660 arg4 = wxString_in_helper(obj3);
40661 if (arg4 == NULL) SWIG_fail;
40662 temp4 = true;
40663 }
40664 }
40665 {
40666 PyThreadState* __tstate = wxPyBeginAllowThreads();
40667 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40668 wxPyEndAllowThreads(__tstate);
40669 if (PyErr_Occurred()) SWIG_fail;
40670 }
40671 {
40672 resultobj = wxPyMake_wxObject(result, (bool)0);
40673 }
40674 {
40675 if (temp3)
40676 delete arg3;
40677 }
40678 {
40679 if (temp4)
40680 delete arg4;
40681 }
40682 return resultobj;
40683 fail:
40684 {
40685 if (temp3)
40686 delete arg3;
40687 }
40688 {
40689 if (temp4)
40690 delete arg4;
40691 }
40692 return NULL;
40693 }
40694
40695
40696 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40697 PyObject *resultobj = 0;
40698 wxMenu *arg1 = (wxMenu *) 0 ;
40699 int arg2 ;
40700 wxString *arg3 = 0 ;
40701 wxMenu *arg4 = (wxMenu *) 0 ;
40702 wxString const &arg5_defvalue = wxPyEmptyString ;
40703 wxString *arg5 = (wxString *) &arg5_defvalue ;
40704 wxMenuItem *result = 0 ;
40705 void *argp1 = 0 ;
40706 int res1 = 0 ;
40707 int val2 ;
40708 int ecode2 = 0 ;
40709 bool temp3 = false ;
40710 void *argp4 = 0 ;
40711 int res4 = 0 ;
40712 bool temp5 = false ;
40713 PyObject * obj0 = 0 ;
40714 PyObject * obj1 = 0 ;
40715 PyObject * obj2 = 0 ;
40716 PyObject * obj3 = 0 ;
40717 PyObject * obj4 = 0 ;
40718 char * kwnames[] = {
40719 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40720 };
40721
40722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40724 if (!SWIG_IsOK(res1)) {
40725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40726 }
40727 arg1 = reinterpret_cast< wxMenu * >(argp1);
40728 ecode2 = SWIG_AsVal_int(obj1, &val2);
40729 if (!SWIG_IsOK(ecode2)) {
40730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40731 }
40732 arg2 = static_cast< int >(val2);
40733 {
40734 arg3 = wxString_in_helper(obj2);
40735 if (arg3 == NULL) SWIG_fail;
40736 temp3 = true;
40737 }
40738 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40739 if (!SWIG_IsOK(res4)) {
40740 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40741 }
40742 arg4 = reinterpret_cast< wxMenu * >(argp4);
40743 if (obj4) {
40744 {
40745 arg5 = wxString_in_helper(obj4);
40746 if (arg5 == NULL) SWIG_fail;
40747 temp5 = true;
40748 }
40749 }
40750 {
40751 PyThreadState* __tstate = wxPyBeginAllowThreads();
40752 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 {
40757 resultobj = wxPyMake_wxObject(result, (bool)0);
40758 }
40759 {
40760 if (temp3)
40761 delete arg3;
40762 }
40763 {
40764 if (temp5)
40765 delete arg5;
40766 }
40767 return resultobj;
40768 fail:
40769 {
40770 if (temp3)
40771 delete arg3;
40772 }
40773 {
40774 if (temp5)
40775 delete arg5;
40776 }
40777 return NULL;
40778 }
40779
40780
40781 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40782 PyObject *resultobj = 0;
40783 wxMenu *arg1 = (wxMenu *) 0 ;
40784 int arg2 ;
40785 wxMenuItem *result = 0 ;
40786 void *argp1 = 0 ;
40787 int res1 = 0 ;
40788 int val2 ;
40789 int ecode2 = 0 ;
40790 PyObject * obj0 = 0 ;
40791 PyObject * obj1 = 0 ;
40792 char * kwnames[] = {
40793 (char *) "self",(char *) "id", NULL
40794 };
40795
40796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40798 if (!SWIG_IsOK(res1)) {
40799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40800 }
40801 arg1 = reinterpret_cast< wxMenu * >(argp1);
40802 ecode2 = SWIG_AsVal_int(obj1, &val2);
40803 if (!SWIG_IsOK(ecode2)) {
40804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40805 }
40806 arg2 = static_cast< int >(val2);
40807 {
40808 PyThreadState* __tstate = wxPyBeginAllowThreads();
40809 result = (wxMenuItem *)(arg1)->Remove(arg2);
40810 wxPyEndAllowThreads(__tstate);
40811 if (PyErr_Occurred()) SWIG_fail;
40812 }
40813 {
40814 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40815 }
40816 return resultobj;
40817 fail:
40818 return NULL;
40819 }
40820
40821
40822 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40823 PyObject *resultobj = 0;
40824 wxMenu *arg1 = (wxMenu *) 0 ;
40825 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40826 wxMenuItem *result = 0 ;
40827 void *argp1 = 0 ;
40828 int res1 = 0 ;
40829 void *argp2 = 0 ;
40830 int res2 = 0 ;
40831 PyObject * obj0 = 0 ;
40832 PyObject * obj1 = 0 ;
40833 char * kwnames[] = {
40834 (char *) "self",(char *) "item", NULL
40835 };
40836
40837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40839 if (!SWIG_IsOK(res1)) {
40840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40841 }
40842 arg1 = reinterpret_cast< wxMenu * >(argp1);
40843 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40844 if (!SWIG_IsOK(res2)) {
40845 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40846 }
40847 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40848 {
40849 PyThreadState* __tstate = wxPyBeginAllowThreads();
40850 result = (wxMenuItem *)(arg1)->Remove(arg2);
40851 wxPyEndAllowThreads(__tstate);
40852 if (PyErr_Occurred()) SWIG_fail;
40853 }
40854 {
40855 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40856 }
40857 return resultobj;
40858 fail:
40859 return NULL;
40860 }
40861
40862
40863 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40864 PyObject *resultobj = 0;
40865 wxMenu *arg1 = (wxMenu *) 0 ;
40866 int arg2 ;
40867 bool result;
40868 void *argp1 = 0 ;
40869 int res1 = 0 ;
40870 int val2 ;
40871 int ecode2 = 0 ;
40872 PyObject * obj0 = 0 ;
40873 PyObject * obj1 = 0 ;
40874 char * kwnames[] = {
40875 (char *) "self",(char *) "id", NULL
40876 };
40877
40878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40880 if (!SWIG_IsOK(res1)) {
40881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40882 }
40883 arg1 = reinterpret_cast< wxMenu * >(argp1);
40884 ecode2 = SWIG_AsVal_int(obj1, &val2);
40885 if (!SWIG_IsOK(ecode2)) {
40886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40887 }
40888 arg2 = static_cast< int >(val2);
40889 {
40890 PyThreadState* __tstate = wxPyBeginAllowThreads();
40891 result = (bool)(arg1)->Delete(arg2);
40892 wxPyEndAllowThreads(__tstate);
40893 if (PyErr_Occurred()) SWIG_fail;
40894 }
40895 {
40896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40897 }
40898 return resultobj;
40899 fail:
40900 return NULL;
40901 }
40902
40903
40904 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40905 PyObject *resultobj = 0;
40906 wxMenu *arg1 = (wxMenu *) 0 ;
40907 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40908 bool result;
40909 void *argp1 = 0 ;
40910 int res1 = 0 ;
40911 void *argp2 = 0 ;
40912 int res2 = 0 ;
40913 PyObject * obj0 = 0 ;
40914 PyObject * obj1 = 0 ;
40915 char * kwnames[] = {
40916 (char *) "self",(char *) "item", NULL
40917 };
40918
40919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40921 if (!SWIG_IsOK(res1)) {
40922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40923 }
40924 arg1 = reinterpret_cast< wxMenu * >(argp1);
40925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40926 if (!SWIG_IsOK(res2)) {
40927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40928 }
40929 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40930 {
40931 PyThreadState* __tstate = wxPyBeginAllowThreads();
40932 result = (bool)(arg1)->Delete(arg2);
40933 wxPyEndAllowThreads(__tstate);
40934 if (PyErr_Occurred()) SWIG_fail;
40935 }
40936 {
40937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40938 }
40939 return resultobj;
40940 fail:
40941 return NULL;
40942 }
40943
40944
40945 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40946 PyObject *resultobj = 0;
40947 wxMenu *arg1 = (wxMenu *) 0 ;
40948 void *argp1 = 0 ;
40949 int res1 = 0 ;
40950 PyObject *swig_obj[1] ;
40951
40952 if (!args) SWIG_fail;
40953 swig_obj[0] = args;
40954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40955 if (!SWIG_IsOK(res1)) {
40956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40957 }
40958 arg1 = reinterpret_cast< wxMenu * >(argp1);
40959 {
40960 PyThreadState* __tstate = wxPyBeginAllowThreads();
40961 wxMenu_Destroy(arg1);
40962 wxPyEndAllowThreads(__tstate);
40963 if (PyErr_Occurred()) SWIG_fail;
40964 }
40965 resultobj = SWIG_Py_Void();
40966 return resultobj;
40967 fail:
40968 return NULL;
40969 }
40970
40971
40972 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40973 PyObject *resultobj = 0;
40974 wxMenu *arg1 = (wxMenu *) 0 ;
40975 int arg2 ;
40976 bool result;
40977 void *argp1 = 0 ;
40978 int res1 = 0 ;
40979 int val2 ;
40980 int ecode2 = 0 ;
40981 PyObject * obj0 = 0 ;
40982 PyObject * obj1 = 0 ;
40983 char * kwnames[] = {
40984 (char *) "self",(char *) "id", NULL
40985 };
40986
40987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40989 if (!SWIG_IsOK(res1)) {
40990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40991 }
40992 arg1 = reinterpret_cast< wxMenu * >(argp1);
40993 ecode2 = SWIG_AsVal_int(obj1, &val2);
40994 if (!SWIG_IsOK(ecode2)) {
40995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40996 }
40997 arg2 = static_cast< int >(val2);
40998 {
40999 PyThreadState* __tstate = wxPyBeginAllowThreads();
41000 result = (bool)(arg1)->Destroy(arg2);
41001 wxPyEndAllowThreads(__tstate);
41002 if (PyErr_Occurred()) SWIG_fail;
41003 }
41004 {
41005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41006 }
41007 return resultobj;
41008 fail:
41009 return NULL;
41010 }
41011
41012
41013 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41014 PyObject *resultobj = 0;
41015 wxMenu *arg1 = (wxMenu *) 0 ;
41016 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41017 bool result;
41018 void *argp1 = 0 ;
41019 int res1 = 0 ;
41020 void *argp2 = 0 ;
41021 int res2 = 0 ;
41022 PyObject * obj0 = 0 ;
41023 PyObject * obj1 = 0 ;
41024 char * kwnames[] = {
41025 (char *) "self",(char *) "item", NULL
41026 };
41027
41028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41030 if (!SWIG_IsOK(res1)) {
41031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41032 }
41033 arg1 = reinterpret_cast< wxMenu * >(argp1);
41034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41035 if (!SWIG_IsOK(res2)) {
41036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41037 }
41038 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41039 {
41040 PyThreadState* __tstate = wxPyBeginAllowThreads();
41041 result = (bool)(arg1)->Destroy(arg2);
41042 wxPyEndAllowThreads(__tstate);
41043 if (PyErr_Occurred()) SWIG_fail;
41044 }
41045 {
41046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41047 }
41048 return resultobj;
41049 fail:
41050 return NULL;
41051 }
41052
41053
41054 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41055 PyObject *resultobj = 0;
41056 wxMenu *arg1 = (wxMenu *) 0 ;
41057 size_t result;
41058 void *argp1 = 0 ;
41059 int res1 = 0 ;
41060 PyObject *swig_obj[1] ;
41061
41062 if (!args) SWIG_fail;
41063 swig_obj[0] = args;
41064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41065 if (!SWIG_IsOK(res1)) {
41066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41067 }
41068 arg1 = reinterpret_cast< wxMenu * >(argp1);
41069 {
41070 PyThreadState* __tstate = wxPyBeginAllowThreads();
41071 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41072 wxPyEndAllowThreads(__tstate);
41073 if (PyErr_Occurred()) SWIG_fail;
41074 }
41075 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41076 return resultobj;
41077 fail:
41078 return NULL;
41079 }
41080
41081
41082 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41083 PyObject *resultobj = 0;
41084 wxMenu *arg1 = (wxMenu *) 0 ;
41085 PyObject *result = 0 ;
41086 void *argp1 = 0 ;
41087 int res1 = 0 ;
41088 PyObject *swig_obj[1] ;
41089
41090 if (!args) SWIG_fail;
41091 swig_obj[0] = args;
41092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41093 if (!SWIG_IsOK(res1)) {
41094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41095 }
41096 arg1 = reinterpret_cast< wxMenu * >(argp1);
41097 {
41098 PyThreadState* __tstate = wxPyBeginAllowThreads();
41099 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41100 wxPyEndAllowThreads(__tstate);
41101 if (PyErr_Occurred()) SWIG_fail;
41102 }
41103 resultobj = result;
41104 return resultobj;
41105 fail:
41106 return NULL;
41107 }
41108
41109
41110 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41111 PyObject *resultobj = 0;
41112 wxMenu *arg1 = (wxMenu *) 0 ;
41113 wxString *arg2 = 0 ;
41114 int result;
41115 void *argp1 = 0 ;
41116 int res1 = 0 ;
41117 bool temp2 = false ;
41118 PyObject * obj0 = 0 ;
41119 PyObject * obj1 = 0 ;
41120 char * kwnames[] = {
41121 (char *) "self",(char *) "item", NULL
41122 };
41123
41124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41126 if (!SWIG_IsOK(res1)) {
41127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41128 }
41129 arg1 = reinterpret_cast< wxMenu * >(argp1);
41130 {
41131 arg2 = wxString_in_helper(obj1);
41132 if (arg2 == NULL) SWIG_fail;
41133 temp2 = true;
41134 }
41135 {
41136 PyThreadState* __tstate = wxPyBeginAllowThreads();
41137 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41138 wxPyEndAllowThreads(__tstate);
41139 if (PyErr_Occurred()) SWIG_fail;
41140 }
41141 resultobj = SWIG_From_int(static_cast< int >(result));
41142 {
41143 if (temp2)
41144 delete arg2;
41145 }
41146 return resultobj;
41147 fail:
41148 {
41149 if (temp2)
41150 delete arg2;
41151 }
41152 return NULL;
41153 }
41154
41155
41156 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41157 PyObject *resultobj = 0;
41158 wxMenu *arg1 = (wxMenu *) 0 ;
41159 int arg2 ;
41160 wxMenuItem *result = 0 ;
41161 void *argp1 = 0 ;
41162 int res1 = 0 ;
41163 int val2 ;
41164 int ecode2 = 0 ;
41165 PyObject * obj0 = 0 ;
41166 PyObject * obj1 = 0 ;
41167 char * kwnames[] = {
41168 (char *) "self",(char *) "id", NULL
41169 };
41170
41171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41173 if (!SWIG_IsOK(res1)) {
41174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41175 }
41176 arg1 = reinterpret_cast< wxMenu * >(argp1);
41177 ecode2 = SWIG_AsVal_int(obj1, &val2);
41178 if (!SWIG_IsOK(ecode2)) {
41179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41180 }
41181 arg2 = static_cast< int >(val2);
41182 {
41183 PyThreadState* __tstate = wxPyBeginAllowThreads();
41184 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41185 wxPyEndAllowThreads(__tstate);
41186 if (PyErr_Occurred()) SWIG_fail;
41187 }
41188 {
41189 resultobj = wxPyMake_wxObject(result, (bool)0);
41190 }
41191 return resultobj;
41192 fail:
41193 return NULL;
41194 }
41195
41196
41197 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41198 PyObject *resultobj = 0;
41199 wxMenu *arg1 = (wxMenu *) 0 ;
41200 size_t arg2 ;
41201 wxMenuItem *result = 0 ;
41202 void *argp1 = 0 ;
41203 int res1 = 0 ;
41204 size_t val2 ;
41205 int ecode2 = 0 ;
41206 PyObject * obj0 = 0 ;
41207 PyObject * obj1 = 0 ;
41208 char * kwnames[] = {
41209 (char *) "self",(char *) "position", NULL
41210 };
41211
41212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41214 if (!SWIG_IsOK(res1)) {
41215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41216 }
41217 arg1 = reinterpret_cast< wxMenu * >(argp1);
41218 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41219 if (!SWIG_IsOK(ecode2)) {
41220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41221 }
41222 arg2 = static_cast< size_t >(val2);
41223 {
41224 PyThreadState* __tstate = wxPyBeginAllowThreads();
41225 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41226 wxPyEndAllowThreads(__tstate);
41227 if (PyErr_Occurred()) SWIG_fail;
41228 }
41229 {
41230 resultobj = wxPyMake_wxObject(result, (bool)0);
41231 }
41232 return resultobj;
41233 fail:
41234 return NULL;
41235 }
41236
41237
41238 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41239 PyObject *resultobj = 0;
41240 wxMenu *arg1 = (wxMenu *) 0 ;
41241 int arg2 ;
41242 bool arg3 ;
41243 void *argp1 = 0 ;
41244 int res1 = 0 ;
41245 int val2 ;
41246 int ecode2 = 0 ;
41247 bool val3 ;
41248 int ecode3 = 0 ;
41249 PyObject * obj0 = 0 ;
41250 PyObject * obj1 = 0 ;
41251 PyObject * obj2 = 0 ;
41252 char * kwnames[] = {
41253 (char *) "self",(char *) "id",(char *) "enable", NULL
41254 };
41255
41256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41258 if (!SWIG_IsOK(res1)) {
41259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41260 }
41261 arg1 = reinterpret_cast< wxMenu * >(argp1);
41262 ecode2 = SWIG_AsVal_int(obj1, &val2);
41263 if (!SWIG_IsOK(ecode2)) {
41264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41265 }
41266 arg2 = static_cast< int >(val2);
41267 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41268 if (!SWIG_IsOK(ecode3)) {
41269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41270 }
41271 arg3 = static_cast< bool >(val3);
41272 {
41273 PyThreadState* __tstate = wxPyBeginAllowThreads();
41274 (arg1)->Enable(arg2,arg3);
41275 wxPyEndAllowThreads(__tstate);
41276 if (PyErr_Occurred()) SWIG_fail;
41277 }
41278 resultobj = SWIG_Py_Void();
41279 return resultobj;
41280 fail:
41281 return NULL;
41282 }
41283
41284
41285 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41286 PyObject *resultobj = 0;
41287 wxMenu *arg1 = (wxMenu *) 0 ;
41288 int arg2 ;
41289 bool result;
41290 void *argp1 = 0 ;
41291 int res1 = 0 ;
41292 int val2 ;
41293 int ecode2 = 0 ;
41294 PyObject * obj0 = 0 ;
41295 PyObject * obj1 = 0 ;
41296 char * kwnames[] = {
41297 (char *) "self",(char *) "id", NULL
41298 };
41299
41300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41302 if (!SWIG_IsOK(res1)) {
41303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41304 }
41305 arg1 = reinterpret_cast< wxMenu * >(argp1);
41306 ecode2 = SWIG_AsVal_int(obj1, &val2);
41307 if (!SWIG_IsOK(ecode2)) {
41308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41309 }
41310 arg2 = static_cast< int >(val2);
41311 {
41312 PyThreadState* __tstate = wxPyBeginAllowThreads();
41313 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 {
41318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41319 }
41320 return resultobj;
41321 fail:
41322 return NULL;
41323 }
41324
41325
41326 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41327 PyObject *resultobj = 0;
41328 wxMenu *arg1 = (wxMenu *) 0 ;
41329 int arg2 ;
41330 bool arg3 ;
41331 void *argp1 = 0 ;
41332 int res1 = 0 ;
41333 int val2 ;
41334 int ecode2 = 0 ;
41335 bool val3 ;
41336 int ecode3 = 0 ;
41337 PyObject * obj0 = 0 ;
41338 PyObject * obj1 = 0 ;
41339 PyObject * obj2 = 0 ;
41340 char * kwnames[] = {
41341 (char *) "self",(char *) "id",(char *) "check", NULL
41342 };
41343
41344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41346 if (!SWIG_IsOK(res1)) {
41347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41348 }
41349 arg1 = reinterpret_cast< wxMenu * >(argp1);
41350 ecode2 = SWIG_AsVal_int(obj1, &val2);
41351 if (!SWIG_IsOK(ecode2)) {
41352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41353 }
41354 arg2 = static_cast< int >(val2);
41355 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41356 if (!SWIG_IsOK(ecode3)) {
41357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41358 }
41359 arg3 = static_cast< bool >(val3);
41360 {
41361 PyThreadState* __tstate = wxPyBeginAllowThreads();
41362 (arg1)->Check(arg2,arg3);
41363 wxPyEndAllowThreads(__tstate);
41364 if (PyErr_Occurred()) SWIG_fail;
41365 }
41366 resultobj = SWIG_Py_Void();
41367 return resultobj;
41368 fail:
41369 return NULL;
41370 }
41371
41372
41373 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41374 PyObject *resultobj = 0;
41375 wxMenu *arg1 = (wxMenu *) 0 ;
41376 int arg2 ;
41377 bool result;
41378 void *argp1 = 0 ;
41379 int res1 = 0 ;
41380 int val2 ;
41381 int ecode2 = 0 ;
41382 PyObject * obj0 = 0 ;
41383 PyObject * obj1 = 0 ;
41384 char * kwnames[] = {
41385 (char *) "self",(char *) "id", NULL
41386 };
41387
41388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41390 if (!SWIG_IsOK(res1)) {
41391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41392 }
41393 arg1 = reinterpret_cast< wxMenu * >(argp1);
41394 ecode2 = SWIG_AsVal_int(obj1, &val2);
41395 if (!SWIG_IsOK(ecode2)) {
41396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41397 }
41398 arg2 = static_cast< int >(val2);
41399 {
41400 PyThreadState* __tstate = wxPyBeginAllowThreads();
41401 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41402 wxPyEndAllowThreads(__tstate);
41403 if (PyErr_Occurred()) SWIG_fail;
41404 }
41405 {
41406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41407 }
41408 return resultobj;
41409 fail:
41410 return NULL;
41411 }
41412
41413
41414 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41415 PyObject *resultobj = 0;
41416 wxMenu *arg1 = (wxMenu *) 0 ;
41417 int arg2 ;
41418 wxString *arg3 = 0 ;
41419 void *argp1 = 0 ;
41420 int res1 = 0 ;
41421 int val2 ;
41422 int ecode2 = 0 ;
41423 bool temp3 = false ;
41424 PyObject * obj0 = 0 ;
41425 PyObject * obj1 = 0 ;
41426 PyObject * obj2 = 0 ;
41427 char * kwnames[] = {
41428 (char *) "self",(char *) "id",(char *) "label", NULL
41429 };
41430
41431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41433 if (!SWIG_IsOK(res1)) {
41434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41435 }
41436 arg1 = reinterpret_cast< wxMenu * >(argp1);
41437 ecode2 = SWIG_AsVal_int(obj1, &val2);
41438 if (!SWIG_IsOK(ecode2)) {
41439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41440 }
41441 arg2 = static_cast< int >(val2);
41442 {
41443 arg3 = wxString_in_helper(obj2);
41444 if (arg3 == NULL) SWIG_fail;
41445 temp3 = true;
41446 }
41447 {
41448 PyThreadState* __tstate = wxPyBeginAllowThreads();
41449 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41450 wxPyEndAllowThreads(__tstate);
41451 if (PyErr_Occurred()) SWIG_fail;
41452 }
41453 resultobj = SWIG_Py_Void();
41454 {
41455 if (temp3)
41456 delete arg3;
41457 }
41458 return resultobj;
41459 fail:
41460 {
41461 if (temp3)
41462 delete arg3;
41463 }
41464 return NULL;
41465 }
41466
41467
41468 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41469 PyObject *resultobj = 0;
41470 wxMenu *arg1 = (wxMenu *) 0 ;
41471 int arg2 ;
41472 wxString result;
41473 void *argp1 = 0 ;
41474 int res1 = 0 ;
41475 int val2 ;
41476 int ecode2 = 0 ;
41477 PyObject * obj0 = 0 ;
41478 PyObject * obj1 = 0 ;
41479 char * kwnames[] = {
41480 (char *) "self",(char *) "id", NULL
41481 };
41482
41483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41485 if (!SWIG_IsOK(res1)) {
41486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41487 }
41488 arg1 = reinterpret_cast< wxMenu * >(argp1);
41489 ecode2 = SWIG_AsVal_int(obj1, &val2);
41490 if (!SWIG_IsOK(ecode2)) {
41491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41492 }
41493 arg2 = static_cast< int >(val2);
41494 {
41495 PyThreadState* __tstate = wxPyBeginAllowThreads();
41496 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41497 wxPyEndAllowThreads(__tstate);
41498 if (PyErr_Occurred()) SWIG_fail;
41499 }
41500 {
41501 #if wxUSE_UNICODE
41502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41503 #else
41504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41505 #endif
41506 }
41507 return resultobj;
41508 fail:
41509 return NULL;
41510 }
41511
41512
41513 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41514 PyObject *resultobj = 0;
41515 wxMenu *arg1 = (wxMenu *) 0 ;
41516 int arg2 ;
41517 wxString *arg3 = 0 ;
41518 void *argp1 = 0 ;
41519 int res1 = 0 ;
41520 int val2 ;
41521 int ecode2 = 0 ;
41522 bool temp3 = false ;
41523 PyObject * obj0 = 0 ;
41524 PyObject * obj1 = 0 ;
41525 PyObject * obj2 = 0 ;
41526 char * kwnames[] = {
41527 (char *) "self",(char *) "id",(char *) "helpString", NULL
41528 };
41529
41530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41532 if (!SWIG_IsOK(res1)) {
41533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41534 }
41535 arg1 = reinterpret_cast< wxMenu * >(argp1);
41536 ecode2 = SWIG_AsVal_int(obj1, &val2);
41537 if (!SWIG_IsOK(ecode2)) {
41538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41539 }
41540 arg2 = static_cast< int >(val2);
41541 {
41542 arg3 = wxString_in_helper(obj2);
41543 if (arg3 == NULL) SWIG_fail;
41544 temp3 = true;
41545 }
41546 {
41547 PyThreadState* __tstate = wxPyBeginAllowThreads();
41548 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41549 wxPyEndAllowThreads(__tstate);
41550 if (PyErr_Occurred()) SWIG_fail;
41551 }
41552 resultobj = SWIG_Py_Void();
41553 {
41554 if (temp3)
41555 delete arg3;
41556 }
41557 return resultobj;
41558 fail:
41559 {
41560 if (temp3)
41561 delete arg3;
41562 }
41563 return NULL;
41564 }
41565
41566
41567 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41568 PyObject *resultobj = 0;
41569 wxMenu *arg1 = (wxMenu *) 0 ;
41570 int arg2 ;
41571 wxString result;
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:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41584 if (!SWIG_IsOK(res1)) {
41585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41586 }
41587 arg1 = reinterpret_cast< wxMenu * >(argp1);
41588 ecode2 = SWIG_AsVal_int(obj1, &val2);
41589 if (!SWIG_IsOK(ecode2)) {
41590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41591 }
41592 arg2 = static_cast< int >(val2);
41593 {
41594 PyThreadState* __tstate = wxPyBeginAllowThreads();
41595 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41596 wxPyEndAllowThreads(__tstate);
41597 if (PyErr_Occurred()) SWIG_fail;
41598 }
41599 {
41600 #if wxUSE_UNICODE
41601 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41602 #else
41603 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41604 #endif
41605 }
41606 return resultobj;
41607 fail:
41608 return NULL;
41609 }
41610
41611
41612 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41613 PyObject *resultobj = 0;
41614 wxMenu *arg1 = (wxMenu *) 0 ;
41615 wxString *arg2 = 0 ;
41616 void *argp1 = 0 ;
41617 int res1 = 0 ;
41618 bool temp2 = false ;
41619 PyObject * obj0 = 0 ;
41620 PyObject * obj1 = 0 ;
41621 char * kwnames[] = {
41622 (char *) "self",(char *) "title", NULL
41623 };
41624
41625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41627 if (!SWIG_IsOK(res1)) {
41628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41629 }
41630 arg1 = reinterpret_cast< wxMenu * >(argp1);
41631 {
41632 arg2 = wxString_in_helper(obj1);
41633 if (arg2 == NULL) SWIG_fail;
41634 temp2 = true;
41635 }
41636 {
41637 PyThreadState* __tstate = wxPyBeginAllowThreads();
41638 (arg1)->SetTitle((wxString const &)*arg2);
41639 wxPyEndAllowThreads(__tstate);
41640 if (PyErr_Occurred()) SWIG_fail;
41641 }
41642 resultobj = SWIG_Py_Void();
41643 {
41644 if (temp2)
41645 delete arg2;
41646 }
41647 return resultobj;
41648 fail:
41649 {
41650 if (temp2)
41651 delete arg2;
41652 }
41653 return NULL;
41654 }
41655
41656
41657 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41658 PyObject *resultobj = 0;
41659 wxMenu *arg1 = (wxMenu *) 0 ;
41660 wxString result;
41661 void *argp1 = 0 ;
41662 int res1 = 0 ;
41663 PyObject *swig_obj[1] ;
41664
41665 if (!args) SWIG_fail;
41666 swig_obj[0] = args;
41667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41668 if (!SWIG_IsOK(res1)) {
41669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41670 }
41671 arg1 = reinterpret_cast< wxMenu * >(argp1);
41672 {
41673 PyThreadState* __tstate = wxPyBeginAllowThreads();
41674 result = ((wxMenu const *)arg1)->GetTitle();
41675 wxPyEndAllowThreads(__tstate);
41676 if (PyErr_Occurred()) SWIG_fail;
41677 }
41678 {
41679 #if wxUSE_UNICODE
41680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41681 #else
41682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41683 #endif
41684 }
41685 return resultobj;
41686 fail:
41687 return NULL;
41688 }
41689
41690
41691 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41692 PyObject *resultobj = 0;
41693 wxMenu *arg1 = (wxMenu *) 0 ;
41694 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41695 void *argp1 = 0 ;
41696 int res1 = 0 ;
41697 void *argp2 = 0 ;
41698 int res2 = 0 ;
41699 PyObject * obj0 = 0 ;
41700 PyObject * obj1 = 0 ;
41701 char * kwnames[] = {
41702 (char *) "self",(char *) "handler", NULL
41703 };
41704
41705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41707 if (!SWIG_IsOK(res1)) {
41708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41709 }
41710 arg1 = reinterpret_cast< wxMenu * >(argp1);
41711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41712 if (!SWIG_IsOK(res2)) {
41713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41714 }
41715 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41716 {
41717 PyThreadState* __tstate = wxPyBeginAllowThreads();
41718 (arg1)->SetEventHandler(arg2);
41719 wxPyEndAllowThreads(__tstate);
41720 if (PyErr_Occurred()) SWIG_fail;
41721 }
41722 resultobj = SWIG_Py_Void();
41723 return resultobj;
41724 fail:
41725 return NULL;
41726 }
41727
41728
41729 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41730 PyObject *resultobj = 0;
41731 wxMenu *arg1 = (wxMenu *) 0 ;
41732 wxEvtHandler *result = 0 ;
41733 void *argp1 = 0 ;
41734 int res1 = 0 ;
41735 PyObject *swig_obj[1] ;
41736
41737 if (!args) SWIG_fail;
41738 swig_obj[0] = args;
41739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41740 if (!SWIG_IsOK(res1)) {
41741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41742 }
41743 arg1 = reinterpret_cast< wxMenu * >(argp1);
41744 {
41745 PyThreadState* __tstate = wxPyBeginAllowThreads();
41746 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41747 wxPyEndAllowThreads(__tstate);
41748 if (PyErr_Occurred()) SWIG_fail;
41749 }
41750 {
41751 resultobj = wxPyMake_wxObject(result, 0);
41752 }
41753 return resultobj;
41754 fail:
41755 return NULL;
41756 }
41757
41758
41759 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41760 PyObject *resultobj = 0;
41761 wxMenu *arg1 = (wxMenu *) 0 ;
41762 wxWindow *arg2 = (wxWindow *) 0 ;
41763 void *argp1 = 0 ;
41764 int res1 = 0 ;
41765 void *argp2 = 0 ;
41766 int res2 = 0 ;
41767 PyObject * obj0 = 0 ;
41768 PyObject * obj1 = 0 ;
41769 char * kwnames[] = {
41770 (char *) "self",(char *) "win", NULL
41771 };
41772
41773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41775 if (!SWIG_IsOK(res1)) {
41776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41777 }
41778 arg1 = reinterpret_cast< wxMenu * >(argp1);
41779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41780 if (!SWIG_IsOK(res2)) {
41781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41782 }
41783 arg2 = reinterpret_cast< wxWindow * >(argp2);
41784 {
41785 PyThreadState* __tstate = wxPyBeginAllowThreads();
41786 (arg1)->SetInvokingWindow(arg2);
41787 wxPyEndAllowThreads(__tstate);
41788 if (PyErr_Occurred()) SWIG_fail;
41789 }
41790 resultobj = SWIG_Py_Void();
41791 return resultobj;
41792 fail:
41793 return NULL;
41794 }
41795
41796
41797 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41798 PyObject *resultobj = 0;
41799 wxMenu *arg1 = (wxMenu *) 0 ;
41800 wxWindow *result = 0 ;
41801 void *argp1 = 0 ;
41802 int res1 = 0 ;
41803 PyObject *swig_obj[1] ;
41804
41805 if (!args) SWIG_fail;
41806 swig_obj[0] = args;
41807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41808 if (!SWIG_IsOK(res1)) {
41809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41810 }
41811 arg1 = reinterpret_cast< wxMenu * >(argp1);
41812 {
41813 PyThreadState* __tstate = wxPyBeginAllowThreads();
41814 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41815 wxPyEndAllowThreads(__tstate);
41816 if (PyErr_Occurred()) SWIG_fail;
41817 }
41818 {
41819 resultobj = wxPyMake_wxObject(result, 0);
41820 }
41821 return resultobj;
41822 fail:
41823 return NULL;
41824 }
41825
41826
41827 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41828 PyObject *resultobj = 0;
41829 wxMenu *arg1 = (wxMenu *) 0 ;
41830 long result;
41831 void *argp1 = 0 ;
41832 int res1 = 0 ;
41833 PyObject *swig_obj[1] ;
41834
41835 if (!args) SWIG_fail;
41836 swig_obj[0] = args;
41837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41838 if (!SWIG_IsOK(res1)) {
41839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41840 }
41841 arg1 = reinterpret_cast< wxMenu * >(argp1);
41842 {
41843 PyThreadState* __tstate = wxPyBeginAllowThreads();
41844 result = (long)((wxMenu const *)arg1)->GetStyle();
41845 wxPyEndAllowThreads(__tstate);
41846 if (PyErr_Occurred()) SWIG_fail;
41847 }
41848 resultobj = SWIG_From_long(static_cast< long >(result));
41849 return resultobj;
41850 fail:
41851 return NULL;
41852 }
41853
41854
41855 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41856 PyObject *resultobj = 0;
41857 wxMenu *arg1 = (wxMenu *) 0 ;
41858 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41859 void *argp1 = 0 ;
41860 int res1 = 0 ;
41861 void *argp2 = 0 ;
41862 int res2 = 0 ;
41863 PyObject * obj0 = 0 ;
41864 PyObject * obj1 = 0 ;
41865 char * kwnames[] = {
41866 (char *) "self",(char *) "source", NULL
41867 };
41868
41869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41871 if (!SWIG_IsOK(res1)) {
41872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41873 }
41874 arg1 = reinterpret_cast< wxMenu * >(argp1);
41875 if (obj1) {
41876 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41877 if (!SWIG_IsOK(res2)) {
41878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41879 }
41880 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41881 }
41882 {
41883 PyThreadState* __tstate = wxPyBeginAllowThreads();
41884 (arg1)->UpdateUI(arg2);
41885 wxPyEndAllowThreads(__tstate);
41886 if (PyErr_Occurred()) SWIG_fail;
41887 }
41888 resultobj = SWIG_Py_Void();
41889 return resultobj;
41890 fail:
41891 return NULL;
41892 }
41893
41894
41895 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41896 PyObject *resultobj = 0;
41897 wxMenu *arg1 = (wxMenu *) 0 ;
41898 wxMenuBar *result = 0 ;
41899 void *argp1 = 0 ;
41900 int res1 = 0 ;
41901 PyObject *swig_obj[1] ;
41902
41903 if (!args) SWIG_fail;
41904 swig_obj[0] = args;
41905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41906 if (!SWIG_IsOK(res1)) {
41907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41908 }
41909 arg1 = reinterpret_cast< wxMenu * >(argp1);
41910 {
41911 PyThreadState* __tstate = wxPyBeginAllowThreads();
41912 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41913 wxPyEndAllowThreads(__tstate);
41914 if (PyErr_Occurred()) SWIG_fail;
41915 }
41916 {
41917 resultobj = wxPyMake_wxObject(result, (bool)0);
41918 }
41919 return resultobj;
41920 fail:
41921 return NULL;
41922 }
41923
41924
41925 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41926 PyObject *resultobj = 0;
41927 wxMenu *arg1 = (wxMenu *) 0 ;
41928 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41929 void *argp1 = 0 ;
41930 int res1 = 0 ;
41931 void *argp2 = 0 ;
41932 int res2 = 0 ;
41933 PyObject * obj0 = 0 ;
41934 PyObject * obj1 = 0 ;
41935 char * kwnames[] = {
41936 (char *) "self",(char *) "menubar", NULL
41937 };
41938
41939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41941 if (!SWIG_IsOK(res1)) {
41942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41943 }
41944 arg1 = reinterpret_cast< wxMenu * >(argp1);
41945 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41946 if (!SWIG_IsOK(res2)) {
41947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41948 }
41949 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41950 {
41951 PyThreadState* __tstate = wxPyBeginAllowThreads();
41952 (arg1)->Attach(arg2);
41953 wxPyEndAllowThreads(__tstate);
41954 if (PyErr_Occurred()) SWIG_fail;
41955 }
41956 resultobj = SWIG_Py_Void();
41957 return resultobj;
41958 fail:
41959 return NULL;
41960 }
41961
41962
41963 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41964 PyObject *resultobj = 0;
41965 wxMenu *arg1 = (wxMenu *) 0 ;
41966 void *argp1 = 0 ;
41967 int res1 = 0 ;
41968 PyObject *swig_obj[1] ;
41969
41970 if (!args) SWIG_fail;
41971 swig_obj[0] = args;
41972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41973 if (!SWIG_IsOK(res1)) {
41974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41975 }
41976 arg1 = reinterpret_cast< wxMenu * >(argp1);
41977 {
41978 PyThreadState* __tstate = wxPyBeginAllowThreads();
41979 (arg1)->Detach();
41980 wxPyEndAllowThreads(__tstate);
41981 if (PyErr_Occurred()) SWIG_fail;
41982 }
41983 resultobj = SWIG_Py_Void();
41984 return resultobj;
41985 fail:
41986 return NULL;
41987 }
41988
41989
41990 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41991 PyObject *resultobj = 0;
41992 wxMenu *arg1 = (wxMenu *) 0 ;
41993 bool result;
41994 void *argp1 = 0 ;
41995 int res1 = 0 ;
41996 PyObject *swig_obj[1] ;
41997
41998 if (!args) SWIG_fail;
41999 swig_obj[0] = args;
42000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42001 if (!SWIG_IsOK(res1)) {
42002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42003 }
42004 arg1 = reinterpret_cast< wxMenu * >(argp1);
42005 {
42006 PyThreadState* __tstate = wxPyBeginAllowThreads();
42007 result = (bool)((wxMenu const *)arg1)->IsAttached();
42008 wxPyEndAllowThreads(__tstate);
42009 if (PyErr_Occurred()) SWIG_fail;
42010 }
42011 {
42012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42013 }
42014 return resultobj;
42015 fail:
42016 return NULL;
42017 }
42018
42019
42020 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42021 PyObject *resultobj = 0;
42022 wxMenu *arg1 = (wxMenu *) 0 ;
42023 wxMenu *arg2 = (wxMenu *) 0 ;
42024 void *argp1 = 0 ;
42025 int res1 = 0 ;
42026 void *argp2 = 0 ;
42027 int res2 = 0 ;
42028 PyObject * obj0 = 0 ;
42029 PyObject * obj1 = 0 ;
42030 char * kwnames[] = {
42031 (char *) "self",(char *) "parent", NULL
42032 };
42033
42034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42036 if (!SWIG_IsOK(res1)) {
42037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42038 }
42039 arg1 = reinterpret_cast< wxMenu * >(argp1);
42040 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42041 if (!SWIG_IsOK(res2)) {
42042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42043 }
42044 arg2 = reinterpret_cast< wxMenu * >(argp2);
42045 {
42046 PyThreadState* __tstate = wxPyBeginAllowThreads();
42047 (arg1)->SetParent(arg2);
42048 wxPyEndAllowThreads(__tstate);
42049 if (PyErr_Occurred()) SWIG_fail;
42050 }
42051 resultobj = SWIG_Py_Void();
42052 return resultobj;
42053 fail:
42054 return NULL;
42055 }
42056
42057
42058 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42059 PyObject *resultobj = 0;
42060 wxMenu *arg1 = (wxMenu *) 0 ;
42061 wxMenu *result = 0 ;
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_wxMenu, 0 | 0 );
42069 if (!SWIG_IsOK(res1)) {
42070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42071 }
42072 arg1 = reinterpret_cast< wxMenu * >(argp1);
42073 {
42074 PyThreadState* __tstate = wxPyBeginAllowThreads();
42075 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42076 wxPyEndAllowThreads(__tstate);
42077 if (PyErr_Occurred()) SWIG_fail;
42078 }
42079 {
42080 resultobj = wxPyMake_wxObject(result, 0);
42081 }
42082 return resultobj;
42083 fail:
42084 return NULL;
42085 }
42086
42087
42088 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42089 PyObject *obj;
42090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42091 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42092 return SWIG_Py_Void();
42093 }
42094
42095 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42096 return SWIG_Python_InitShadowInstance(args);
42097 }
42098
42099 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42100 PyObject *resultobj = 0;
42101 long arg1 = (long) 0 ;
42102 wxMenuBar *result = 0 ;
42103 long val1 ;
42104 int ecode1 = 0 ;
42105 PyObject * obj0 = 0 ;
42106 char * kwnames[] = {
42107 (char *) "style", NULL
42108 };
42109
42110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42111 if (obj0) {
42112 ecode1 = SWIG_AsVal_long(obj0, &val1);
42113 if (!SWIG_IsOK(ecode1)) {
42114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42115 }
42116 arg1 = static_cast< long >(val1);
42117 }
42118 {
42119 if (!wxPyCheckForApp()) SWIG_fail;
42120 PyThreadState* __tstate = wxPyBeginAllowThreads();
42121 result = (wxMenuBar *)new wxMenuBar(arg1);
42122 wxPyEndAllowThreads(__tstate);
42123 if (PyErr_Occurred()) SWIG_fail;
42124 }
42125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42126 return resultobj;
42127 fail:
42128 return NULL;
42129 }
42130
42131
42132 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42133 PyObject *resultobj = 0;
42134 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42135 wxMenu *arg2 = (wxMenu *) 0 ;
42136 wxString *arg3 = 0 ;
42137 bool result;
42138 void *argp1 = 0 ;
42139 int res1 = 0 ;
42140 void *argp2 = 0 ;
42141 int res2 = 0 ;
42142 bool temp3 = false ;
42143 PyObject * obj0 = 0 ;
42144 PyObject * obj1 = 0 ;
42145 PyObject * obj2 = 0 ;
42146 char * kwnames[] = {
42147 (char *) "self",(char *) "menu",(char *) "title", NULL
42148 };
42149
42150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42152 if (!SWIG_IsOK(res1)) {
42153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42154 }
42155 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42156 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42157 if (!SWIG_IsOK(res2)) {
42158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42159 }
42160 arg2 = reinterpret_cast< wxMenu * >(argp2);
42161 {
42162 arg3 = wxString_in_helper(obj2);
42163 if (arg3 == NULL) SWIG_fail;
42164 temp3 = true;
42165 }
42166 {
42167 PyThreadState* __tstate = wxPyBeginAllowThreads();
42168 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42169 wxPyEndAllowThreads(__tstate);
42170 if (PyErr_Occurred()) SWIG_fail;
42171 }
42172 {
42173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42174 }
42175 {
42176 if (temp3)
42177 delete arg3;
42178 }
42179 return resultobj;
42180 fail:
42181 {
42182 if (temp3)
42183 delete arg3;
42184 }
42185 return NULL;
42186 }
42187
42188
42189 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42190 PyObject *resultobj = 0;
42191 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42192 size_t arg2 ;
42193 wxMenu *arg3 = (wxMenu *) 0 ;
42194 wxString *arg4 = 0 ;
42195 bool result;
42196 void *argp1 = 0 ;
42197 int res1 = 0 ;
42198 size_t val2 ;
42199 int ecode2 = 0 ;
42200 void *argp3 = 0 ;
42201 int res3 = 0 ;
42202 bool temp4 = false ;
42203 PyObject * obj0 = 0 ;
42204 PyObject * obj1 = 0 ;
42205 PyObject * obj2 = 0 ;
42206 PyObject * obj3 = 0 ;
42207 char * kwnames[] = {
42208 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42209 };
42210
42211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42213 if (!SWIG_IsOK(res1)) {
42214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42215 }
42216 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42217 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42218 if (!SWIG_IsOK(ecode2)) {
42219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42220 }
42221 arg2 = static_cast< size_t >(val2);
42222 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42223 if (!SWIG_IsOK(res3)) {
42224 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42225 }
42226 arg3 = reinterpret_cast< wxMenu * >(argp3);
42227 {
42228 arg4 = wxString_in_helper(obj3);
42229 if (arg4 == NULL) SWIG_fail;
42230 temp4 = true;
42231 }
42232 {
42233 PyThreadState* __tstate = wxPyBeginAllowThreads();
42234 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42235 wxPyEndAllowThreads(__tstate);
42236 if (PyErr_Occurred()) SWIG_fail;
42237 }
42238 {
42239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42240 }
42241 {
42242 if (temp4)
42243 delete arg4;
42244 }
42245 return resultobj;
42246 fail:
42247 {
42248 if (temp4)
42249 delete arg4;
42250 }
42251 return NULL;
42252 }
42253
42254
42255 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42256 PyObject *resultobj = 0;
42257 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42258 size_t result;
42259 void *argp1 = 0 ;
42260 int res1 = 0 ;
42261 PyObject *swig_obj[1] ;
42262
42263 if (!args) SWIG_fail;
42264 swig_obj[0] = args;
42265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42266 if (!SWIG_IsOK(res1)) {
42267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42268 }
42269 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42270 {
42271 PyThreadState* __tstate = wxPyBeginAllowThreads();
42272 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42273 wxPyEndAllowThreads(__tstate);
42274 if (PyErr_Occurred()) SWIG_fail;
42275 }
42276 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42277 return resultobj;
42278 fail:
42279 return NULL;
42280 }
42281
42282
42283 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42284 PyObject *resultobj = 0;
42285 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42286 size_t arg2 ;
42287 wxMenu *result = 0 ;
42288 void *argp1 = 0 ;
42289 int res1 = 0 ;
42290 size_t val2 ;
42291 int ecode2 = 0 ;
42292 PyObject * obj0 = 0 ;
42293 PyObject * obj1 = 0 ;
42294 char * kwnames[] = {
42295 (char *) "self",(char *) "pos", NULL
42296 };
42297
42298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42300 if (!SWIG_IsOK(res1)) {
42301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42302 }
42303 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42304 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42305 if (!SWIG_IsOK(ecode2)) {
42306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42307 }
42308 arg2 = static_cast< size_t >(val2);
42309 {
42310 PyThreadState* __tstate = wxPyBeginAllowThreads();
42311 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42312 wxPyEndAllowThreads(__tstate);
42313 if (PyErr_Occurred()) SWIG_fail;
42314 }
42315 {
42316 resultobj = wxPyMake_wxObject(result, 0);
42317 }
42318 return resultobj;
42319 fail:
42320 return NULL;
42321 }
42322
42323
42324 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42325 PyObject *resultobj = 0;
42326 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42327 size_t arg2 ;
42328 wxMenu *arg3 = (wxMenu *) 0 ;
42329 wxString *arg4 = 0 ;
42330 wxMenu *result = 0 ;
42331 void *argp1 = 0 ;
42332 int res1 = 0 ;
42333 size_t val2 ;
42334 int ecode2 = 0 ;
42335 void *argp3 = 0 ;
42336 int res3 = 0 ;
42337 bool temp4 = false ;
42338 PyObject * obj0 = 0 ;
42339 PyObject * obj1 = 0 ;
42340 PyObject * obj2 = 0 ;
42341 PyObject * obj3 = 0 ;
42342 char * kwnames[] = {
42343 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42344 };
42345
42346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42348 if (!SWIG_IsOK(res1)) {
42349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42350 }
42351 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42352 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42353 if (!SWIG_IsOK(ecode2)) {
42354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42355 }
42356 arg2 = static_cast< size_t >(val2);
42357 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42358 if (!SWIG_IsOK(res3)) {
42359 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42360 }
42361 arg3 = reinterpret_cast< wxMenu * >(argp3);
42362 {
42363 arg4 = wxString_in_helper(obj3);
42364 if (arg4 == NULL) SWIG_fail;
42365 temp4 = true;
42366 }
42367 {
42368 PyThreadState* __tstate = wxPyBeginAllowThreads();
42369 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42370 wxPyEndAllowThreads(__tstate);
42371 if (PyErr_Occurred()) SWIG_fail;
42372 }
42373 {
42374 resultobj = wxPyMake_wxObject(result, 0);
42375 }
42376 {
42377 if (temp4)
42378 delete arg4;
42379 }
42380 return resultobj;
42381 fail:
42382 {
42383 if (temp4)
42384 delete arg4;
42385 }
42386 return NULL;
42387 }
42388
42389
42390 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42391 PyObject *resultobj = 0;
42392 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42393 size_t arg2 ;
42394 wxMenu *result = 0 ;
42395 void *argp1 = 0 ;
42396 int res1 = 0 ;
42397 size_t val2 ;
42398 int ecode2 = 0 ;
42399 PyObject * obj0 = 0 ;
42400 PyObject * obj1 = 0 ;
42401 char * kwnames[] = {
42402 (char *) "self",(char *) "pos", NULL
42403 };
42404
42405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42407 if (!SWIG_IsOK(res1)) {
42408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42409 }
42410 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42411 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42412 if (!SWIG_IsOK(ecode2)) {
42413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42414 }
42415 arg2 = static_cast< size_t >(val2);
42416 {
42417 PyThreadState* __tstate = wxPyBeginAllowThreads();
42418 result = (wxMenu *)(arg1)->Remove(arg2);
42419 wxPyEndAllowThreads(__tstate);
42420 if (PyErr_Occurred()) SWIG_fail;
42421 }
42422 {
42423 resultobj = wxPyMake_wxObject(result, 0);
42424 }
42425 return resultobj;
42426 fail:
42427 return NULL;
42428 }
42429
42430
42431 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42432 PyObject *resultobj = 0;
42433 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42434 size_t arg2 ;
42435 bool arg3 ;
42436 void *argp1 = 0 ;
42437 int res1 = 0 ;
42438 size_t val2 ;
42439 int ecode2 = 0 ;
42440 bool val3 ;
42441 int ecode3 = 0 ;
42442 PyObject * obj0 = 0 ;
42443 PyObject * obj1 = 0 ;
42444 PyObject * obj2 = 0 ;
42445 char * kwnames[] = {
42446 (char *) "self",(char *) "pos",(char *) "enable", NULL
42447 };
42448
42449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42451 if (!SWIG_IsOK(res1)) {
42452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42453 }
42454 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42455 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42456 if (!SWIG_IsOK(ecode2)) {
42457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42458 }
42459 arg2 = static_cast< size_t >(val2);
42460 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42461 if (!SWIG_IsOK(ecode3)) {
42462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42463 }
42464 arg3 = static_cast< bool >(val3);
42465 {
42466 PyThreadState* __tstate = wxPyBeginAllowThreads();
42467 (arg1)->EnableTop(arg2,arg3);
42468 wxPyEndAllowThreads(__tstate);
42469 if (PyErr_Occurred()) SWIG_fail;
42470 }
42471 resultobj = SWIG_Py_Void();
42472 return resultobj;
42473 fail:
42474 return NULL;
42475 }
42476
42477
42478 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42479 PyObject *resultobj = 0;
42480 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42481 size_t arg2 ;
42482 bool result;
42483 void *argp1 = 0 ;
42484 int res1 = 0 ;
42485 size_t val2 ;
42486 int ecode2 = 0 ;
42487 PyObject * obj0 = 0 ;
42488 PyObject * obj1 = 0 ;
42489 char * kwnames[] = {
42490 (char *) "self",(char *) "pos", NULL
42491 };
42492
42493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42495 if (!SWIG_IsOK(res1)) {
42496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42497 }
42498 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42499 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42500 if (!SWIG_IsOK(ecode2)) {
42501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42502 }
42503 arg2 = static_cast< size_t >(val2);
42504 {
42505 PyThreadState* __tstate = wxPyBeginAllowThreads();
42506 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42507 wxPyEndAllowThreads(__tstate);
42508 if (PyErr_Occurred()) SWIG_fail;
42509 }
42510 {
42511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42512 }
42513 return resultobj;
42514 fail:
42515 return NULL;
42516 }
42517
42518
42519 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42520 PyObject *resultobj = 0;
42521 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42522 size_t arg2 ;
42523 wxString *arg3 = 0 ;
42524 void *argp1 = 0 ;
42525 int res1 = 0 ;
42526 size_t val2 ;
42527 int ecode2 = 0 ;
42528 bool temp3 = false ;
42529 PyObject * obj0 = 0 ;
42530 PyObject * obj1 = 0 ;
42531 PyObject * obj2 = 0 ;
42532 char * kwnames[] = {
42533 (char *) "self",(char *) "pos",(char *) "label", NULL
42534 };
42535
42536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42538 if (!SWIG_IsOK(res1)) {
42539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42540 }
42541 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42542 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42543 if (!SWIG_IsOK(ecode2)) {
42544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42545 }
42546 arg2 = static_cast< size_t >(val2);
42547 {
42548 arg3 = wxString_in_helper(obj2);
42549 if (arg3 == NULL) SWIG_fail;
42550 temp3 = true;
42551 }
42552 {
42553 PyThreadState* __tstate = wxPyBeginAllowThreads();
42554 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42555 wxPyEndAllowThreads(__tstate);
42556 if (PyErr_Occurred()) SWIG_fail;
42557 }
42558 resultobj = SWIG_Py_Void();
42559 {
42560 if (temp3)
42561 delete arg3;
42562 }
42563 return resultobj;
42564 fail:
42565 {
42566 if (temp3)
42567 delete arg3;
42568 }
42569 return NULL;
42570 }
42571
42572
42573 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42574 PyObject *resultobj = 0;
42575 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42576 size_t arg2 ;
42577 wxString result;
42578 void *argp1 = 0 ;
42579 int res1 = 0 ;
42580 size_t val2 ;
42581 int ecode2 = 0 ;
42582 PyObject * obj0 = 0 ;
42583 PyObject * obj1 = 0 ;
42584 char * kwnames[] = {
42585 (char *) "self",(char *) "pos", NULL
42586 };
42587
42588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42590 if (!SWIG_IsOK(res1)) {
42591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42592 }
42593 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42594 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42595 if (!SWIG_IsOK(ecode2)) {
42596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42597 }
42598 arg2 = static_cast< size_t >(val2);
42599 {
42600 PyThreadState* __tstate = wxPyBeginAllowThreads();
42601 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42602 wxPyEndAllowThreads(__tstate);
42603 if (PyErr_Occurred()) SWIG_fail;
42604 }
42605 {
42606 #if wxUSE_UNICODE
42607 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42608 #else
42609 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42610 #endif
42611 }
42612 return resultobj;
42613 fail:
42614 return NULL;
42615 }
42616
42617
42618 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42619 PyObject *resultobj = 0;
42620 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42621 wxString *arg2 = 0 ;
42622 wxString *arg3 = 0 ;
42623 int result;
42624 void *argp1 = 0 ;
42625 int res1 = 0 ;
42626 bool temp2 = false ;
42627 bool temp3 = false ;
42628 PyObject * obj0 = 0 ;
42629 PyObject * obj1 = 0 ;
42630 PyObject * obj2 = 0 ;
42631 char * kwnames[] = {
42632 (char *) "self",(char *) "menu",(char *) "item", NULL
42633 };
42634
42635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42637 if (!SWIG_IsOK(res1)) {
42638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42639 }
42640 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42641 {
42642 arg2 = wxString_in_helper(obj1);
42643 if (arg2 == NULL) SWIG_fail;
42644 temp2 = true;
42645 }
42646 {
42647 arg3 = wxString_in_helper(obj2);
42648 if (arg3 == NULL) SWIG_fail;
42649 temp3 = true;
42650 }
42651 {
42652 PyThreadState* __tstate = wxPyBeginAllowThreads();
42653 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42654 wxPyEndAllowThreads(__tstate);
42655 if (PyErr_Occurred()) SWIG_fail;
42656 }
42657 resultobj = SWIG_From_int(static_cast< int >(result));
42658 {
42659 if (temp2)
42660 delete arg2;
42661 }
42662 {
42663 if (temp3)
42664 delete arg3;
42665 }
42666 return resultobj;
42667 fail:
42668 {
42669 if (temp2)
42670 delete arg2;
42671 }
42672 {
42673 if (temp3)
42674 delete arg3;
42675 }
42676 return NULL;
42677 }
42678
42679
42680 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42681 PyObject *resultobj = 0;
42682 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42683 int arg2 ;
42684 wxMenuItem *result = 0 ;
42685 void *argp1 = 0 ;
42686 int res1 = 0 ;
42687 int val2 ;
42688 int ecode2 = 0 ;
42689 PyObject * obj0 = 0 ;
42690 PyObject * obj1 = 0 ;
42691 char * kwnames[] = {
42692 (char *) "self",(char *) "id", NULL
42693 };
42694
42695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42697 if (!SWIG_IsOK(res1)) {
42698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42699 }
42700 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42701 ecode2 = SWIG_AsVal_int(obj1, &val2);
42702 if (!SWIG_IsOK(ecode2)) {
42703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42704 }
42705 arg2 = static_cast< int >(val2);
42706 {
42707 PyThreadState* __tstate = wxPyBeginAllowThreads();
42708 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42709 wxPyEndAllowThreads(__tstate);
42710 if (PyErr_Occurred()) SWIG_fail;
42711 }
42712 {
42713 resultobj = wxPyMake_wxObject(result, (bool)0);
42714 }
42715 return resultobj;
42716 fail:
42717 return NULL;
42718 }
42719
42720
42721 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42722 PyObject *resultobj = 0;
42723 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42724 wxString *arg2 = 0 ;
42725 int result;
42726 void *argp1 = 0 ;
42727 int res1 = 0 ;
42728 bool temp2 = false ;
42729 PyObject * obj0 = 0 ;
42730 PyObject * obj1 = 0 ;
42731 char * kwnames[] = {
42732 (char *) "self",(char *) "title", NULL
42733 };
42734
42735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42737 if (!SWIG_IsOK(res1)) {
42738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42739 }
42740 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42741 {
42742 arg2 = wxString_in_helper(obj1);
42743 if (arg2 == NULL) SWIG_fail;
42744 temp2 = true;
42745 }
42746 {
42747 PyThreadState* __tstate = wxPyBeginAllowThreads();
42748 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42749 wxPyEndAllowThreads(__tstate);
42750 if (PyErr_Occurred()) SWIG_fail;
42751 }
42752 resultobj = SWIG_From_int(static_cast< int >(result));
42753 {
42754 if (temp2)
42755 delete arg2;
42756 }
42757 return resultobj;
42758 fail:
42759 {
42760 if (temp2)
42761 delete arg2;
42762 }
42763 return NULL;
42764 }
42765
42766
42767 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42768 PyObject *resultobj = 0;
42769 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42770 int arg2 ;
42771 bool arg3 ;
42772 void *argp1 = 0 ;
42773 int res1 = 0 ;
42774 int val2 ;
42775 int ecode2 = 0 ;
42776 bool val3 ;
42777 int ecode3 = 0 ;
42778 PyObject * obj0 = 0 ;
42779 PyObject * obj1 = 0 ;
42780 PyObject * obj2 = 0 ;
42781 char * kwnames[] = {
42782 (char *) "self",(char *) "id",(char *) "enable", NULL
42783 };
42784
42785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42787 if (!SWIG_IsOK(res1)) {
42788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42789 }
42790 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42791 ecode2 = SWIG_AsVal_int(obj1, &val2);
42792 if (!SWIG_IsOK(ecode2)) {
42793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42794 }
42795 arg2 = static_cast< int >(val2);
42796 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42797 if (!SWIG_IsOK(ecode3)) {
42798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42799 }
42800 arg3 = static_cast< bool >(val3);
42801 {
42802 PyThreadState* __tstate = wxPyBeginAllowThreads();
42803 (arg1)->Enable(arg2,arg3);
42804 wxPyEndAllowThreads(__tstate);
42805 if (PyErr_Occurred()) SWIG_fail;
42806 }
42807 resultobj = SWIG_Py_Void();
42808 return resultobj;
42809 fail:
42810 return NULL;
42811 }
42812
42813
42814 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42815 PyObject *resultobj = 0;
42816 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42817 int arg2 ;
42818 bool arg3 ;
42819 void *argp1 = 0 ;
42820 int res1 = 0 ;
42821 int val2 ;
42822 int ecode2 = 0 ;
42823 bool val3 ;
42824 int ecode3 = 0 ;
42825 PyObject * obj0 = 0 ;
42826 PyObject * obj1 = 0 ;
42827 PyObject * obj2 = 0 ;
42828 char * kwnames[] = {
42829 (char *) "self",(char *) "id",(char *) "check", NULL
42830 };
42831
42832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42834 if (!SWIG_IsOK(res1)) {
42835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42836 }
42837 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42838 ecode2 = SWIG_AsVal_int(obj1, &val2);
42839 if (!SWIG_IsOK(ecode2)) {
42840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42841 }
42842 arg2 = static_cast< int >(val2);
42843 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42844 if (!SWIG_IsOK(ecode3)) {
42845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42846 }
42847 arg3 = static_cast< bool >(val3);
42848 {
42849 PyThreadState* __tstate = wxPyBeginAllowThreads();
42850 (arg1)->Check(arg2,arg3);
42851 wxPyEndAllowThreads(__tstate);
42852 if (PyErr_Occurred()) SWIG_fail;
42853 }
42854 resultobj = SWIG_Py_Void();
42855 return resultobj;
42856 fail:
42857 return NULL;
42858 }
42859
42860
42861 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42862 PyObject *resultobj = 0;
42863 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42864 int arg2 ;
42865 bool result;
42866 void *argp1 = 0 ;
42867 int res1 = 0 ;
42868 int val2 ;
42869 int ecode2 = 0 ;
42870 PyObject * obj0 = 0 ;
42871 PyObject * obj1 = 0 ;
42872 char * kwnames[] = {
42873 (char *) "self",(char *) "id", NULL
42874 };
42875
42876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42878 if (!SWIG_IsOK(res1)) {
42879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42880 }
42881 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42882 ecode2 = SWIG_AsVal_int(obj1, &val2);
42883 if (!SWIG_IsOK(ecode2)) {
42884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42885 }
42886 arg2 = static_cast< int >(val2);
42887 {
42888 PyThreadState* __tstate = wxPyBeginAllowThreads();
42889 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42890 wxPyEndAllowThreads(__tstate);
42891 if (PyErr_Occurred()) SWIG_fail;
42892 }
42893 {
42894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42895 }
42896 return resultobj;
42897 fail:
42898 return NULL;
42899 }
42900
42901
42902 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42903 PyObject *resultobj = 0;
42904 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42905 int arg2 ;
42906 bool result;
42907 void *argp1 = 0 ;
42908 int res1 = 0 ;
42909 int val2 ;
42910 int ecode2 = 0 ;
42911 PyObject * obj0 = 0 ;
42912 PyObject * obj1 = 0 ;
42913 char * kwnames[] = {
42914 (char *) "self",(char *) "id", NULL
42915 };
42916
42917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42919 if (!SWIG_IsOK(res1)) {
42920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42921 }
42922 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42923 ecode2 = SWIG_AsVal_int(obj1, &val2);
42924 if (!SWIG_IsOK(ecode2)) {
42925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42926 }
42927 arg2 = static_cast< int >(val2);
42928 {
42929 PyThreadState* __tstate = wxPyBeginAllowThreads();
42930 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42931 wxPyEndAllowThreads(__tstate);
42932 if (PyErr_Occurred()) SWIG_fail;
42933 }
42934 {
42935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42936 }
42937 return resultobj;
42938 fail:
42939 return NULL;
42940 }
42941
42942
42943 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42944 PyObject *resultobj = 0;
42945 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42946 int arg2 ;
42947 wxString *arg3 = 0 ;
42948 void *argp1 = 0 ;
42949 int res1 = 0 ;
42950 int val2 ;
42951 int ecode2 = 0 ;
42952 bool temp3 = false ;
42953 PyObject * obj0 = 0 ;
42954 PyObject * obj1 = 0 ;
42955 PyObject * obj2 = 0 ;
42956 char * kwnames[] = {
42957 (char *) "self",(char *) "id",(char *) "label", NULL
42958 };
42959
42960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42962 if (!SWIG_IsOK(res1)) {
42963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42964 }
42965 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42966 ecode2 = SWIG_AsVal_int(obj1, &val2);
42967 if (!SWIG_IsOK(ecode2)) {
42968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42969 }
42970 arg2 = static_cast< int >(val2);
42971 {
42972 arg3 = wxString_in_helper(obj2);
42973 if (arg3 == NULL) SWIG_fail;
42974 temp3 = true;
42975 }
42976 {
42977 PyThreadState* __tstate = wxPyBeginAllowThreads();
42978 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42979 wxPyEndAllowThreads(__tstate);
42980 if (PyErr_Occurred()) SWIG_fail;
42981 }
42982 resultobj = SWIG_Py_Void();
42983 {
42984 if (temp3)
42985 delete arg3;
42986 }
42987 return resultobj;
42988 fail:
42989 {
42990 if (temp3)
42991 delete arg3;
42992 }
42993 return NULL;
42994 }
42995
42996
42997 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42998 PyObject *resultobj = 0;
42999 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43000 int arg2 ;
43001 wxString result;
43002 void *argp1 = 0 ;
43003 int res1 = 0 ;
43004 int val2 ;
43005 int ecode2 = 0 ;
43006 PyObject * obj0 = 0 ;
43007 PyObject * obj1 = 0 ;
43008 char * kwnames[] = {
43009 (char *) "self",(char *) "id", NULL
43010 };
43011
43012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43014 if (!SWIG_IsOK(res1)) {
43015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43016 }
43017 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43018 ecode2 = SWIG_AsVal_int(obj1, &val2);
43019 if (!SWIG_IsOK(ecode2)) {
43020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43021 }
43022 arg2 = static_cast< int >(val2);
43023 {
43024 PyThreadState* __tstate = wxPyBeginAllowThreads();
43025 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43026 wxPyEndAllowThreads(__tstate);
43027 if (PyErr_Occurred()) SWIG_fail;
43028 }
43029 {
43030 #if wxUSE_UNICODE
43031 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43032 #else
43033 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43034 #endif
43035 }
43036 return resultobj;
43037 fail:
43038 return NULL;
43039 }
43040
43041
43042 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43043 PyObject *resultobj = 0;
43044 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43045 int arg2 ;
43046 wxString *arg3 = 0 ;
43047 void *argp1 = 0 ;
43048 int res1 = 0 ;
43049 int val2 ;
43050 int ecode2 = 0 ;
43051 bool temp3 = false ;
43052 PyObject * obj0 = 0 ;
43053 PyObject * obj1 = 0 ;
43054 PyObject * obj2 = 0 ;
43055 char * kwnames[] = {
43056 (char *) "self",(char *) "id",(char *) "helpString", NULL
43057 };
43058
43059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43061 if (!SWIG_IsOK(res1)) {
43062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43063 }
43064 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43065 ecode2 = SWIG_AsVal_int(obj1, &val2);
43066 if (!SWIG_IsOK(ecode2)) {
43067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43068 }
43069 arg2 = static_cast< int >(val2);
43070 {
43071 arg3 = wxString_in_helper(obj2);
43072 if (arg3 == NULL) SWIG_fail;
43073 temp3 = true;
43074 }
43075 {
43076 PyThreadState* __tstate = wxPyBeginAllowThreads();
43077 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43078 wxPyEndAllowThreads(__tstate);
43079 if (PyErr_Occurred()) SWIG_fail;
43080 }
43081 resultobj = SWIG_Py_Void();
43082 {
43083 if (temp3)
43084 delete arg3;
43085 }
43086 return resultobj;
43087 fail:
43088 {
43089 if (temp3)
43090 delete arg3;
43091 }
43092 return NULL;
43093 }
43094
43095
43096 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43097 PyObject *resultobj = 0;
43098 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43099 int arg2 ;
43100 wxString result;
43101 void *argp1 = 0 ;
43102 int res1 = 0 ;
43103 int val2 ;
43104 int ecode2 = 0 ;
43105 PyObject * obj0 = 0 ;
43106 PyObject * obj1 = 0 ;
43107 char * kwnames[] = {
43108 (char *) "self",(char *) "id", NULL
43109 };
43110
43111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43113 if (!SWIG_IsOK(res1)) {
43114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43115 }
43116 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43117 ecode2 = SWIG_AsVal_int(obj1, &val2);
43118 if (!SWIG_IsOK(ecode2)) {
43119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43120 }
43121 arg2 = static_cast< int >(val2);
43122 {
43123 PyThreadState* __tstate = wxPyBeginAllowThreads();
43124 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43125 wxPyEndAllowThreads(__tstate);
43126 if (PyErr_Occurred()) SWIG_fail;
43127 }
43128 {
43129 #if wxUSE_UNICODE
43130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43131 #else
43132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43133 #endif
43134 }
43135 return resultobj;
43136 fail:
43137 return NULL;
43138 }
43139
43140
43141 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43142 PyObject *resultobj = 0;
43143 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43144 wxFrame *result = 0 ;
43145 void *argp1 = 0 ;
43146 int res1 = 0 ;
43147 PyObject *swig_obj[1] ;
43148
43149 if (!args) SWIG_fail;
43150 swig_obj[0] = args;
43151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43152 if (!SWIG_IsOK(res1)) {
43153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43154 }
43155 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43156 {
43157 PyThreadState* __tstate = wxPyBeginAllowThreads();
43158 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43159 wxPyEndAllowThreads(__tstate);
43160 if (PyErr_Occurred()) SWIG_fail;
43161 }
43162 {
43163 resultobj = wxPyMake_wxObject(result, (bool)0);
43164 }
43165 return resultobj;
43166 fail:
43167 return NULL;
43168 }
43169
43170
43171 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43172 PyObject *resultobj = 0;
43173 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43174 bool result;
43175 void *argp1 = 0 ;
43176 int res1 = 0 ;
43177 PyObject *swig_obj[1] ;
43178
43179 if (!args) SWIG_fail;
43180 swig_obj[0] = args;
43181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43182 if (!SWIG_IsOK(res1)) {
43183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43184 }
43185 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43186 {
43187 PyThreadState* __tstate = wxPyBeginAllowThreads();
43188 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43189 wxPyEndAllowThreads(__tstate);
43190 if (PyErr_Occurred()) SWIG_fail;
43191 }
43192 {
43193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43194 }
43195 return resultobj;
43196 fail:
43197 return NULL;
43198 }
43199
43200
43201 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43202 PyObject *resultobj = 0;
43203 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43204 wxFrame *arg2 = (wxFrame *) 0 ;
43205 void *argp1 = 0 ;
43206 int res1 = 0 ;
43207 void *argp2 = 0 ;
43208 int res2 = 0 ;
43209 PyObject * obj0 = 0 ;
43210 PyObject * obj1 = 0 ;
43211 char * kwnames[] = {
43212 (char *) "self",(char *) "frame", NULL
43213 };
43214
43215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43217 if (!SWIG_IsOK(res1)) {
43218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43219 }
43220 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43222 if (!SWIG_IsOK(res2)) {
43223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43224 }
43225 arg2 = reinterpret_cast< wxFrame * >(argp2);
43226 {
43227 PyThreadState* __tstate = wxPyBeginAllowThreads();
43228 (arg1)->Attach(arg2);
43229 wxPyEndAllowThreads(__tstate);
43230 if (PyErr_Occurred()) SWIG_fail;
43231 }
43232 resultobj = SWIG_Py_Void();
43233 return resultobj;
43234 fail:
43235 return NULL;
43236 }
43237
43238
43239 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43240 PyObject *resultobj = 0;
43241 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43242 void *argp1 = 0 ;
43243 int res1 = 0 ;
43244 PyObject *swig_obj[1] ;
43245
43246 if (!args) SWIG_fail;
43247 swig_obj[0] = args;
43248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43249 if (!SWIG_IsOK(res1)) {
43250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43251 }
43252 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43253 {
43254 PyThreadState* __tstate = wxPyBeginAllowThreads();
43255 (arg1)->Detach();
43256 wxPyEndAllowThreads(__tstate);
43257 if (PyErr_Occurred()) SWIG_fail;
43258 }
43259 resultobj = SWIG_Py_Void();
43260 return resultobj;
43261 fail:
43262 return NULL;
43263 }
43264
43265
43266 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43267 PyObject *resultobj = 0;
43268 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43269 void *argp1 = 0 ;
43270 int res1 = 0 ;
43271 PyObject *swig_obj[1] ;
43272
43273 if (!args) SWIG_fail;
43274 swig_obj[0] = args;
43275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43276 if (!SWIG_IsOK(res1)) {
43277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43278 }
43279 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43280 {
43281 PyThreadState* __tstate = wxPyBeginAllowThreads();
43282 (arg1)->UpdateMenus();
43283 wxPyEndAllowThreads(__tstate);
43284 if (PyErr_Occurred()) SWIG_fail;
43285 }
43286 resultobj = SWIG_Py_Void();
43287 return resultobj;
43288 fail:
43289 return NULL;
43290 }
43291
43292
43293 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43294 PyObject *resultobj = 0;
43295 bool arg1 ;
43296 bool val1 ;
43297 int ecode1 = 0 ;
43298 PyObject * obj0 = 0 ;
43299 char * kwnames[] = {
43300 (char *) "enable", NULL
43301 };
43302
43303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43304 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43305 if (!SWIG_IsOK(ecode1)) {
43306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43307 }
43308 arg1 = static_cast< bool >(val1);
43309 {
43310 PyThreadState* __tstate = wxPyBeginAllowThreads();
43311 wxMenuBar_SetAutoWindowMenu(arg1);
43312 wxPyEndAllowThreads(__tstate);
43313 if (PyErr_Occurred()) SWIG_fail;
43314 }
43315 resultobj = SWIG_Py_Void();
43316 return resultobj;
43317 fail:
43318 return NULL;
43319 }
43320
43321
43322 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43323 PyObject *resultobj = 0;
43324 bool result;
43325
43326 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43327 {
43328 PyThreadState* __tstate = wxPyBeginAllowThreads();
43329 result = (bool)wxMenuBar_GetAutoWindowMenu();
43330 wxPyEndAllowThreads(__tstate);
43331 if (PyErr_Occurred()) SWIG_fail;
43332 }
43333 {
43334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43335 }
43336 return resultobj;
43337 fail:
43338 return NULL;
43339 }
43340
43341
43342 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43343 PyObject *obj;
43344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43345 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43346 return SWIG_Py_Void();
43347 }
43348
43349 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43350 return SWIG_Python_InitShadowInstance(args);
43351 }
43352
43353 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43354 PyObject *resultobj = 0;
43355 wxMenu *arg1 = (wxMenu *) NULL ;
43356 int arg2 = (int) wxID_ANY ;
43357 wxString const &arg3_defvalue = wxPyEmptyString ;
43358 wxString *arg3 = (wxString *) &arg3_defvalue ;
43359 wxString const &arg4_defvalue = wxPyEmptyString ;
43360 wxString *arg4 = (wxString *) &arg4_defvalue ;
43361 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43362 wxMenu *arg6 = (wxMenu *) NULL ;
43363 wxMenuItem *result = 0 ;
43364 void *argp1 = 0 ;
43365 int res1 = 0 ;
43366 int val2 ;
43367 int ecode2 = 0 ;
43368 bool temp3 = false ;
43369 bool temp4 = false ;
43370 int val5 ;
43371 int ecode5 = 0 ;
43372 void *argp6 = 0 ;
43373 int res6 = 0 ;
43374 PyObject * obj0 = 0 ;
43375 PyObject * obj1 = 0 ;
43376 PyObject * obj2 = 0 ;
43377 PyObject * obj3 = 0 ;
43378 PyObject * obj4 = 0 ;
43379 PyObject * obj5 = 0 ;
43380 char * kwnames[] = {
43381 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43382 };
43383
43384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43385 if (obj0) {
43386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43387 if (!SWIG_IsOK(res1)) {
43388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43389 }
43390 arg1 = reinterpret_cast< wxMenu * >(argp1);
43391 }
43392 if (obj1) {
43393 ecode2 = SWIG_AsVal_int(obj1, &val2);
43394 if (!SWIG_IsOK(ecode2)) {
43395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43396 }
43397 arg2 = static_cast< int >(val2);
43398 }
43399 if (obj2) {
43400 {
43401 arg3 = wxString_in_helper(obj2);
43402 if (arg3 == NULL) SWIG_fail;
43403 temp3 = true;
43404 }
43405 }
43406 if (obj3) {
43407 {
43408 arg4 = wxString_in_helper(obj3);
43409 if (arg4 == NULL) SWIG_fail;
43410 temp4 = true;
43411 }
43412 }
43413 if (obj4) {
43414 ecode5 = SWIG_AsVal_int(obj4, &val5);
43415 if (!SWIG_IsOK(ecode5)) {
43416 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43417 }
43418 arg5 = static_cast< wxItemKind >(val5);
43419 }
43420 if (obj5) {
43421 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43422 if (!SWIG_IsOK(res6)) {
43423 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43424 }
43425 arg6 = reinterpret_cast< wxMenu * >(argp6);
43426 }
43427 {
43428 PyThreadState* __tstate = wxPyBeginAllowThreads();
43429 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43430 wxPyEndAllowThreads(__tstate);
43431 if (PyErr_Occurred()) SWIG_fail;
43432 }
43433 {
43434 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43435 }
43436 {
43437 if (temp3)
43438 delete arg3;
43439 }
43440 {
43441 if (temp4)
43442 delete arg4;
43443 }
43444 return resultobj;
43445 fail:
43446 {
43447 if (temp3)
43448 delete arg3;
43449 }
43450 {
43451 if (temp4)
43452 delete arg4;
43453 }
43454 return NULL;
43455 }
43456
43457
43458 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43459 PyObject *resultobj = 0;
43460 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43461 void *argp1 = 0 ;
43462 int res1 = 0 ;
43463 PyObject *swig_obj[1] ;
43464
43465 if (!args) SWIG_fail;
43466 swig_obj[0] = args;
43467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43468 if (!SWIG_IsOK(res1)) {
43469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43470 }
43471 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43472 {
43473 PyThreadState* __tstate = wxPyBeginAllowThreads();
43474 delete arg1;
43475
43476 wxPyEndAllowThreads(__tstate);
43477 if (PyErr_Occurred()) SWIG_fail;
43478 }
43479 resultobj = SWIG_Py_Void();
43480 return resultobj;
43481 fail:
43482 return NULL;
43483 }
43484
43485
43486 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43487 PyObject *resultobj = 0;
43488 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43489 wxMenu *result = 0 ;
43490 void *argp1 = 0 ;
43491 int res1 = 0 ;
43492 PyObject *swig_obj[1] ;
43493
43494 if (!args) SWIG_fail;
43495 swig_obj[0] = args;
43496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43497 if (!SWIG_IsOK(res1)) {
43498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43499 }
43500 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43501 {
43502 PyThreadState* __tstate = wxPyBeginAllowThreads();
43503 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43504 wxPyEndAllowThreads(__tstate);
43505 if (PyErr_Occurred()) SWIG_fail;
43506 }
43507 {
43508 resultobj = wxPyMake_wxObject(result, 0);
43509 }
43510 return resultobj;
43511 fail:
43512 return NULL;
43513 }
43514
43515
43516 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43517 PyObject *resultobj = 0;
43518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43519 wxMenu *arg2 = (wxMenu *) 0 ;
43520 void *argp1 = 0 ;
43521 int res1 = 0 ;
43522 void *argp2 = 0 ;
43523 int res2 = 0 ;
43524 PyObject * obj0 = 0 ;
43525 PyObject * obj1 = 0 ;
43526 char * kwnames[] = {
43527 (char *) "self",(char *) "menu", NULL
43528 };
43529
43530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43532 if (!SWIG_IsOK(res1)) {
43533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43534 }
43535 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43537 if (!SWIG_IsOK(res2)) {
43538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43539 }
43540 arg2 = reinterpret_cast< wxMenu * >(argp2);
43541 {
43542 PyThreadState* __tstate = wxPyBeginAllowThreads();
43543 (arg1)->SetMenu(arg2);
43544 wxPyEndAllowThreads(__tstate);
43545 if (PyErr_Occurred()) SWIG_fail;
43546 }
43547 resultobj = SWIG_Py_Void();
43548 return resultobj;
43549 fail:
43550 return NULL;
43551 }
43552
43553
43554 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43555 PyObject *resultobj = 0;
43556 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43557 int arg2 ;
43558 void *argp1 = 0 ;
43559 int res1 = 0 ;
43560 int val2 ;
43561 int ecode2 = 0 ;
43562 PyObject * obj0 = 0 ;
43563 PyObject * obj1 = 0 ;
43564 char * kwnames[] = {
43565 (char *) "self",(char *) "id", NULL
43566 };
43567
43568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43570 if (!SWIG_IsOK(res1)) {
43571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43572 }
43573 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43574 ecode2 = SWIG_AsVal_int(obj1, &val2);
43575 if (!SWIG_IsOK(ecode2)) {
43576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43577 }
43578 arg2 = static_cast< int >(val2);
43579 {
43580 PyThreadState* __tstate = wxPyBeginAllowThreads();
43581 (arg1)->SetId(arg2);
43582 wxPyEndAllowThreads(__tstate);
43583 if (PyErr_Occurred()) SWIG_fail;
43584 }
43585 resultobj = SWIG_Py_Void();
43586 return resultobj;
43587 fail:
43588 return NULL;
43589 }
43590
43591
43592 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43593 PyObject *resultobj = 0;
43594 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43595 int result;
43596 void *argp1 = 0 ;
43597 int res1 = 0 ;
43598 PyObject *swig_obj[1] ;
43599
43600 if (!args) SWIG_fail;
43601 swig_obj[0] = args;
43602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43603 if (!SWIG_IsOK(res1)) {
43604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43605 }
43606 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43607 {
43608 PyThreadState* __tstate = wxPyBeginAllowThreads();
43609 result = (int)((wxMenuItem const *)arg1)->GetId();
43610 wxPyEndAllowThreads(__tstate);
43611 if (PyErr_Occurred()) SWIG_fail;
43612 }
43613 resultobj = SWIG_From_int(static_cast< int >(result));
43614 return resultobj;
43615 fail:
43616 return NULL;
43617 }
43618
43619
43620 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43621 PyObject *resultobj = 0;
43622 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43623 bool result;
43624 void *argp1 = 0 ;
43625 int res1 = 0 ;
43626 PyObject *swig_obj[1] ;
43627
43628 if (!args) SWIG_fail;
43629 swig_obj[0] = args;
43630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43631 if (!SWIG_IsOK(res1)) {
43632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43633 }
43634 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43635 {
43636 PyThreadState* __tstate = wxPyBeginAllowThreads();
43637 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43638 wxPyEndAllowThreads(__tstate);
43639 if (PyErr_Occurred()) SWIG_fail;
43640 }
43641 {
43642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43643 }
43644 return resultobj;
43645 fail:
43646 return NULL;
43647 }
43648
43649
43650 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43651 PyObject *resultobj = 0;
43652 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43653 wxString *arg2 = 0 ;
43654 void *argp1 = 0 ;
43655 int res1 = 0 ;
43656 bool temp2 = false ;
43657 PyObject * obj0 = 0 ;
43658 PyObject * obj1 = 0 ;
43659 char * kwnames[] = {
43660 (char *) "self",(char *) "str", NULL
43661 };
43662
43663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43665 if (!SWIG_IsOK(res1)) {
43666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43667 }
43668 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43669 {
43670 arg2 = wxString_in_helper(obj1);
43671 if (arg2 == NULL) SWIG_fail;
43672 temp2 = true;
43673 }
43674 {
43675 PyThreadState* __tstate = wxPyBeginAllowThreads();
43676 (arg1)->SetText((wxString const &)*arg2);
43677 wxPyEndAllowThreads(__tstate);
43678 if (PyErr_Occurred()) SWIG_fail;
43679 }
43680 resultobj = SWIG_Py_Void();
43681 {
43682 if (temp2)
43683 delete arg2;
43684 }
43685 return resultobj;
43686 fail:
43687 {
43688 if (temp2)
43689 delete arg2;
43690 }
43691 return NULL;
43692 }
43693
43694
43695 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43696 PyObject *resultobj = 0;
43697 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43698 wxString result;
43699 void *argp1 = 0 ;
43700 int res1 = 0 ;
43701 PyObject *swig_obj[1] ;
43702
43703 if (!args) SWIG_fail;
43704 swig_obj[0] = args;
43705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43706 if (!SWIG_IsOK(res1)) {
43707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43708 }
43709 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43710 {
43711 PyThreadState* __tstate = wxPyBeginAllowThreads();
43712 result = ((wxMenuItem const *)arg1)->GetLabel();
43713 wxPyEndAllowThreads(__tstate);
43714 if (PyErr_Occurred()) SWIG_fail;
43715 }
43716 {
43717 #if wxUSE_UNICODE
43718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43719 #else
43720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43721 #endif
43722 }
43723 return resultobj;
43724 fail:
43725 return NULL;
43726 }
43727
43728
43729 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43730 PyObject *resultobj = 0;
43731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43732 wxString *result = 0 ;
43733 void *argp1 = 0 ;
43734 int res1 = 0 ;
43735 PyObject *swig_obj[1] ;
43736
43737 if (!args) SWIG_fail;
43738 swig_obj[0] = args;
43739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43740 if (!SWIG_IsOK(res1)) {
43741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43742 }
43743 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43744 {
43745 PyThreadState* __tstate = wxPyBeginAllowThreads();
43746 {
43747 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43748 result = (wxString *) &_result_ref;
43749 }
43750 wxPyEndAllowThreads(__tstate);
43751 if (PyErr_Occurred()) SWIG_fail;
43752 }
43753 {
43754 #if wxUSE_UNICODE
43755 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43756 #else
43757 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43758 #endif
43759 }
43760 return resultobj;
43761 fail:
43762 return NULL;
43763 }
43764
43765
43766 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43767 PyObject *resultobj = 0;
43768 wxString *arg1 = 0 ;
43769 wxString result;
43770 bool temp1 = false ;
43771 PyObject * obj0 = 0 ;
43772 char * kwnames[] = {
43773 (char *) "text", NULL
43774 };
43775
43776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43777 {
43778 arg1 = wxString_in_helper(obj0);
43779 if (arg1 == NULL) SWIG_fail;
43780 temp1 = true;
43781 }
43782 {
43783 PyThreadState* __tstate = wxPyBeginAllowThreads();
43784 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43785 wxPyEndAllowThreads(__tstate);
43786 if (PyErr_Occurred()) SWIG_fail;
43787 }
43788 {
43789 #if wxUSE_UNICODE
43790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43791 #else
43792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43793 #endif
43794 }
43795 {
43796 if (temp1)
43797 delete arg1;
43798 }
43799 return resultobj;
43800 fail:
43801 {
43802 if (temp1)
43803 delete arg1;
43804 }
43805 return NULL;
43806 }
43807
43808
43809 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43810 PyObject *resultobj = 0;
43811 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43812 wxItemKind result;
43813 void *argp1 = 0 ;
43814 int res1 = 0 ;
43815 PyObject *swig_obj[1] ;
43816
43817 if (!args) SWIG_fail;
43818 swig_obj[0] = args;
43819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43820 if (!SWIG_IsOK(res1)) {
43821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43822 }
43823 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43824 {
43825 PyThreadState* __tstate = wxPyBeginAllowThreads();
43826 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43827 wxPyEndAllowThreads(__tstate);
43828 if (PyErr_Occurred()) SWIG_fail;
43829 }
43830 resultobj = SWIG_From_int(static_cast< int >(result));
43831 return resultobj;
43832 fail:
43833 return NULL;
43834 }
43835
43836
43837 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43838 PyObject *resultobj = 0;
43839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43840 wxItemKind arg2 ;
43841 void *argp1 = 0 ;
43842 int res1 = 0 ;
43843 int val2 ;
43844 int ecode2 = 0 ;
43845 PyObject * obj0 = 0 ;
43846 PyObject * obj1 = 0 ;
43847 char * kwnames[] = {
43848 (char *) "self",(char *) "kind", NULL
43849 };
43850
43851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43853 if (!SWIG_IsOK(res1)) {
43854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43855 }
43856 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43857 ecode2 = SWIG_AsVal_int(obj1, &val2);
43858 if (!SWIG_IsOK(ecode2)) {
43859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43860 }
43861 arg2 = static_cast< wxItemKind >(val2);
43862 {
43863 PyThreadState* __tstate = wxPyBeginAllowThreads();
43864 (arg1)->SetKind(arg2);
43865 wxPyEndAllowThreads(__tstate);
43866 if (PyErr_Occurred()) SWIG_fail;
43867 }
43868 resultobj = SWIG_Py_Void();
43869 return resultobj;
43870 fail:
43871 return NULL;
43872 }
43873
43874
43875 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43876 PyObject *resultobj = 0;
43877 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43878 bool arg2 ;
43879 void *argp1 = 0 ;
43880 int res1 = 0 ;
43881 bool val2 ;
43882 int ecode2 = 0 ;
43883 PyObject * obj0 = 0 ;
43884 PyObject * obj1 = 0 ;
43885 char * kwnames[] = {
43886 (char *) "self",(char *) "checkable", NULL
43887 };
43888
43889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43891 if (!SWIG_IsOK(res1)) {
43892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43893 }
43894 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43895 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43896 if (!SWIG_IsOK(ecode2)) {
43897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43898 }
43899 arg2 = static_cast< bool >(val2);
43900 {
43901 PyThreadState* __tstate = wxPyBeginAllowThreads();
43902 (arg1)->SetCheckable(arg2);
43903 wxPyEndAllowThreads(__tstate);
43904 if (PyErr_Occurred()) SWIG_fail;
43905 }
43906 resultobj = SWIG_Py_Void();
43907 return resultobj;
43908 fail:
43909 return NULL;
43910 }
43911
43912
43913 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43914 PyObject *resultobj = 0;
43915 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43916 bool result;
43917 void *argp1 = 0 ;
43918 int res1 = 0 ;
43919 PyObject *swig_obj[1] ;
43920
43921 if (!args) SWIG_fail;
43922 swig_obj[0] = args;
43923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43924 if (!SWIG_IsOK(res1)) {
43925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43926 }
43927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43928 {
43929 PyThreadState* __tstate = wxPyBeginAllowThreads();
43930 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 {
43935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43936 }
43937 return resultobj;
43938 fail:
43939 return NULL;
43940 }
43941
43942
43943 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43944 PyObject *resultobj = 0;
43945 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43946 bool result;
43947 void *argp1 = 0 ;
43948 int res1 = 0 ;
43949 PyObject *swig_obj[1] ;
43950
43951 if (!args) SWIG_fail;
43952 swig_obj[0] = args;
43953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43954 if (!SWIG_IsOK(res1)) {
43955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43956 }
43957 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43958 {
43959 PyThreadState* __tstate = wxPyBeginAllowThreads();
43960 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43961 wxPyEndAllowThreads(__tstate);
43962 if (PyErr_Occurred()) SWIG_fail;
43963 }
43964 {
43965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43966 }
43967 return resultobj;
43968 fail:
43969 return NULL;
43970 }
43971
43972
43973 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43974 PyObject *resultobj = 0;
43975 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43976 wxMenu *arg2 = (wxMenu *) 0 ;
43977 void *argp1 = 0 ;
43978 int res1 = 0 ;
43979 void *argp2 = 0 ;
43980 int res2 = 0 ;
43981 PyObject * obj0 = 0 ;
43982 PyObject * obj1 = 0 ;
43983 char * kwnames[] = {
43984 (char *) "self",(char *) "menu", NULL
43985 };
43986
43987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43989 if (!SWIG_IsOK(res1)) {
43990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43991 }
43992 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43993 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43994 if (!SWIG_IsOK(res2)) {
43995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43996 }
43997 arg2 = reinterpret_cast< wxMenu * >(argp2);
43998 {
43999 PyThreadState* __tstate = wxPyBeginAllowThreads();
44000 (arg1)->SetSubMenu(arg2);
44001 wxPyEndAllowThreads(__tstate);
44002 if (PyErr_Occurred()) SWIG_fail;
44003 }
44004 resultobj = SWIG_Py_Void();
44005 return resultobj;
44006 fail:
44007 return NULL;
44008 }
44009
44010
44011 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44012 PyObject *resultobj = 0;
44013 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44014 wxMenu *result = 0 ;
44015 void *argp1 = 0 ;
44016 int res1 = 0 ;
44017 PyObject *swig_obj[1] ;
44018
44019 if (!args) SWIG_fail;
44020 swig_obj[0] = args;
44021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44022 if (!SWIG_IsOK(res1)) {
44023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44024 }
44025 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44026 {
44027 PyThreadState* __tstate = wxPyBeginAllowThreads();
44028 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44029 wxPyEndAllowThreads(__tstate);
44030 if (PyErr_Occurred()) SWIG_fail;
44031 }
44032 {
44033 resultobj = wxPyMake_wxObject(result, 0);
44034 }
44035 return resultobj;
44036 fail:
44037 return NULL;
44038 }
44039
44040
44041 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44042 PyObject *resultobj = 0;
44043 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44044 bool arg2 = (bool) true ;
44045 void *argp1 = 0 ;
44046 int res1 = 0 ;
44047 bool val2 ;
44048 int ecode2 = 0 ;
44049 PyObject * obj0 = 0 ;
44050 PyObject * obj1 = 0 ;
44051 char * kwnames[] = {
44052 (char *) "self",(char *) "enable", NULL
44053 };
44054
44055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44057 if (!SWIG_IsOK(res1)) {
44058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44059 }
44060 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44061 if (obj1) {
44062 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44063 if (!SWIG_IsOK(ecode2)) {
44064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44065 }
44066 arg2 = static_cast< bool >(val2);
44067 }
44068 {
44069 PyThreadState* __tstate = wxPyBeginAllowThreads();
44070 (arg1)->Enable(arg2);
44071 wxPyEndAllowThreads(__tstate);
44072 if (PyErr_Occurred()) SWIG_fail;
44073 }
44074 resultobj = SWIG_Py_Void();
44075 return resultobj;
44076 fail:
44077 return NULL;
44078 }
44079
44080
44081 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44082 PyObject *resultobj = 0;
44083 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44084 bool result;
44085 void *argp1 = 0 ;
44086 int res1 = 0 ;
44087 PyObject *swig_obj[1] ;
44088
44089 if (!args) SWIG_fail;
44090 swig_obj[0] = args;
44091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44092 if (!SWIG_IsOK(res1)) {
44093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44094 }
44095 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44096 {
44097 PyThreadState* __tstate = wxPyBeginAllowThreads();
44098 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44099 wxPyEndAllowThreads(__tstate);
44100 if (PyErr_Occurred()) SWIG_fail;
44101 }
44102 {
44103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44104 }
44105 return resultobj;
44106 fail:
44107 return NULL;
44108 }
44109
44110
44111 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44112 PyObject *resultobj = 0;
44113 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44114 bool arg2 = (bool) true ;
44115 void *argp1 = 0 ;
44116 int res1 = 0 ;
44117 bool val2 ;
44118 int ecode2 = 0 ;
44119 PyObject * obj0 = 0 ;
44120 PyObject * obj1 = 0 ;
44121 char * kwnames[] = {
44122 (char *) "self",(char *) "check", NULL
44123 };
44124
44125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44127 if (!SWIG_IsOK(res1)) {
44128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44129 }
44130 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44131 if (obj1) {
44132 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44133 if (!SWIG_IsOK(ecode2)) {
44134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44135 }
44136 arg2 = static_cast< bool >(val2);
44137 }
44138 {
44139 PyThreadState* __tstate = wxPyBeginAllowThreads();
44140 (arg1)->Check(arg2);
44141 wxPyEndAllowThreads(__tstate);
44142 if (PyErr_Occurred()) SWIG_fail;
44143 }
44144 resultobj = SWIG_Py_Void();
44145 return resultobj;
44146 fail:
44147 return NULL;
44148 }
44149
44150
44151 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44152 PyObject *resultobj = 0;
44153 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44154 bool result;
44155 void *argp1 = 0 ;
44156 int res1 = 0 ;
44157 PyObject *swig_obj[1] ;
44158
44159 if (!args) SWIG_fail;
44160 swig_obj[0] = args;
44161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44162 if (!SWIG_IsOK(res1)) {
44163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44164 }
44165 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44166 {
44167 PyThreadState* __tstate = wxPyBeginAllowThreads();
44168 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44169 wxPyEndAllowThreads(__tstate);
44170 if (PyErr_Occurred()) SWIG_fail;
44171 }
44172 {
44173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44174 }
44175 return resultobj;
44176 fail:
44177 return NULL;
44178 }
44179
44180
44181 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44182 PyObject *resultobj = 0;
44183 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44184 void *argp1 = 0 ;
44185 int res1 = 0 ;
44186 PyObject *swig_obj[1] ;
44187
44188 if (!args) SWIG_fail;
44189 swig_obj[0] = args;
44190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44191 if (!SWIG_IsOK(res1)) {
44192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44193 }
44194 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44195 {
44196 PyThreadState* __tstate = wxPyBeginAllowThreads();
44197 (arg1)->Toggle();
44198 wxPyEndAllowThreads(__tstate);
44199 if (PyErr_Occurred()) SWIG_fail;
44200 }
44201 resultobj = SWIG_Py_Void();
44202 return resultobj;
44203 fail:
44204 return NULL;
44205 }
44206
44207
44208 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44209 PyObject *resultobj = 0;
44210 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44211 wxString *arg2 = 0 ;
44212 void *argp1 = 0 ;
44213 int res1 = 0 ;
44214 bool temp2 = false ;
44215 PyObject * obj0 = 0 ;
44216 PyObject * obj1 = 0 ;
44217 char * kwnames[] = {
44218 (char *) "self",(char *) "str", NULL
44219 };
44220
44221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44223 if (!SWIG_IsOK(res1)) {
44224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44225 }
44226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44227 {
44228 arg2 = wxString_in_helper(obj1);
44229 if (arg2 == NULL) SWIG_fail;
44230 temp2 = true;
44231 }
44232 {
44233 PyThreadState* __tstate = wxPyBeginAllowThreads();
44234 (arg1)->SetHelp((wxString const &)*arg2);
44235 wxPyEndAllowThreads(__tstate);
44236 if (PyErr_Occurred()) SWIG_fail;
44237 }
44238 resultobj = SWIG_Py_Void();
44239 {
44240 if (temp2)
44241 delete arg2;
44242 }
44243 return resultobj;
44244 fail:
44245 {
44246 if (temp2)
44247 delete arg2;
44248 }
44249 return NULL;
44250 }
44251
44252
44253 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44254 PyObject *resultobj = 0;
44255 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44256 wxString *result = 0 ;
44257 void *argp1 = 0 ;
44258 int res1 = 0 ;
44259 PyObject *swig_obj[1] ;
44260
44261 if (!args) SWIG_fail;
44262 swig_obj[0] = args;
44263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44264 if (!SWIG_IsOK(res1)) {
44265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44266 }
44267 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44268 {
44269 PyThreadState* __tstate = wxPyBeginAllowThreads();
44270 {
44271 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44272 result = (wxString *) &_result_ref;
44273 }
44274 wxPyEndAllowThreads(__tstate);
44275 if (PyErr_Occurred()) SWIG_fail;
44276 }
44277 {
44278 #if wxUSE_UNICODE
44279 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44280 #else
44281 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44282 #endif
44283 }
44284 return resultobj;
44285 fail:
44286 return NULL;
44287 }
44288
44289
44290 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44291 PyObject *resultobj = 0;
44292 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44293 wxAcceleratorEntry *result = 0 ;
44294 void *argp1 = 0 ;
44295 int res1 = 0 ;
44296 PyObject *swig_obj[1] ;
44297
44298 if (!args) SWIG_fail;
44299 swig_obj[0] = args;
44300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44301 if (!SWIG_IsOK(res1)) {
44302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44303 }
44304 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44305 {
44306 PyThreadState* __tstate = wxPyBeginAllowThreads();
44307 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44308 wxPyEndAllowThreads(__tstate);
44309 if (PyErr_Occurred()) SWIG_fail;
44310 }
44311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44312 return resultobj;
44313 fail:
44314 return NULL;
44315 }
44316
44317
44318 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44319 PyObject *resultobj = 0;
44320 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44321 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44322 void *argp1 = 0 ;
44323 int res1 = 0 ;
44324 void *argp2 = 0 ;
44325 int res2 = 0 ;
44326 PyObject * obj0 = 0 ;
44327 PyObject * obj1 = 0 ;
44328 char * kwnames[] = {
44329 (char *) "self",(char *) "accel", NULL
44330 };
44331
44332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44334 if (!SWIG_IsOK(res1)) {
44335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44336 }
44337 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44339 if (!SWIG_IsOK(res2)) {
44340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44341 }
44342 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44343 {
44344 PyThreadState* __tstate = wxPyBeginAllowThreads();
44345 (arg1)->SetAccel(arg2);
44346 wxPyEndAllowThreads(__tstate);
44347 if (PyErr_Occurred()) SWIG_fail;
44348 }
44349 resultobj = SWIG_Py_Void();
44350 return resultobj;
44351 fail:
44352 return NULL;
44353 }
44354
44355
44356 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44357 PyObject *resultobj = 0;
44358 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44359 wxBitmap *arg2 = 0 ;
44360 void *argp1 = 0 ;
44361 int res1 = 0 ;
44362 void *argp2 = 0 ;
44363 int res2 = 0 ;
44364 PyObject * obj0 = 0 ;
44365 PyObject * obj1 = 0 ;
44366 char * kwnames[] = {
44367 (char *) "self",(char *) "bitmap", NULL
44368 };
44369
44370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44372 if (!SWIG_IsOK(res1)) {
44373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44374 }
44375 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44377 if (!SWIG_IsOK(res2)) {
44378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44379 }
44380 if (!argp2) {
44381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44382 }
44383 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44384 {
44385 PyThreadState* __tstate = wxPyBeginAllowThreads();
44386 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44387 wxPyEndAllowThreads(__tstate);
44388 if (PyErr_Occurred()) SWIG_fail;
44389 }
44390 resultobj = SWIG_Py_Void();
44391 return resultobj;
44392 fail:
44393 return NULL;
44394 }
44395
44396
44397 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44398 PyObject *resultobj = 0;
44399 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44400 wxBitmap *result = 0 ;
44401 void *argp1 = 0 ;
44402 int res1 = 0 ;
44403 PyObject *swig_obj[1] ;
44404
44405 if (!args) SWIG_fail;
44406 swig_obj[0] = args;
44407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44408 if (!SWIG_IsOK(res1)) {
44409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44410 }
44411 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44412 {
44413 PyThreadState* __tstate = wxPyBeginAllowThreads();
44414 {
44415 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44416 result = (wxBitmap *) &_result_ref;
44417 }
44418 wxPyEndAllowThreads(__tstate);
44419 if (PyErr_Occurred()) SWIG_fail;
44420 }
44421 {
44422 wxBitmap* resultptr = new wxBitmap(*result);
44423 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44424 }
44425 return resultobj;
44426 fail:
44427 return NULL;
44428 }
44429
44430
44431 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44432 PyObject *resultobj = 0;
44433 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44434 wxFont *arg2 = 0 ;
44435 void *argp1 = 0 ;
44436 int res1 = 0 ;
44437 void *argp2 = 0 ;
44438 int res2 = 0 ;
44439 PyObject * obj0 = 0 ;
44440 PyObject * obj1 = 0 ;
44441 char * kwnames[] = {
44442 (char *) "self",(char *) "font", NULL
44443 };
44444
44445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44447 if (!SWIG_IsOK(res1)) {
44448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44449 }
44450 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44451 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44452 if (!SWIG_IsOK(res2)) {
44453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44454 }
44455 if (!argp2) {
44456 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44457 }
44458 arg2 = reinterpret_cast< wxFont * >(argp2);
44459 {
44460 PyThreadState* __tstate = wxPyBeginAllowThreads();
44461 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44462 wxPyEndAllowThreads(__tstate);
44463 if (PyErr_Occurred()) SWIG_fail;
44464 }
44465 resultobj = SWIG_Py_Void();
44466 return resultobj;
44467 fail:
44468 return NULL;
44469 }
44470
44471
44472 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44473 PyObject *resultobj = 0;
44474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44475 wxFont result;
44476 void *argp1 = 0 ;
44477 int res1 = 0 ;
44478 PyObject *swig_obj[1] ;
44479
44480 if (!args) SWIG_fail;
44481 swig_obj[0] = args;
44482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44483 if (!SWIG_IsOK(res1)) {
44484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44485 }
44486 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44487 {
44488 PyThreadState* __tstate = wxPyBeginAllowThreads();
44489 result = wxMenuItem_GetFont(arg1);
44490 wxPyEndAllowThreads(__tstate);
44491 if (PyErr_Occurred()) SWIG_fail;
44492 }
44493 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44494 return resultobj;
44495 fail:
44496 return NULL;
44497 }
44498
44499
44500 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44501 PyObject *resultobj = 0;
44502 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44503 wxColour *arg2 = 0 ;
44504 void *argp1 = 0 ;
44505 int res1 = 0 ;
44506 wxColour temp2 ;
44507 PyObject * obj0 = 0 ;
44508 PyObject * obj1 = 0 ;
44509 char * kwnames[] = {
44510 (char *) "self",(char *) "colText", NULL
44511 };
44512
44513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44515 if (!SWIG_IsOK(res1)) {
44516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44517 }
44518 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44519 {
44520 arg2 = &temp2;
44521 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44522 }
44523 {
44524 PyThreadState* __tstate = wxPyBeginAllowThreads();
44525 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44526 wxPyEndAllowThreads(__tstate);
44527 if (PyErr_Occurred()) SWIG_fail;
44528 }
44529 resultobj = SWIG_Py_Void();
44530 return resultobj;
44531 fail:
44532 return NULL;
44533 }
44534
44535
44536 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44537 PyObject *resultobj = 0;
44538 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44539 wxColour result;
44540 void *argp1 = 0 ;
44541 int res1 = 0 ;
44542 PyObject *swig_obj[1] ;
44543
44544 if (!args) SWIG_fail;
44545 swig_obj[0] = args;
44546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44547 if (!SWIG_IsOK(res1)) {
44548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44549 }
44550 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44551 {
44552 PyThreadState* __tstate = wxPyBeginAllowThreads();
44553 result = wxMenuItem_GetTextColour(arg1);
44554 wxPyEndAllowThreads(__tstate);
44555 if (PyErr_Occurred()) SWIG_fail;
44556 }
44557 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44558 return resultobj;
44559 fail:
44560 return NULL;
44561 }
44562
44563
44564 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44565 PyObject *resultobj = 0;
44566 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44567 wxColour *arg2 = 0 ;
44568 void *argp1 = 0 ;
44569 int res1 = 0 ;
44570 wxColour temp2 ;
44571 PyObject * obj0 = 0 ;
44572 PyObject * obj1 = 0 ;
44573 char * kwnames[] = {
44574 (char *) "self",(char *) "colBack", NULL
44575 };
44576
44577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44579 if (!SWIG_IsOK(res1)) {
44580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44581 }
44582 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44583 {
44584 arg2 = &temp2;
44585 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44586 }
44587 {
44588 PyThreadState* __tstate = wxPyBeginAllowThreads();
44589 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44590 wxPyEndAllowThreads(__tstate);
44591 if (PyErr_Occurred()) SWIG_fail;
44592 }
44593 resultobj = SWIG_Py_Void();
44594 return resultobj;
44595 fail:
44596 return NULL;
44597 }
44598
44599
44600 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44601 PyObject *resultobj = 0;
44602 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44603 wxColour result;
44604 void *argp1 = 0 ;
44605 int res1 = 0 ;
44606 PyObject *swig_obj[1] ;
44607
44608 if (!args) SWIG_fail;
44609 swig_obj[0] = args;
44610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44611 if (!SWIG_IsOK(res1)) {
44612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44613 }
44614 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44615 {
44616 PyThreadState* __tstate = wxPyBeginAllowThreads();
44617 result = wxMenuItem_GetBackgroundColour(arg1);
44618 wxPyEndAllowThreads(__tstate);
44619 if (PyErr_Occurred()) SWIG_fail;
44620 }
44621 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44622 return resultobj;
44623 fail:
44624 return NULL;
44625 }
44626
44627
44628 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44629 PyObject *resultobj = 0;
44630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44631 wxBitmap *arg2 = 0 ;
44632 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44633 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44634 void *argp1 = 0 ;
44635 int res1 = 0 ;
44636 void *argp2 = 0 ;
44637 int res2 = 0 ;
44638 void *argp3 = 0 ;
44639 int res3 = 0 ;
44640 PyObject * obj0 = 0 ;
44641 PyObject * obj1 = 0 ;
44642 PyObject * obj2 = 0 ;
44643 char * kwnames[] = {
44644 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44645 };
44646
44647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44649 if (!SWIG_IsOK(res1)) {
44650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44651 }
44652 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44653 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44654 if (!SWIG_IsOK(res2)) {
44655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44656 }
44657 if (!argp2) {
44658 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44659 }
44660 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44661 if (obj2) {
44662 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44663 if (!SWIG_IsOK(res3)) {
44664 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44665 }
44666 if (!argp3) {
44667 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44668 }
44669 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44670 }
44671 {
44672 PyThreadState* __tstate = wxPyBeginAllowThreads();
44673 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44674 wxPyEndAllowThreads(__tstate);
44675 if (PyErr_Occurred()) SWIG_fail;
44676 }
44677 resultobj = SWIG_Py_Void();
44678 return resultobj;
44679 fail:
44680 return NULL;
44681 }
44682
44683
44684 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44685 PyObject *resultobj = 0;
44686 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44687 wxBitmap *arg2 = 0 ;
44688 void *argp1 = 0 ;
44689 int res1 = 0 ;
44690 void *argp2 = 0 ;
44691 int res2 = 0 ;
44692 PyObject * obj0 = 0 ;
44693 PyObject * obj1 = 0 ;
44694 char * kwnames[] = {
44695 (char *) "self",(char *) "bmpDisabled", NULL
44696 };
44697
44698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44700 if (!SWIG_IsOK(res1)) {
44701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44702 }
44703 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44704 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44705 if (!SWIG_IsOK(res2)) {
44706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44707 }
44708 if (!argp2) {
44709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44710 }
44711 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44712 {
44713 PyThreadState* __tstate = wxPyBeginAllowThreads();
44714 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44715 wxPyEndAllowThreads(__tstate);
44716 if (PyErr_Occurred()) SWIG_fail;
44717 }
44718 resultobj = SWIG_Py_Void();
44719 return resultobj;
44720 fail:
44721 return NULL;
44722 }
44723
44724
44725 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44726 PyObject *resultobj = 0;
44727 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44728 wxBitmap *result = 0 ;
44729 void *argp1 = 0 ;
44730 int res1 = 0 ;
44731 PyObject *swig_obj[1] ;
44732
44733 if (!args) SWIG_fail;
44734 swig_obj[0] = args;
44735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44736 if (!SWIG_IsOK(res1)) {
44737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44738 }
44739 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44740 {
44741 PyThreadState* __tstate = wxPyBeginAllowThreads();
44742 {
44743 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44744 result = (wxBitmap *) &_result_ref;
44745 }
44746 wxPyEndAllowThreads(__tstate);
44747 if (PyErr_Occurred()) SWIG_fail;
44748 }
44749 {
44750 wxBitmap* resultptr = new wxBitmap(*result);
44751 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44752 }
44753 return resultobj;
44754 fail:
44755 return NULL;
44756 }
44757
44758
44759 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44760 PyObject *resultobj = 0;
44761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44762 int arg2 ;
44763 void *argp1 = 0 ;
44764 int res1 = 0 ;
44765 int val2 ;
44766 int ecode2 = 0 ;
44767 PyObject * obj0 = 0 ;
44768 PyObject * obj1 = 0 ;
44769 char * kwnames[] = {
44770 (char *) "self",(char *) "nWidth", NULL
44771 };
44772
44773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44775 if (!SWIG_IsOK(res1)) {
44776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44777 }
44778 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44779 ecode2 = SWIG_AsVal_int(obj1, &val2);
44780 if (!SWIG_IsOK(ecode2)) {
44781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44782 }
44783 arg2 = static_cast< int >(val2);
44784 {
44785 PyThreadState* __tstate = wxPyBeginAllowThreads();
44786 wxMenuItem_SetMarginWidth(arg1,arg2);
44787 wxPyEndAllowThreads(__tstate);
44788 if (PyErr_Occurred()) SWIG_fail;
44789 }
44790 resultobj = SWIG_Py_Void();
44791 return resultobj;
44792 fail:
44793 return NULL;
44794 }
44795
44796
44797 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44798 PyObject *resultobj = 0;
44799 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44800 int result;
44801 void *argp1 = 0 ;
44802 int res1 = 0 ;
44803 PyObject *swig_obj[1] ;
44804
44805 if (!args) SWIG_fail;
44806 swig_obj[0] = args;
44807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44808 if (!SWIG_IsOK(res1)) {
44809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44810 }
44811 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44812 {
44813 PyThreadState* __tstate = wxPyBeginAllowThreads();
44814 result = (int)wxMenuItem_GetMarginWidth(arg1);
44815 wxPyEndAllowThreads(__tstate);
44816 if (PyErr_Occurred()) SWIG_fail;
44817 }
44818 resultobj = SWIG_From_int(static_cast< int >(result));
44819 return resultobj;
44820 fail:
44821 return NULL;
44822 }
44823
44824
44825 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44826 PyObject *resultobj = 0;
44827 int result;
44828
44829 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44830 {
44831 PyThreadState* __tstate = wxPyBeginAllowThreads();
44832 result = (int)wxMenuItem_GetDefaultMarginWidth();
44833 wxPyEndAllowThreads(__tstate);
44834 if (PyErr_Occurred()) SWIG_fail;
44835 }
44836 resultobj = SWIG_From_int(static_cast< int >(result));
44837 return resultobj;
44838 fail:
44839 return NULL;
44840 }
44841
44842
44843 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44844 PyObject *resultobj = 0;
44845 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44846 bool result;
44847 void *argp1 = 0 ;
44848 int res1 = 0 ;
44849 PyObject *swig_obj[1] ;
44850
44851 if (!args) SWIG_fail;
44852 swig_obj[0] = args;
44853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44854 if (!SWIG_IsOK(res1)) {
44855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44856 }
44857 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44858 {
44859 PyThreadState* __tstate = wxPyBeginAllowThreads();
44860 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44861 wxPyEndAllowThreads(__tstate);
44862 if (PyErr_Occurred()) SWIG_fail;
44863 }
44864 {
44865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44866 }
44867 return resultobj;
44868 fail:
44869 return NULL;
44870 }
44871
44872
44873 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44874 PyObject *resultobj = 0;
44875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44876 bool arg2 = (bool) true ;
44877 void *argp1 = 0 ;
44878 int res1 = 0 ;
44879 bool val2 ;
44880 int ecode2 = 0 ;
44881 PyObject * obj0 = 0 ;
44882 PyObject * obj1 = 0 ;
44883 char * kwnames[] = {
44884 (char *) "self",(char *) "ownerDrawn", NULL
44885 };
44886
44887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44889 if (!SWIG_IsOK(res1)) {
44890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44891 }
44892 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44893 if (obj1) {
44894 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44895 if (!SWIG_IsOK(ecode2)) {
44896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44897 }
44898 arg2 = static_cast< bool >(val2);
44899 }
44900 {
44901 PyThreadState* __tstate = wxPyBeginAllowThreads();
44902 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44903 wxPyEndAllowThreads(__tstate);
44904 if (PyErr_Occurred()) SWIG_fail;
44905 }
44906 resultobj = SWIG_Py_Void();
44907 return resultobj;
44908 fail:
44909 return NULL;
44910 }
44911
44912
44913 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44914 PyObject *resultobj = 0;
44915 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44916 void *argp1 = 0 ;
44917 int res1 = 0 ;
44918 PyObject *swig_obj[1] ;
44919
44920 if (!args) SWIG_fail;
44921 swig_obj[0] = args;
44922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44923 if (!SWIG_IsOK(res1)) {
44924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44925 }
44926 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44927 {
44928 PyThreadState* __tstate = wxPyBeginAllowThreads();
44929 wxMenuItem_ResetOwnerDrawn(arg1);
44930 wxPyEndAllowThreads(__tstate);
44931 if (PyErr_Occurred()) SWIG_fail;
44932 }
44933 resultobj = SWIG_Py_Void();
44934 return resultobj;
44935 fail:
44936 return NULL;
44937 }
44938
44939
44940 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44941 PyObject *obj;
44942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44943 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44944 return SWIG_Py_Void();
44945 }
44946
44947 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44948 return SWIG_Python_InitShadowInstance(args);
44949 }
44950
44951 SWIGINTERN int ControlNameStr_set(PyObject *) {
44952 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44953 return 1;
44954 }
44955
44956
44957 SWIGINTERN PyObject *ControlNameStr_get(void) {
44958 PyObject *pyobj = 0;
44959
44960 {
44961 #if wxUSE_UNICODE
44962 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44963 #else
44964 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44965 #endif
44966 }
44967 return pyobj;
44968 }
44969
44970
44971 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44972 PyObject *resultobj = 0;
44973 wxWindow *arg1 = (wxWindow *) 0 ;
44974 int arg2 = (int) -1 ;
44975 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44976 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44977 wxSize const &arg4_defvalue = wxDefaultSize ;
44978 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44979 long arg5 = (long) 0 ;
44980 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44981 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44982 wxString const &arg7_defvalue = wxPyControlNameStr ;
44983 wxString *arg7 = (wxString *) &arg7_defvalue ;
44984 wxControl *result = 0 ;
44985 void *argp1 = 0 ;
44986 int res1 = 0 ;
44987 int val2 ;
44988 int ecode2 = 0 ;
44989 wxPoint temp3 ;
44990 wxSize temp4 ;
44991 long val5 ;
44992 int ecode5 = 0 ;
44993 void *argp6 = 0 ;
44994 int res6 = 0 ;
44995 bool temp7 = false ;
44996 PyObject * obj0 = 0 ;
44997 PyObject * obj1 = 0 ;
44998 PyObject * obj2 = 0 ;
44999 PyObject * obj3 = 0 ;
45000 PyObject * obj4 = 0 ;
45001 PyObject * obj5 = 0 ;
45002 PyObject * obj6 = 0 ;
45003 char * kwnames[] = {
45004 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45005 };
45006
45007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45009 if (!SWIG_IsOK(res1)) {
45010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45011 }
45012 arg1 = reinterpret_cast< wxWindow * >(argp1);
45013 if (obj1) {
45014 ecode2 = SWIG_AsVal_int(obj1, &val2);
45015 if (!SWIG_IsOK(ecode2)) {
45016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45017 }
45018 arg2 = static_cast< int >(val2);
45019 }
45020 if (obj2) {
45021 {
45022 arg3 = &temp3;
45023 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45024 }
45025 }
45026 if (obj3) {
45027 {
45028 arg4 = &temp4;
45029 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45030 }
45031 }
45032 if (obj4) {
45033 ecode5 = SWIG_AsVal_long(obj4, &val5);
45034 if (!SWIG_IsOK(ecode5)) {
45035 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45036 }
45037 arg5 = static_cast< long >(val5);
45038 }
45039 if (obj5) {
45040 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45041 if (!SWIG_IsOK(res6)) {
45042 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45043 }
45044 if (!argp6) {
45045 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45046 }
45047 arg6 = reinterpret_cast< wxValidator * >(argp6);
45048 }
45049 if (obj6) {
45050 {
45051 arg7 = wxString_in_helper(obj6);
45052 if (arg7 == NULL) SWIG_fail;
45053 temp7 = true;
45054 }
45055 }
45056 {
45057 if (!wxPyCheckForApp()) SWIG_fail;
45058 PyThreadState* __tstate = wxPyBeginAllowThreads();
45059 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45060 wxPyEndAllowThreads(__tstate);
45061 if (PyErr_Occurred()) SWIG_fail;
45062 }
45063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45064 {
45065 if (temp7)
45066 delete arg7;
45067 }
45068 return resultobj;
45069 fail:
45070 {
45071 if (temp7)
45072 delete arg7;
45073 }
45074 return NULL;
45075 }
45076
45077
45078 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45079 PyObject *resultobj = 0;
45080 wxControl *result = 0 ;
45081
45082 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45083 {
45084 if (!wxPyCheckForApp()) SWIG_fail;
45085 PyThreadState* __tstate = wxPyBeginAllowThreads();
45086 result = (wxControl *)new wxControl();
45087 wxPyEndAllowThreads(__tstate);
45088 if (PyErr_Occurred()) SWIG_fail;
45089 }
45090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45091 return resultobj;
45092 fail:
45093 return NULL;
45094 }
45095
45096
45097 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45098 PyObject *resultobj = 0;
45099 wxControl *arg1 = (wxControl *) 0 ;
45100 wxWindow *arg2 = (wxWindow *) 0 ;
45101 int arg3 = (int) -1 ;
45102 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45103 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45104 wxSize const &arg5_defvalue = wxDefaultSize ;
45105 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45106 long arg6 = (long) 0 ;
45107 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45108 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45109 wxString const &arg8_defvalue = wxPyControlNameStr ;
45110 wxString *arg8 = (wxString *) &arg8_defvalue ;
45111 bool result;
45112 void *argp1 = 0 ;
45113 int res1 = 0 ;
45114 void *argp2 = 0 ;
45115 int res2 = 0 ;
45116 int val3 ;
45117 int ecode3 = 0 ;
45118 wxPoint temp4 ;
45119 wxSize temp5 ;
45120 long val6 ;
45121 int ecode6 = 0 ;
45122 void *argp7 = 0 ;
45123 int res7 = 0 ;
45124 bool temp8 = false ;
45125 PyObject * obj0 = 0 ;
45126 PyObject * obj1 = 0 ;
45127 PyObject * obj2 = 0 ;
45128 PyObject * obj3 = 0 ;
45129 PyObject * obj4 = 0 ;
45130 PyObject * obj5 = 0 ;
45131 PyObject * obj6 = 0 ;
45132 PyObject * obj7 = 0 ;
45133 char * kwnames[] = {
45134 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45135 };
45136
45137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45139 if (!SWIG_IsOK(res1)) {
45140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45141 }
45142 arg1 = reinterpret_cast< wxControl * >(argp1);
45143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45144 if (!SWIG_IsOK(res2)) {
45145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45146 }
45147 arg2 = reinterpret_cast< wxWindow * >(argp2);
45148 if (obj2) {
45149 ecode3 = SWIG_AsVal_int(obj2, &val3);
45150 if (!SWIG_IsOK(ecode3)) {
45151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45152 }
45153 arg3 = static_cast< int >(val3);
45154 }
45155 if (obj3) {
45156 {
45157 arg4 = &temp4;
45158 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45159 }
45160 }
45161 if (obj4) {
45162 {
45163 arg5 = &temp5;
45164 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45165 }
45166 }
45167 if (obj5) {
45168 ecode6 = SWIG_AsVal_long(obj5, &val6);
45169 if (!SWIG_IsOK(ecode6)) {
45170 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45171 }
45172 arg6 = static_cast< long >(val6);
45173 }
45174 if (obj6) {
45175 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45176 if (!SWIG_IsOK(res7)) {
45177 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45178 }
45179 if (!argp7) {
45180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45181 }
45182 arg7 = reinterpret_cast< wxValidator * >(argp7);
45183 }
45184 if (obj7) {
45185 {
45186 arg8 = wxString_in_helper(obj7);
45187 if (arg8 == NULL) SWIG_fail;
45188 temp8 = true;
45189 }
45190 }
45191 {
45192 PyThreadState* __tstate = wxPyBeginAllowThreads();
45193 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45194 wxPyEndAllowThreads(__tstate);
45195 if (PyErr_Occurred()) SWIG_fail;
45196 }
45197 {
45198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45199 }
45200 {
45201 if (temp8)
45202 delete arg8;
45203 }
45204 return resultobj;
45205 fail:
45206 {
45207 if (temp8)
45208 delete arg8;
45209 }
45210 return NULL;
45211 }
45212
45213
45214 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45215 PyObject *resultobj = 0;
45216 wxControl *arg1 = (wxControl *) 0 ;
45217 int result;
45218 void *argp1 = 0 ;
45219 int res1 = 0 ;
45220 PyObject *swig_obj[1] ;
45221
45222 if (!args) SWIG_fail;
45223 swig_obj[0] = args;
45224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45225 if (!SWIG_IsOK(res1)) {
45226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45227 }
45228 arg1 = reinterpret_cast< wxControl * >(argp1);
45229 {
45230 PyThreadState* __tstate = wxPyBeginAllowThreads();
45231 result = (int)((wxControl const *)arg1)->GetAlignment();
45232 wxPyEndAllowThreads(__tstate);
45233 if (PyErr_Occurred()) SWIG_fail;
45234 }
45235 resultobj = SWIG_From_int(static_cast< int >(result));
45236 return resultobj;
45237 fail:
45238 return NULL;
45239 }
45240
45241
45242 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45243 PyObject *resultobj = 0;
45244 wxControl *arg1 = (wxControl *) 0 ;
45245 wxString result;
45246 void *argp1 = 0 ;
45247 int res1 = 0 ;
45248 PyObject *swig_obj[1] ;
45249
45250 if (!args) SWIG_fail;
45251 swig_obj[0] = args;
45252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45253 if (!SWIG_IsOK(res1)) {
45254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45255 }
45256 arg1 = reinterpret_cast< wxControl * >(argp1);
45257 {
45258 PyThreadState* __tstate = wxPyBeginAllowThreads();
45259 result = ((wxControl const *)arg1)->GetLabelText();
45260 wxPyEndAllowThreads(__tstate);
45261 if (PyErr_Occurred()) SWIG_fail;
45262 }
45263 {
45264 #if wxUSE_UNICODE
45265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45266 #else
45267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45268 #endif
45269 }
45270 return resultobj;
45271 fail:
45272 return NULL;
45273 }
45274
45275
45276 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45277 PyObject *resultobj = 0;
45278 wxControl *arg1 = (wxControl *) 0 ;
45279 wxCommandEvent *arg2 = 0 ;
45280 void *argp1 = 0 ;
45281 int res1 = 0 ;
45282 void *argp2 = 0 ;
45283 int res2 = 0 ;
45284 PyObject * obj0 = 0 ;
45285 PyObject * obj1 = 0 ;
45286 char * kwnames[] = {
45287 (char *) "self",(char *) "event", NULL
45288 };
45289
45290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45292 if (!SWIG_IsOK(res1)) {
45293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45294 }
45295 arg1 = reinterpret_cast< wxControl * >(argp1);
45296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45297 if (!SWIG_IsOK(res2)) {
45298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45299 }
45300 if (!argp2) {
45301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45302 }
45303 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45304 {
45305 PyThreadState* __tstate = wxPyBeginAllowThreads();
45306 (arg1)->Command(*arg2);
45307 wxPyEndAllowThreads(__tstate);
45308 if (PyErr_Occurred()) SWIG_fail;
45309 }
45310 resultobj = SWIG_Py_Void();
45311 return resultobj;
45312 fail:
45313 return NULL;
45314 }
45315
45316
45317 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45318 PyObject *resultobj = 0;
45319 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45320 SwigValueWrapper<wxVisualAttributes > result;
45321 int val1 ;
45322 int ecode1 = 0 ;
45323 PyObject * obj0 = 0 ;
45324 char * kwnames[] = {
45325 (char *) "variant", NULL
45326 };
45327
45328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45329 if (obj0) {
45330 ecode1 = SWIG_AsVal_int(obj0, &val1);
45331 if (!SWIG_IsOK(ecode1)) {
45332 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45333 }
45334 arg1 = static_cast< wxWindowVariant >(val1);
45335 }
45336 {
45337 if (!wxPyCheckForApp()) SWIG_fail;
45338 PyThreadState* __tstate = wxPyBeginAllowThreads();
45339 result = wxControl::GetClassDefaultAttributes(arg1);
45340 wxPyEndAllowThreads(__tstate);
45341 if (PyErr_Occurred()) SWIG_fail;
45342 }
45343 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45344 return resultobj;
45345 fail:
45346 return NULL;
45347 }
45348
45349
45350 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45351 PyObject *obj;
45352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45353 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45354 return SWIG_Py_Void();
45355 }
45356
45357 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45358 return SWIG_Python_InitShadowInstance(args);
45359 }
45360
45361 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45362 PyObject *resultobj = 0;
45363 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45364 wxString *arg2 = 0 ;
45365 PyObject *arg3 = (PyObject *) NULL ;
45366 int result;
45367 void *argp1 = 0 ;
45368 int res1 = 0 ;
45369 bool temp2 = false ;
45370 PyObject * obj0 = 0 ;
45371 PyObject * obj1 = 0 ;
45372 PyObject * obj2 = 0 ;
45373 char * kwnames[] = {
45374 (char *) "self",(char *) "item",(char *) "clientData", NULL
45375 };
45376
45377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45379 if (!SWIG_IsOK(res1)) {
45380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45381 }
45382 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45383 {
45384 arg2 = wxString_in_helper(obj1);
45385 if (arg2 == NULL) SWIG_fail;
45386 temp2 = true;
45387 }
45388 if (obj2) {
45389 arg3 = obj2;
45390 }
45391 {
45392 PyThreadState* __tstate = wxPyBeginAllowThreads();
45393 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45394 wxPyEndAllowThreads(__tstate);
45395 if (PyErr_Occurred()) SWIG_fail;
45396 }
45397 resultobj = SWIG_From_int(static_cast< int >(result));
45398 {
45399 if (temp2)
45400 delete arg2;
45401 }
45402 return resultobj;
45403 fail:
45404 {
45405 if (temp2)
45406 delete arg2;
45407 }
45408 return NULL;
45409 }
45410
45411
45412 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45413 PyObject *resultobj = 0;
45414 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45415 wxArrayString *arg2 = 0 ;
45416 void *argp1 = 0 ;
45417 int res1 = 0 ;
45418 bool temp2 = false ;
45419 PyObject * obj0 = 0 ;
45420 PyObject * obj1 = 0 ;
45421 char * kwnames[] = {
45422 (char *) "self",(char *) "strings", NULL
45423 };
45424
45425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45427 if (!SWIG_IsOK(res1)) {
45428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45429 }
45430 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45431 {
45432 if (! PySequence_Check(obj1)) {
45433 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45434 SWIG_fail;
45435 }
45436 arg2 = new wxArrayString;
45437 temp2 = true;
45438 int i, len=PySequence_Length(obj1);
45439 for (i=0; i<len; i++) {
45440 PyObject* item = PySequence_GetItem(obj1, i);
45441 wxString* s = wxString_in_helper(item);
45442 if (PyErr_Occurred()) SWIG_fail;
45443 arg2->Add(*s);
45444 delete s;
45445 Py_DECREF(item);
45446 }
45447 }
45448 {
45449 PyThreadState* __tstate = wxPyBeginAllowThreads();
45450 (arg1)->Append((wxArrayString const &)*arg2);
45451 wxPyEndAllowThreads(__tstate);
45452 if (PyErr_Occurred()) SWIG_fail;
45453 }
45454 resultobj = SWIG_Py_Void();
45455 {
45456 if (temp2) delete arg2;
45457 }
45458 return resultobj;
45459 fail:
45460 {
45461 if (temp2) delete arg2;
45462 }
45463 return NULL;
45464 }
45465
45466
45467 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45468 PyObject *resultobj = 0;
45469 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45470 wxString *arg2 = 0 ;
45471 unsigned int arg3 ;
45472 PyObject *arg4 = (PyObject *) NULL ;
45473 int result;
45474 void *argp1 = 0 ;
45475 int res1 = 0 ;
45476 bool temp2 = false ;
45477 unsigned int val3 ;
45478 int ecode3 = 0 ;
45479 PyObject * obj0 = 0 ;
45480 PyObject * obj1 = 0 ;
45481 PyObject * obj2 = 0 ;
45482 PyObject * obj3 = 0 ;
45483 char * kwnames[] = {
45484 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45485 };
45486
45487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45489 if (!SWIG_IsOK(res1)) {
45490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45491 }
45492 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45493 {
45494 arg2 = wxString_in_helper(obj1);
45495 if (arg2 == NULL) SWIG_fail;
45496 temp2 = true;
45497 }
45498 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45499 if (!SWIG_IsOK(ecode3)) {
45500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45501 }
45502 arg3 = static_cast< unsigned int >(val3);
45503 if (obj3) {
45504 arg4 = obj3;
45505 }
45506 {
45507 PyThreadState* __tstate = wxPyBeginAllowThreads();
45508 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45509 wxPyEndAllowThreads(__tstate);
45510 if (PyErr_Occurred()) SWIG_fail;
45511 }
45512 resultobj = SWIG_From_int(static_cast< int >(result));
45513 {
45514 if (temp2)
45515 delete arg2;
45516 }
45517 return resultobj;
45518 fail:
45519 {
45520 if (temp2)
45521 delete arg2;
45522 }
45523 return NULL;
45524 }
45525
45526
45527 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45528 PyObject *resultobj = 0;
45529 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45530 void *argp1 = 0 ;
45531 int res1 = 0 ;
45532 PyObject *swig_obj[1] ;
45533
45534 if (!args) SWIG_fail;
45535 swig_obj[0] = args;
45536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45537 if (!SWIG_IsOK(res1)) {
45538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45539 }
45540 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45541 {
45542 PyThreadState* __tstate = wxPyBeginAllowThreads();
45543 (arg1)->Clear();
45544 wxPyEndAllowThreads(__tstate);
45545 if (PyErr_Occurred()) SWIG_fail;
45546 }
45547 resultobj = SWIG_Py_Void();
45548 return resultobj;
45549 fail:
45550 return NULL;
45551 }
45552
45553
45554 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45555 PyObject *resultobj = 0;
45556 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45557 unsigned int arg2 ;
45558 void *argp1 = 0 ;
45559 int res1 = 0 ;
45560 unsigned int val2 ;
45561 int ecode2 = 0 ;
45562 PyObject * obj0 = 0 ;
45563 PyObject * obj1 = 0 ;
45564 char * kwnames[] = {
45565 (char *) "self",(char *) "n", NULL
45566 };
45567
45568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45570 if (!SWIG_IsOK(res1)) {
45571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45572 }
45573 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45574 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45575 if (!SWIG_IsOK(ecode2)) {
45576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45577 }
45578 arg2 = static_cast< unsigned int >(val2);
45579 {
45580 PyThreadState* __tstate = wxPyBeginAllowThreads();
45581 (arg1)->Delete(arg2);
45582 wxPyEndAllowThreads(__tstate);
45583 if (PyErr_Occurred()) SWIG_fail;
45584 }
45585 resultobj = SWIG_Py_Void();
45586 return resultobj;
45587 fail:
45588 return NULL;
45589 }
45590
45591
45592 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45593 PyObject *resultobj = 0;
45594 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45595 unsigned int arg2 ;
45596 PyObject *result = 0 ;
45597 void *argp1 = 0 ;
45598 int res1 = 0 ;
45599 unsigned int val2 ;
45600 int ecode2 = 0 ;
45601 PyObject * obj0 = 0 ;
45602 PyObject * obj1 = 0 ;
45603 char * kwnames[] = {
45604 (char *) "self",(char *) "n", NULL
45605 };
45606
45607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45609 if (!SWIG_IsOK(res1)) {
45610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45611 }
45612 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45613 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45614 if (!SWIG_IsOK(ecode2)) {
45615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45616 }
45617 arg2 = static_cast< unsigned int >(val2);
45618 {
45619 PyThreadState* __tstate = wxPyBeginAllowThreads();
45620 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45621 wxPyEndAllowThreads(__tstate);
45622 if (PyErr_Occurred()) SWIG_fail;
45623 }
45624 resultobj = result;
45625 return resultobj;
45626 fail:
45627 return NULL;
45628 }
45629
45630
45631 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45632 PyObject *resultobj = 0;
45633 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45634 unsigned int arg2 ;
45635 PyObject *arg3 = (PyObject *) 0 ;
45636 void *argp1 = 0 ;
45637 int res1 = 0 ;
45638 unsigned int val2 ;
45639 int ecode2 = 0 ;
45640 PyObject * obj0 = 0 ;
45641 PyObject * obj1 = 0 ;
45642 PyObject * obj2 = 0 ;
45643 char * kwnames[] = {
45644 (char *) "self",(char *) "n",(char *) "clientData", NULL
45645 };
45646
45647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45649 if (!SWIG_IsOK(res1)) {
45650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45651 }
45652 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45653 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45654 if (!SWIG_IsOK(ecode2)) {
45655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45656 }
45657 arg2 = static_cast< unsigned int >(val2);
45658 arg3 = obj2;
45659 {
45660 PyThreadState* __tstate = wxPyBeginAllowThreads();
45661 wxItemContainer_SetClientData(arg1,arg2,arg3);
45662 wxPyEndAllowThreads(__tstate);
45663 if (PyErr_Occurred()) SWIG_fail;
45664 }
45665 resultobj = SWIG_Py_Void();
45666 return resultobj;
45667 fail:
45668 return NULL;
45669 }
45670
45671
45672 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45673 PyObject *resultobj = 0;
45674 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45675 unsigned int result;
45676 void *argp1 = 0 ;
45677 int res1 = 0 ;
45678 PyObject *swig_obj[1] ;
45679
45680 if (!args) SWIG_fail;
45681 swig_obj[0] = args;
45682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45683 if (!SWIG_IsOK(res1)) {
45684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45685 }
45686 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45687 {
45688 PyThreadState* __tstate = wxPyBeginAllowThreads();
45689 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45690 wxPyEndAllowThreads(__tstate);
45691 if (PyErr_Occurred()) SWIG_fail;
45692 }
45693 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45694 return resultobj;
45695 fail:
45696 return NULL;
45697 }
45698
45699
45700 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45701 PyObject *resultobj = 0;
45702 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45703 bool result;
45704 void *argp1 = 0 ;
45705 int res1 = 0 ;
45706 PyObject *swig_obj[1] ;
45707
45708 if (!args) SWIG_fail;
45709 swig_obj[0] = args;
45710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45711 if (!SWIG_IsOK(res1)) {
45712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45713 }
45714 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45715 {
45716 PyThreadState* __tstate = wxPyBeginAllowThreads();
45717 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45718 wxPyEndAllowThreads(__tstate);
45719 if (PyErr_Occurred()) SWIG_fail;
45720 }
45721 {
45722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45723 }
45724 return resultobj;
45725 fail:
45726 return NULL;
45727 }
45728
45729
45730 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45731 PyObject *resultobj = 0;
45732 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45733 unsigned int arg2 ;
45734 wxString result;
45735 void *argp1 = 0 ;
45736 int res1 = 0 ;
45737 unsigned int val2 ;
45738 int ecode2 = 0 ;
45739 PyObject * obj0 = 0 ;
45740 PyObject * obj1 = 0 ;
45741 char * kwnames[] = {
45742 (char *) "self",(char *) "n", NULL
45743 };
45744
45745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45747 if (!SWIG_IsOK(res1)) {
45748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45749 }
45750 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45751 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45752 if (!SWIG_IsOK(ecode2)) {
45753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45754 }
45755 arg2 = static_cast< unsigned int >(val2);
45756 {
45757 PyThreadState* __tstate = wxPyBeginAllowThreads();
45758 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45759 wxPyEndAllowThreads(__tstate);
45760 if (PyErr_Occurred()) SWIG_fail;
45761 }
45762 {
45763 #if wxUSE_UNICODE
45764 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45765 #else
45766 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45767 #endif
45768 }
45769 return resultobj;
45770 fail:
45771 return NULL;
45772 }
45773
45774
45775 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45776 PyObject *resultobj = 0;
45777 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45778 wxArrayString result;
45779 void *argp1 = 0 ;
45780 int res1 = 0 ;
45781 PyObject *swig_obj[1] ;
45782
45783 if (!args) SWIG_fail;
45784 swig_obj[0] = args;
45785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45786 if (!SWIG_IsOK(res1)) {
45787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45788 }
45789 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45790 {
45791 PyThreadState* __tstate = wxPyBeginAllowThreads();
45792 result = ((wxItemContainer const *)arg1)->GetStrings();
45793 wxPyEndAllowThreads(__tstate);
45794 if (PyErr_Occurred()) SWIG_fail;
45795 }
45796 {
45797 resultobj = wxArrayString2PyList_helper(result);
45798 }
45799 return resultobj;
45800 fail:
45801 return NULL;
45802 }
45803
45804
45805 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45806 PyObject *resultobj = 0;
45807 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45808 unsigned int arg2 ;
45809 wxString *arg3 = 0 ;
45810 void *argp1 = 0 ;
45811 int res1 = 0 ;
45812 unsigned int val2 ;
45813 int ecode2 = 0 ;
45814 bool temp3 = false ;
45815 PyObject * obj0 = 0 ;
45816 PyObject * obj1 = 0 ;
45817 PyObject * obj2 = 0 ;
45818 char * kwnames[] = {
45819 (char *) "self",(char *) "n",(char *) "s", NULL
45820 };
45821
45822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45824 if (!SWIG_IsOK(res1)) {
45825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45826 }
45827 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45828 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45829 if (!SWIG_IsOK(ecode2)) {
45830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45831 }
45832 arg2 = static_cast< unsigned int >(val2);
45833 {
45834 arg3 = wxString_in_helper(obj2);
45835 if (arg3 == NULL) SWIG_fail;
45836 temp3 = true;
45837 }
45838 {
45839 PyThreadState* __tstate = wxPyBeginAllowThreads();
45840 (arg1)->SetString(arg2,(wxString const &)*arg3);
45841 wxPyEndAllowThreads(__tstate);
45842 if (PyErr_Occurred()) SWIG_fail;
45843 }
45844 resultobj = SWIG_Py_Void();
45845 {
45846 if (temp3)
45847 delete arg3;
45848 }
45849 return resultobj;
45850 fail:
45851 {
45852 if (temp3)
45853 delete arg3;
45854 }
45855 return NULL;
45856 }
45857
45858
45859 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45860 PyObject *resultobj = 0;
45861 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45862 wxString *arg2 = 0 ;
45863 int result;
45864 void *argp1 = 0 ;
45865 int res1 = 0 ;
45866 bool temp2 = false ;
45867 PyObject * obj0 = 0 ;
45868 PyObject * obj1 = 0 ;
45869 char * kwnames[] = {
45870 (char *) "self",(char *) "s", NULL
45871 };
45872
45873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45875 if (!SWIG_IsOK(res1)) {
45876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45877 }
45878 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45879 {
45880 arg2 = wxString_in_helper(obj1);
45881 if (arg2 == NULL) SWIG_fail;
45882 temp2 = true;
45883 }
45884 {
45885 PyThreadState* __tstate = wxPyBeginAllowThreads();
45886 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45887 wxPyEndAllowThreads(__tstate);
45888 if (PyErr_Occurred()) SWIG_fail;
45889 }
45890 resultobj = SWIG_From_int(static_cast< int >(result));
45891 {
45892 if (temp2)
45893 delete arg2;
45894 }
45895 return resultobj;
45896 fail:
45897 {
45898 if (temp2)
45899 delete arg2;
45900 }
45901 return NULL;
45902 }
45903
45904
45905 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45906 PyObject *resultobj = 0;
45907 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45908 int arg2 ;
45909 void *argp1 = 0 ;
45910 int res1 = 0 ;
45911 int val2 ;
45912 int ecode2 = 0 ;
45913 PyObject * obj0 = 0 ;
45914 PyObject * obj1 = 0 ;
45915 char * kwnames[] = {
45916 (char *) "self",(char *) "n", NULL
45917 };
45918
45919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45921 if (!SWIG_IsOK(res1)) {
45922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45923 }
45924 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45925 ecode2 = SWIG_AsVal_int(obj1, &val2);
45926 if (!SWIG_IsOK(ecode2)) {
45927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45928 }
45929 arg2 = static_cast< int >(val2);
45930 {
45931 PyThreadState* __tstate = wxPyBeginAllowThreads();
45932 (arg1)->SetSelection(arg2);
45933 wxPyEndAllowThreads(__tstate);
45934 if (PyErr_Occurred()) SWIG_fail;
45935 }
45936 resultobj = SWIG_Py_Void();
45937 return resultobj;
45938 fail:
45939 return NULL;
45940 }
45941
45942
45943 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45944 PyObject *resultobj = 0;
45945 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45946 int result;
45947 void *argp1 = 0 ;
45948 int res1 = 0 ;
45949 PyObject *swig_obj[1] ;
45950
45951 if (!args) SWIG_fail;
45952 swig_obj[0] = args;
45953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45954 if (!SWIG_IsOK(res1)) {
45955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45956 }
45957 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45958 {
45959 PyThreadState* __tstate = wxPyBeginAllowThreads();
45960 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45961 wxPyEndAllowThreads(__tstate);
45962 if (PyErr_Occurred()) SWIG_fail;
45963 }
45964 resultobj = SWIG_From_int(static_cast< int >(result));
45965 return resultobj;
45966 fail:
45967 return NULL;
45968 }
45969
45970
45971 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45972 PyObject *resultobj = 0;
45973 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45974 wxString *arg2 = 0 ;
45975 bool result;
45976 void *argp1 = 0 ;
45977 int res1 = 0 ;
45978 bool temp2 = false ;
45979 PyObject * obj0 = 0 ;
45980 PyObject * obj1 = 0 ;
45981 char * kwnames[] = {
45982 (char *) "self",(char *) "s", NULL
45983 };
45984
45985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45987 if (!SWIG_IsOK(res1)) {
45988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45989 }
45990 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45991 {
45992 arg2 = wxString_in_helper(obj1);
45993 if (arg2 == NULL) SWIG_fail;
45994 temp2 = true;
45995 }
45996 {
45997 PyThreadState* __tstate = wxPyBeginAllowThreads();
45998 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45999 wxPyEndAllowThreads(__tstate);
46000 if (PyErr_Occurred()) SWIG_fail;
46001 }
46002 {
46003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46004 }
46005 {
46006 if (temp2)
46007 delete arg2;
46008 }
46009 return resultobj;
46010 fail:
46011 {
46012 if (temp2)
46013 delete arg2;
46014 }
46015 return NULL;
46016 }
46017
46018
46019 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46020 PyObject *resultobj = 0;
46021 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46022 wxString result;
46023 void *argp1 = 0 ;
46024 int res1 = 0 ;
46025 PyObject *swig_obj[1] ;
46026
46027 if (!args) SWIG_fail;
46028 swig_obj[0] = args;
46029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46030 if (!SWIG_IsOK(res1)) {
46031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46032 }
46033 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46034 {
46035 PyThreadState* __tstate = wxPyBeginAllowThreads();
46036 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46037 wxPyEndAllowThreads(__tstate);
46038 if (PyErr_Occurred()) SWIG_fail;
46039 }
46040 {
46041 #if wxUSE_UNICODE
46042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46043 #else
46044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46045 #endif
46046 }
46047 return resultobj;
46048 fail:
46049 return NULL;
46050 }
46051
46052
46053 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46054 PyObject *resultobj = 0;
46055 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46056 int arg2 ;
46057 void *argp1 = 0 ;
46058 int res1 = 0 ;
46059 int val2 ;
46060 int ecode2 = 0 ;
46061 PyObject * obj0 = 0 ;
46062 PyObject * obj1 = 0 ;
46063 char * kwnames[] = {
46064 (char *) "self",(char *) "n", NULL
46065 };
46066
46067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46069 if (!SWIG_IsOK(res1)) {
46070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46071 }
46072 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46073 ecode2 = SWIG_AsVal_int(obj1, &val2);
46074 if (!SWIG_IsOK(ecode2)) {
46075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46076 }
46077 arg2 = static_cast< int >(val2);
46078 {
46079 PyThreadState* __tstate = wxPyBeginAllowThreads();
46080 (arg1)->Select(arg2);
46081 wxPyEndAllowThreads(__tstate);
46082 if (PyErr_Occurred()) SWIG_fail;
46083 }
46084 resultobj = SWIG_Py_Void();
46085 return resultobj;
46086 fail:
46087 return NULL;
46088 }
46089
46090
46091 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46092 PyObject *obj;
46093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46094 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46095 return SWIG_Py_Void();
46096 }
46097
46098 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46099 PyObject *obj;
46100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46101 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46102 return SWIG_Py_Void();
46103 }
46104
46105 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46106 PyObject *resultobj = 0;
46107 wxSizerItem *result = 0 ;
46108
46109 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46110 {
46111 PyThreadState* __tstate = wxPyBeginAllowThreads();
46112 result = (wxSizerItem *)new wxSizerItem();
46113 wxPyEndAllowThreads(__tstate);
46114 if (PyErr_Occurred()) SWIG_fail;
46115 }
46116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46117 return resultobj;
46118 fail:
46119 return NULL;
46120 }
46121
46122
46123 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46124 PyObject *resultobj = 0;
46125 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46126 void *argp1 = 0 ;
46127 int res1 = 0 ;
46128 PyObject *swig_obj[1] ;
46129
46130 if (!args) SWIG_fail;
46131 swig_obj[0] = args;
46132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46133 if (!SWIG_IsOK(res1)) {
46134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46135 }
46136 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46137 {
46138 PyThreadState* __tstate = wxPyBeginAllowThreads();
46139 delete arg1;
46140
46141 wxPyEndAllowThreads(__tstate);
46142 if (PyErr_Occurred()) SWIG_fail;
46143 }
46144 resultobj = SWIG_Py_Void();
46145 return resultobj;
46146 fail:
46147 return NULL;
46148 }
46149
46150
46151 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46152 PyObject *resultobj = 0;
46153 wxWindow *arg1 = (wxWindow *) 0 ;
46154 int arg2 ;
46155 int arg3 ;
46156 int arg4 ;
46157 PyObject *arg5 = (PyObject *) NULL ;
46158 wxSizerItem *result = 0 ;
46159 void *argp1 = 0 ;
46160 int res1 = 0 ;
46161 int val2 ;
46162 int ecode2 = 0 ;
46163 int val3 ;
46164 int ecode3 = 0 ;
46165 int val4 ;
46166 int ecode4 = 0 ;
46167 PyObject * obj0 = 0 ;
46168 PyObject * obj1 = 0 ;
46169 PyObject * obj2 = 0 ;
46170 PyObject * obj3 = 0 ;
46171 PyObject * obj4 = 0 ;
46172 char * kwnames[] = {
46173 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46174 };
46175
46176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46178 if (!SWIG_IsOK(res1)) {
46179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46180 }
46181 arg1 = reinterpret_cast< wxWindow * >(argp1);
46182 ecode2 = SWIG_AsVal_int(obj1, &val2);
46183 if (!SWIG_IsOK(ecode2)) {
46184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46185 }
46186 arg2 = static_cast< int >(val2);
46187 ecode3 = SWIG_AsVal_int(obj2, &val3);
46188 if (!SWIG_IsOK(ecode3)) {
46189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46190 }
46191 arg3 = static_cast< int >(val3);
46192 ecode4 = SWIG_AsVal_int(obj3, &val4);
46193 if (!SWIG_IsOK(ecode4)) {
46194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46195 }
46196 arg4 = static_cast< int >(val4);
46197 if (obj4) {
46198 arg5 = obj4;
46199 }
46200 {
46201 PyThreadState* __tstate = wxPyBeginAllowThreads();
46202 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46203 wxPyEndAllowThreads(__tstate);
46204 if (PyErr_Occurred()) SWIG_fail;
46205 }
46206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46207 return resultobj;
46208 fail:
46209 return NULL;
46210 }
46211
46212
46213 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46214 PyObject *resultobj = 0;
46215 int arg1 ;
46216 int arg2 ;
46217 int arg3 ;
46218 int arg4 ;
46219 int arg5 ;
46220 PyObject *arg6 = (PyObject *) NULL ;
46221 wxSizerItem *result = 0 ;
46222 int val1 ;
46223 int ecode1 = 0 ;
46224 int val2 ;
46225 int ecode2 = 0 ;
46226 int val3 ;
46227 int ecode3 = 0 ;
46228 int val4 ;
46229 int ecode4 = 0 ;
46230 int val5 ;
46231 int ecode5 = 0 ;
46232 PyObject * obj0 = 0 ;
46233 PyObject * obj1 = 0 ;
46234 PyObject * obj2 = 0 ;
46235 PyObject * obj3 = 0 ;
46236 PyObject * obj4 = 0 ;
46237 PyObject * obj5 = 0 ;
46238 char * kwnames[] = {
46239 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46240 };
46241
46242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46243 ecode1 = SWIG_AsVal_int(obj0, &val1);
46244 if (!SWIG_IsOK(ecode1)) {
46245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46246 }
46247 arg1 = static_cast< int >(val1);
46248 ecode2 = SWIG_AsVal_int(obj1, &val2);
46249 if (!SWIG_IsOK(ecode2)) {
46250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46251 }
46252 arg2 = static_cast< int >(val2);
46253 ecode3 = SWIG_AsVal_int(obj2, &val3);
46254 if (!SWIG_IsOK(ecode3)) {
46255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46256 }
46257 arg3 = static_cast< int >(val3);
46258 ecode4 = SWIG_AsVal_int(obj3, &val4);
46259 if (!SWIG_IsOK(ecode4)) {
46260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46261 }
46262 arg4 = static_cast< int >(val4);
46263 ecode5 = SWIG_AsVal_int(obj4, &val5);
46264 if (!SWIG_IsOK(ecode5)) {
46265 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46266 }
46267 arg5 = static_cast< int >(val5);
46268 if (obj5) {
46269 arg6 = obj5;
46270 }
46271 {
46272 PyThreadState* __tstate = wxPyBeginAllowThreads();
46273 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46274 wxPyEndAllowThreads(__tstate);
46275 if (PyErr_Occurred()) SWIG_fail;
46276 }
46277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46278 return resultobj;
46279 fail:
46280 return NULL;
46281 }
46282
46283
46284 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46285 PyObject *resultobj = 0;
46286 wxSizer *arg1 = (wxSizer *) 0 ;
46287 int arg2 ;
46288 int arg3 ;
46289 int arg4 ;
46290 PyObject *arg5 = (PyObject *) NULL ;
46291 wxSizerItem *result = 0 ;
46292 int res1 = 0 ;
46293 int val2 ;
46294 int ecode2 = 0 ;
46295 int val3 ;
46296 int ecode3 = 0 ;
46297 int val4 ;
46298 int ecode4 = 0 ;
46299 PyObject * obj0 = 0 ;
46300 PyObject * obj1 = 0 ;
46301 PyObject * obj2 = 0 ;
46302 PyObject * obj3 = 0 ;
46303 PyObject * obj4 = 0 ;
46304 char * kwnames[] = {
46305 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46306 };
46307
46308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46309 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46310 if (!SWIG_IsOK(res1)) {
46311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46312 }
46313 ecode2 = SWIG_AsVal_int(obj1, &val2);
46314 if (!SWIG_IsOK(ecode2)) {
46315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46316 }
46317 arg2 = static_cast< int >(val2);
46318 ecode3 = SWIG_AsVal_int(obj2, &val3);
46319 if (!SWIG_IsOK(ecode3)) {
46320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46321 }
46322 arg3 = static_cast< int >(val3);
46323 ecode4 = SWIG_AsVal_int(obj3, &val4);
46324 if (!SWIG_IsOK(ecode4)) {
46325 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46326 }
46327 arg4 = static_cast< int >(val4);
46328 if (obj4) {
46329 arg5 = obj4;
46330 }
46331 {
46332 PyThreadState* __tstate = wxPyBeginAllowThreads();
46333 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46334 wxPyEndAllowThreads(__tstate);
46335 if (PyErr_Occurred()) SWIG_fail;
46336 }
46337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46338 return resultobj;
46339 fail:
46340 return NULL;
46341 }
46342
46343
46344 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46345 PyObject *resultobj = 0;
46346 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46347 void *argp1 = 0 ;
46348 int res1 = 0 ;
46349 PyObject *swig_obj[1] ;
46350
46351 if (!args) SWIG_fail;
46352 swig_obj[0] = args;
46353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46354 if (!SWIG_IsOK(res1)) {
46355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46356 }
46357 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46358 {
46359 PyThreadState* __tstate = wxPyBeginAllowThreads();
46360 (arg1)->DeleteWindows();
46361 wxPyEndAllowThreads(__tstate);
46362 if (PyErr_Occurred()) SWIG_fail;
46363 }
46364 resultobj = SWIG_Py_Void();
46365 return resultobj;
46366 fail:
46367 return NULL;
46368 }
46369
46370
46371 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46372 PyObject *resultobj = 0;
46373 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46374 void *argp1 = 0 ;
46375 int res1 = 0 ;
46376 PyObject *swig_obj[1] ;
46377
46378 if (!args) SWIG_fail;
46379 swig_obj[0] = args;
46380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46381 if (!SWIG_IsOK(res1)) {
46382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46383 }
46384 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46385 {
46386 PyThreadState* __tstate = wxPyBeginAllowThreads();
46387 (arg1)->DetachSizer();
46388 wxPyEndAllowThreads(__tstate);
46389 if (PyErr_Occurred()) SWIG_fail;
46390 }
46391 resultobj = SWIG_Py_Void();
46392 return resultobj;
46393 fail:
46394 return NULL;
46395 }
46396
46397
46398 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46399 PyObject *resultobj = 0;
46400 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46401 wxSize result;
46402 void *argp1 = 0 ;
46403 int res1 = 0 ;
46404 PyObject *swig_obj[1] ;
46405
46406 if (!args) SWIG_fail;
46407 swig_obj[0] = args;
46408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46409 if (!SWIG_IsOK(res1)) {
46410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46411 }
46412 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46413 {
46414 PyThreadState* __tstate = wxPyBeginAllowThreads();
46415 result = (arg1)->GetSize();
46416 wxPyEndAllowThreads(__tstate);
46417 if (PyErr_Occurred()) SWIG_fail;
46418 }
46419 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46420 return resultobj;
46421 fail:
46422 return NULL;
46423 }
46424
46425
46426 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46427 PyObject *resultobj = 0;
46428 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46429 wxSize result;
46430 void *argp1 = 0 ;
46431 int res1 = 0 ;
46432 PyObject *swig_obj[1] ;
46433
46434 if (!args) SWIG_fail;
46435 swig_obj[0] = args;
46436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46437 if (!SWIG_IsOK(res1)) {
46438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46439 }
46440 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46441 {
46442 PyThreadState* __tstate = wxPyBeginAllowThreads();
46443 result = (arg1)->CalcMin();
46444 wxPyEndAllowThreads(__tstate);
46445 if (PyErr_Occurred()) SWIG_fail;
46446 }
46447 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46448 return resultobj;
46449 fail:
46450 return NULL;
46451 }
46452
46453
46454 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46455 PyObject *resultobj = 0;
46456 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46457 wxPoint *arg2 = 0 ;
46458 wxSize *arg3 = 0 ;
46459 void *argp1 = 0 ;
46460 int res1 = 0 ;
46461 wxPoint temp2 ;
46462 wxSize temp3 ;
46463 PyObject * obj0 = 0 ;
46464 PyObject * obj1 = 0 ;
46465 PyObject * obj2 = 0 ;
46466 char * kwnames[] = {
46467 (char *) "self",(char *) "pos",(char *) "size", NULL
46468 };
46469
46470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46472 if (!SWIG_IsOK(res1)) {
46473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46474 }
46475 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46476 {
46477 arg2 = &temp2;
46478 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46479 }
46480 {
46481 arg3 = &temp3;
46482 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46483 }
46484 {
46485 PyThreadState* __tstate = wxPyBeginAllowThreads();
46486 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46487 wxPyEndAllowThreads(__tstate);
46488 if (PyErr_Occurred()) SWIG_fail;
46489 }
46490 resultobj = SWIG_Py_Void();
46491 return resultobj;
46492 fail:
46493 return NULL;
46494 }
46495
46496
46497 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46498 PyObject *resultobj = 0;
46499 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46500 wxSize result;
46501 void *argp1 = 0 ;
46502 int res1 = 0 ;
46503 PyObject *swig_obj[1] ;
46504
46505 if (!args) SWIG_fail;
46506 swig_obj[0] = args;
46507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46508 if (!SWIG_IsOK(res1)) {
46509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46510 }
46511 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46512 {
46513 PyThreadState* __tstate = wxPyBeginAllowThreads();
46514 result = (arg1)->GetMinSize();
46515 wxPyEndAllowThreads(__tstate);
46516 if (PyErr_Occurred()) SWIG_fail;
46517 }
46518 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46519 return resultobj;
46520 fail:
46521 return NULL;
46522 }
46523
46524
46525 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46526 PyObject *resultobj = 0;
46527 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46528 wxSize result;
46529 void *argp1 = 0 ;
46530 int res1 = 0 ;
46531 PyObject *swig_obj[1] ;
46532
46533 if (!args) SWIG_fail;
46534 swig_obj[0] = args;
46535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46536 if (!SWIG_IsOK(res1)) {
46537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46538 }
46539 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46540 {
46541 PyThreadState* __tstate = wxPyBeginAllowThreads();
46542 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46543 wxPyEndAllowThreads(__tstate);
46544 if (PyErr_Occurred()) SWIG_fail;
46545 }
46546 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46547 return resultobj;
46548 fail:
46549 return NULL;
46550 }
46551
46552
46553 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46554 PyObject *resultobj = 0;
46555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46556 int arg2 ;
46557 int arg3 ;
46558 void *argp1 = 0 ;
46559 int res1 = 0 ;
46560 int val2 ;
46561 int ecode2 = 0 ;
46562 int val3 ;
46563 int ecode3 = 0 ;
46564 PyObject * obj0 = 0 ;
46565 PyObject * obj1 = 0 ;
46566 PyObject * obj2 = 0 ;
46567 char * kwnames[] = {
46568 (char *) "self",(char *) "x",(char *) "y", NULL
46569 };
46570
46571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46573 if (!SWIG_IsOK(res1)) {
46574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46575 }
46576 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46577 ecode2 = SWIG_AsVal_int(obj1, &val2);
46578 if (!SWIG_IsOK(ecode2)) {
46579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46580 }
46581 arg2 = static_cast< int >(val2);
46582 ecode3 = SWIG_AsVal_int(obj2, &val3);
46583 if (!SWIG_IsOK(ecode3)) {
46584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46585 }
46586 arg3 = static_cast< int >(val3);
46587 {
46588 PyThreadState* __tstate = wxPyBeginAllowThreads();
46589 (arg1)->SetInitSize(arg2,arg3);
46590 wxPyEndAllowThreads(__tstate);
46591 if (PyErr_Occurred()) SWIG_fail;
46592 }
46593 resultobj = SWIG_Py_Void();
46594 return resultobj;
46595 fail:
46596 return NULL;
46597 }
46598
46599
46600 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46601 PyObject *resultobj = 0;
46602 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46603 int arg2 ;
46604 int arg3 ;
46605 void *argp1 = 0 ;
46606 int res1 = 0 ;
46607 int val2 ;
46608 int ecode2 = 0 ;
46609 int val3 ;
46610 int ecode3 = 0 ;
46611 PyObject * obj0 = 0 ;
46612 PyObject * obj1 = 0 ;
46613 PyObject * obj2 = 0 ;
46614 char * kwnames[] = {
46615 (char *) "self",(char *) "width",(char *) "height", NULL
46616 };
46617
46618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46620 if (!SWIG_IsOK(res1)) {
46621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46622 }
46623 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46624 ecode2 = SWIG_AsVal_int(obj1, &val2);
46625 if (!SWIG_IsOK(ecode2)) {
46626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46627 }
46628 arg2 = static_cast< int >(val2);
46629 ecode3 = SWIG_AsVal_int(obj2, &val3);
46630 if (!SWIG_IsOK(ecode3)) {
46631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46632 }
46633 arg3 = static_cast< int >(val3);
46634 {
46635 PyThreadState* __tstate = wxPyBeginAllowThreads();
46636 (arg1)->SetRatio(arg2,arg3);
46637 wxPyEndAllowThreads(__tstate);
46638 if (PyErr_Occurred()) SWIG_fail;
46639 }
46640 resultobj = SWIG_Py_Void();
46641 return resultobj;
46642 fail:
46643 return NULL;
46644 }
46645
46646
46647 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46648 PyObject *resultobj = 0;
46649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46650 wxSize *arg2 = 0 ;
46651 void *argp1 = 0 ;
46652 int res1 = 0 ;
46653 wxSize temp2 ;
46654 PyObject * obj0 = 0 ;
46655 PyObject * obj1 = 0 ;
46656 char * kwnames[] = {
46657 (char *) "self",(char *) "size", NULL
46658 };
46659
46660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46662 if (!SWIG_IsOK(res1)) {
46663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46664 }
46665 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46666 {
46667 arg2 = &temp2;
46668 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46669 }
46670 {
46671 PyThreadState* __tstate = wxPyBeginAllowThreads();
46672 (arg1)->SetRatio((wxSize const &)*arg2);
46673 wxPyEndAllowThreads(__tstate);
46674 if (PyErr_Occurred()) SWIG_fail;
46675 }
46676 resultobj = SWIG_Py_Void();
46677 return resultobj;
46678 fail:
46679 return NULL;
46680 }
46681
46682
46683 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46684 PyObject *resultobj = 0;
46685 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46686 float arg2 ;
46687 void *argp1 = 0 ;
46688 int res1 = 0 ;
46689 float val2 ;
46690 int ecode2 = 0 ;
46691 PyObject * obj0 = 0 ;
46692 PyObject * obj1 = 0 ;
46693 char * kwnames[] = {
46694 (char *) "self",(char *) "ratio", NULL
46695 };
46696
46697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46699 if (!SWIG_IsOK(res1)) {
46700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46701 }
46702 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46703 ecode2 = SWIG_AsVal_float(obj1, &val2);
46704 if (!SWIG_IsOK(ecode2)) {
46705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46706 }
46707 arg2 = static_cast< float >(val2);
46708 {
46709 PyThreadState* __tstate = wxPyBeginAllowThreads();
46710 (arg1)->SetRatio(arg2);
46711 wxPyEndAllowThreads(__tstate);
46712 if (PyErr_Occurred()) SWIG_fail;
46713 }
46714 resultobj = SWIG_Py_Void();
46715 return resultobj;
46716 fail:
46717 return NULL;
46718 }
46719
46720
46721 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46722 PyObject *resultobj = 0;
46723 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46724 float result;
46725 void *argp1 = 0 ;
46726 int res1 = 0 ;
46727 PyObject *swig_obj[1] ;
46728
46729 if (!args) SWIG_fail;
46730 swig_obj[0] = args;
46731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46732 if (!SWIG_IsOK(res1)) {
46733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46734 }
46735 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46736 {
46737 PyThreadState* __tstate = wxPyBeginAllowThreads();
46738 result = (float)(arg1)->GetRatio();
46739 wxPyEndAllowThreads(__tstate);
46740 if (PyErr_Occurred()) SWIG_fail;
46741 }
46742 resultobj = SWIG_From_float(static_cast< float >(result));
46743 return resultobj;
46744 fail:
46745 return NULL;
46746 }
46747
46748
46749 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46750 PyObject *resultobj = 0;
46751 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46752 wxRect result;
46753 void *argp1 = 0 ;
46754 int res1 = 0 ;
46755 PyObject *swig_obj[1] ;
46756
46757 if (!args) SWIG_fail;
46758 swig_obj[0] = args;
46759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46760 if (!SWIG_IsOK(res1)) {
46761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46762 }
46763 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46764 {
46765 PyThreadState* __tstate = wxPyBeginAllowThreads();
46766 result = (arg1)->GetRect();
46767 wxPyEndAllowThreads(__tstate);
46768 if (PyErr_Occurred()) SWIG_fail;
46769 }
46770 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46771 return resultobj;
46772 fail:
46773 return NULL;
46774 }
46775
46776
46777 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46778 PyObject *resultobj = 0;
46779 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46780 bool result;
46781 void *argp1 = 0 ;
46782 int res1 = 0 ;
46783 PyObject *swig_obj[1] ;
46784
46785 if (!args) SWIG_fail;
46786 swig_obj[0] = args;
46787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46788 if (!SWIG_IsOK(res1)) {
46789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46790 }
46791 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46792 {
46793 PyThreadState* __tstate = wxPyBeginAllowThreads();
46794 result = (bool)(arg1)->IsWindow();
46795 wxPyEndAllowThreads(__tstate);
46796 if (PyErr_Occurred()) SWIG_fail;
46797 }
46798 {
46799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46800 }
46801 return resultobj;
46802 fail:
46803 return NULL;
46804 }
46805
46806
46807 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46808 PyObject *resultobj = 0;
46809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46810 bool result;
46811 void *argp1 = 0 ;
46812 int res1 = 0 ;
46813 PyObject *swig_obj[1] ;
46814
46815 if (!args) SWIG_fail;
46816 swig_obj[0] = args;
46817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46818 if (!SWIG_IsOK(res1)) {
46819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46820 }
46821 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46822 {
46823 PyThreadState* __tstate = wxPyBeginAllowThreads();
46824 result = (bool)(arg1)->IsSizer();
46825 wxPyEndAllowThreads(__tstate);
46826 if (PyErr_Occurred()) SWIG_fail;
46827 }
46828 {
46829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46830 }
46831 return resultobj;
46832 fail:
46833 return NULL;
46834 }
46835
46836
46837 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46838 PyObject *resultobj = 0;
46839 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46840 bool result;
46841 void *argp1 = 0 ;
46842 int res1 = 0 ;
46843 PyObject *swig_obj[1] ;
46844
46845 if (!args) SWIG_fail;
46846 swig_obj[0] = args;
46847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46848 if (!SWIG_IsOK(res1)) {
46849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46850 }
46851 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46852 {
46853 PyThreadState* __tstate = wxPyBeginAllowThreads();
46854 result = (bool)(arg1)->IsSpacer();
46855 wxPyEndAllowThreads(__tstate);
46856 if (PyErr_Occurred()) SWIG_fail;
46857 }
46858 {
46859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46860 }
46861 return resultobj;
46862 fail:
46863 return NULL;
46864 }
46865
46866
46867 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46868 PyObject *resultobj = 0;
46869 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46870 int arg2 ;
46871 void *argp1 = 0 ;
46872 int res1 = 0 ;
46873 int val2 ;
46874 int ecode2 = 0 ;
46875 PyObject * obj0 = 0 ;
46876 PyObject * obj1 = 0 ;
46877 char * kwnames[] = {
46878 (char *) "self",(char *) "proportion", NULL
46879 };
46880
46881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46883 if (!SWIG_IsOK(res1)) {
46884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46885 }
46886 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46887 ecode2 = SWIG_AsVal_int(obj1, &val2);
46888 if (!SWIG_IsOK(ecode2)) {
46889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46890 }
46891 arg2 = static_cast< int >(val2);
46892 {
46893 PyThreadState* __tstate = wxPyBeginAllowThreads();
46894 (arg1)->SetProportion(arg2);
46895 wxPyEndAllowThreads(__tstate);
46896 if (PyErr_Occurred()) SWIG_fail;
46897 }
46898 resultobj = SWIG_Py_Void();
46899 return resultobj;
46900 fail:
46901 return NULL;
46902 }
46903
46904
46905 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46906 PyObject *resultobj = 0;
46907 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46908 int result;
46909 void *argp1 = 0 ;
46910 int res1 = 0 ;
46911 PyObject *swig_obj[1] ;
46912
46913 if (!args) SWIG_fail;
46914 swig_obj[0] = args;
46915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46916 if (!SWIG_IsOK(res1)) {
46917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46918 }
46919 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46920 {
46921 PyThreadState* __tstate = wxPyBeginAllowThreads();
46922 result = (int)(arg1)->GetProportion();
46923 wxPyEndAllowThreads(__tstate);
46924 if (PyErr_Occurred()) SWIG_fail;
46925 }
46926 resultobj = SWIG_From_int(static_cast< int >(result));
46927 return resultobj;
46928 fail:
46929 return NULL;
46930 }
46931
46932
46933 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46934 PyObject *resultobj = 0;
46935 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46936 int arg2 ;
46937 void *argp1 = 0 ;
46938 int res1 = 0 ;
46939 int val2 ;
46940 int ecode2 = 0 ;
46941 PyObject * obj0 = 0 ;
46942 PyObject * obj1 = 0 ;
46943 char * kwnames[] = {
46944 (char *) "self",(char *) "flag", NULL
46945 };
46946
46947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46949 if (!SWIG_IsOK(res1)) {
46950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46951 }
46952 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46953 ecode2 = SWIG_AsVal_int(obj1, &val2);
46954 if (!SWIG_IsOK(ecode2)) {
46955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46956 }
46957 arg2 = static_cast< int >(val2);
46958 {
46959 PyThreadState* __tstate = wxPyBeginAllowThreads();
46960 (arg1)->SetFlag(arg2);
46961 wxPyEndAllowThreads(__tstate);
46962 if (PyErr_Occurred()) SWIG_fail;
46963 }
46964 resultobj = SWIG_Py_Void();
46965 return resultobj;
46966 fail:
46967 return NULL;
46968 }
46969
46970
46971 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46972 PyObject *resultobj = 0;
46973 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46974 int result;
46975 void *argp1 = 0 ;
46976 int res1 = 0 ;
46977 PyObject *swig_obj[1] ;
46978
46979 if (!args) SWIG_fail;
46980 swig_obj[0] = args;
46981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46982 if (!SWIG_IsOK(res1)) {
46983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46984 }
46985 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46986 {
46987 PyThreadState* __tstate = wxPyBeginAllowThreads();
46988 result = (int)(arg1)->GetFlag();
46989 wxPyEndAllowThreads(__tstate);
46990 if (PyErr_Occurred()) SWIG_fail;
46991 }
46992 resultobj = SWIG_From_int(static_cast< int >(result));
46993 return resultobj;
46994 fail:
46995 return NULL;
46996 }
46997
46998
46999 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47000 PyObject *resultobj = 0;
47001 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47002 int arg2 ;
47003 void *argp1 = 0 ;
47004 int res1 = 0 ;
47005 int val2 ;
47006 int ecode2 = 0 ;
47007 PyObject * obj0 = 0 ;
47008 PyObject * obj1 = 0 ;
47009 char * kwnames[] = {
47010 (char *) "self",(char *) "border", NULL
47011 };
47012
47013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47015 if (!SWIG_IsOK(res1)) {
47016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47017 }
47018 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47019 ecode2 = SWIG_AsVal_int(obj1, &val2);
47020 if (!SWIG_IsOK(ecode2)) {
47021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47022 }
47023 arg2 = static_cast< int >(val2);
47024 {
47025 PyThreadState* __tstate = wxPyBeginAllowThreads();
47026 (arg1)->SetBorder(arg2);
47027 wxPyEndAllowThreads(__tstate);
47028 if (PyErr_Occurred()) SWIG_fail;
47029 }
47030 resultobj = SWIG_Py_Void();
47031 return resultobj;
47032 fail:
47033 return NULL;
47034 }
47035
47036
47037 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47038 PyObject *resultobj = 0;
47039 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47040 int result;
47041 void *argp1 = 0 ;
47042 int res1 = 0 ;
47043 PyObject *swig_obj[1] ;
47044
47045 if (!args) SWIG_fail;
47046 swig_obj[0] = args;
47047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47048 if (!SWIG_IsOK(res1)) {
47049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47050 }
47051 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47052 {
47053 PyThreadState* __tstate = wxPyBeginAllowThreads();
47054 result = (int)(arg1)->GetBorder();
47055 wxPyEndAllowThreads(__tstate);
47056 if (PyErr_Occurred()) SWIG_fail;
47057 }
47058 resultobj = SWIG_From_int(static_cast< int >(result));
47059 return resultobj;
47060 fail:
47061 return NULL;
47062 }
47063
47064
47065 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47066 PyObject *resultobj = 0;
47067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47068 wxWindow *result = 0 ;
47069 void *argp1 = 0 ;
47070 int res1 = 0 ;
47071 PyObject *swig_obj[1] ;
47072
47073 if (!args) SWIG_fail;
47074 swig_obj[0] = args;
47075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47076 if (!SWIG_IsOK(res1)) {
47077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47078 }
47079 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47080 {
47081 PyThreadState* __tstate = wxPyBeginAllowThreads();
47082 result = (wxWindow *)(arg1)->GetWindow();
47083 wxPyEndAllowThreads(__tstate);
47084 if (PyErr_Occurred()) SWIG_fail;
47085 }
47086 {
47087 resultobj = wxPyMake_wxObject(result, 0);
47088 }
47089 return resultobj;
47090 fail:
47091 return NULL;
47092 }
47093
47094
47095 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47096 PyObject *resultobj = 0;
47097 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47098 wxWindow *arg2 = (wxWindow *) 0 ;
47099 void *argp1 = 0 ;
47100 int res1 = 0 ;
47101 void *argp2 = 0 ;
47102 int res2 = 0 ;
47103 PyObject * obj0 = 0 ;
47104 PyObject * obj1 = 0 ;
47105 char * kwnames[] = {
47106 (char *) "self",(char *) "window", NULL
47107 };
47108
47109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47111 if (!SWIG_IsOK(res1)) {
47112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47113 }
47114 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47115 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47116 if (!SWIG_IsOK(res2)) {
47117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47118 }
47119 arg2 = reinterpret_cast< wxWindow * >(argp2);
47120 {
47121 PyThreadState* __tstate = wxPyBeginAllowThreads();
47122 (arg1)->SetWindow(arg2);
47123 wxPyEndAllowThreads(__tstate);
47124 if (PyErr_Occurred()) SWIG_fail;
47125 }
47126 resultobj = SWIG_Py_Void();
47127 return resultobj;
47128 fail:
47129 return NULL;
47130 }
47131
47132
47133 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47134 PyObject *resultobj = 0;
47135 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47136 wxSizer *result = 0 ;
47137 void *argp1 = 0 ;
47138 int res1 = 0 ;
47139 PyObject *swig_obj[1] ;
47140
47141 if (!args) SWIG_fail;
47142 swig_obj[0] = args;
47143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47144 if (!SWIG_IsOK(res1)) {
47145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47146 }
47147 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47148 {
47149 PyThreadState* __tstate = wxPyBeginAllowThreads();
47150 result = (wxSizer *)(arg1)->GetSizer();
47151 wxPyEndAllowThreads(__tstate);
47152 if (PyErr_Occurred()) SWIG_fail;
47153 }
47154 {
47155 resultobj = wxPyMake_wxObject(result, (bool)0);
47156 }
47157 return resultobj;
47158 fail:
47159 return NULL;
47160 }
47161
47162
47163 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47164 PyObject *resultobj = 0;
47165 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47166 wxSizer *arg2 = (wxSizer *) 0 ;
47167 void *argp1 = 0 ;
47168 int res1 = 0 ;
47169 int res2 = 0 ;
47170 PyObject * obj0 = 0 ;
47171 PyObject * obj1 = 0 ;
47172 char * kwnames[] = {
47173 (char *) "self",(char *) "sizer", NULL
47174 };
47175
47176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47178 if (!SWIG_IsOK(res1)) {
47179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47180 }
47181 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47182 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47183 if (!SWIG_IsOK(res2)) {
47184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47185 }
47186 {
47187 PyThreadState* __tstate = wxPyBeginAllowThreads();
47188 (arg1)->SetSizer(arg2);
47189 wxPyEndAllowThreads(__tstate);
47190 if (PyErr_Occurred()) SWIG_fail;
47191 }
47192 resultobj = SWIG_Py_Void();
47193 return resultobj;
47194 fail:
47195 return NULL;
47196 }
47197
47198
47199 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47200 PyObject *resultobj = 0;
47201 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47202 wxSize *result = 0 ;
47203 void *argp1 = 0 ;
47204 int res1 = 0 ;
47205 PyObject *swig_obj[1] ;
47206
47207 if (!args) SWIG_fail;
47208 swig_obj[0] = args;
47209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47210 if (!SWIG_IsOK(res1)) {
47211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47212 }
47213 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47214 {
47215 PyThreadState* __tstate = wxPyBeginAllowThreads();
47216 {
47217 wxSize const &_result_ref = (arg1)->GetSpacer();
47218 result = (wxSize *) &_result_ref;
47219 }
47220 wxPyEndAllowThreads(__tstate);
47221 if (PyErr_Occurred()) SWIG_fail;
47222 }
47223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
47224 return resultobj;
47225 fail:
47226 return NULL;
47227 }
47228
47229
47230 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47231 PyObject *resultobj = 0;
47232 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47233 wxSize *arg2 = 0 ;
47234 void *argp1 = 0 ;
47235 int res1 = 0 ;
47236 wxSize temp2 ;
47237 PyObject * obj0 = 0 ;
47238 PyObject * obj1 = 0 ;
47239 char * kwnames[] = {
47240 (char *) "self",(char *) "size", NULL
47241 };
47242
47243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47245 if (!SWIG_IsOK(res1)) {
47246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47247 }
47248 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47249 {
47250 arg2 = &temp2;
47251 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47252 }
47253 {
47254 PyThreadState* __tstate = wxPyBeginAllowThreads();
47255 (arg1)->SetSpacer((wxSize const &)*arg2);
47256 wxPyEndAllowThreads(__tstate);
47257 if (PyErr_Occurred()) SWIG_fail;
47258 }
47259 resultobj = SWIG_Py_Void();
47260 return resultobj;
47261 fail:
47262 return NULL;
47263 }
47264
47265
47266 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47267 PyObject *resultobj = 0;
47268 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47269 bool arg2 ;
47270 void *argp1 = 0 ;
47271 int res1 = 0 ;
47272 bool val2 ;
47273 int ecode2 = 0 ;
47274 PyObject * obj0 = 0 ;
47275 PyObject * obj1 = 0 ;
47276 char * kwnames[] = {
47277 (char *) "self",(char *) "show", NULL
47278 };
47279
47280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47282 if (!SWIG_IsOK(res1)) {
47283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47284 }
47285 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47286 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47287 if (!SWIG_IsOK(ecode2)) {
47288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47289 }
47290 arg2 = static_cast< bool >(val2);
47291 {
47292 PyThreadState* __tstate = wxPyBeginAllowThreads();
47293 (arg1)->Show(arg2);
47294 wxPyEndAllowThreads(__tstate);
47295 if (PyErr_Occurred()) SWIG_fail;
47296 }
47297 resultobj = SWIG_Py_Void();
47298 return resultobj;
47299 fail:
47300 return NULL;
47301 }
47302
47303
47304 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47305 PyObject *resultobj = 0;
47306 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47307 bool result;
47308 void *argp1 = 0 ;
47309 int res1 = 0 ;
47310 PyObject *swig_obj[1] ;
47311
47312 if (!args) SWIG_fail;
47313 swig_obj[0] = args;
47314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47315 if (!SWIG_IsOK(res1)) {
47316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47317 }
47318 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47319 {
47320 PyThreadState* __tstate = wxPyBeginAllowThreads();
47321 result = (bool)(arg1)->IsShown();
47322 wxPyEndAllowThreads(__tstate);
47323 if (PyErr_Occurred()) SWIG_fail;
47324 }
47325 {
47326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47327 }
47328 return resultobj;
47329 fail:
47330 return NULL;
47331 }
47332
47333
47334 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47335 PyObject *resultobj = 0;
47336 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47337 wxPoint result;
47338 void *argp1 = 0 ;
47339 int res1 = 0 ;
47340 PyObject *swig_obj[1] ;
47341
47342 if (!args) SWIG_fail;
47343 swig_obj[0] = args;
47344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47345 if (!SWIG_IsOK(res1)) {
47346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47347 }
47348 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47349 {
47350 PyThreadState* __tstate = wxPyBeginAllowThreads();
47351 result = (arg1)->GetPosition();
47352 wxPyEndAllowThreads(__tstate);
47353 if (PyErr_Occurred()) SWIG_fail;
47354 }
47355 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47356 return resultobj;
47357 fail:
47358 return NULL;
47359 }
47360
47361
47362 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47363 PyObject *resultobj = 0;
47364 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47365 PyObject *result = 0 ;
47366 void *argp1 = 0 ;
47367 int res1 = 0 ;
47368 PyObject *swig_obj[1] ;
47369
47370 if (!args) SWIG_fail;
47371 swig_obj[0] = args;
47372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47373 if (!SWIG_IsOK(res1)) {
47374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47375 }
47376 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47377 {
47378 PyThreadState* __tstate = wxPyBeginAllowThreads();
47379 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47380 wxPyEndAllowThreads(__tstate);
47381 if (PyErr_Occurred()) SWIG_fail;
47382 }
47383 resultobj = result;
47384 return resultobj;
47385 fail:
47386 return NULL;
47387 }
47388
47389
47390 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47391 PyObject *resultobj = 0;
47392 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47393 PyObject *arg2 = (PyObject *) 0 ;
47394 void *argp1 = 0 ;
47395 int res1 = 0 ;
47396 PyObject * obj0 = 0 ;
47397 PyObject * obj1 = 0 ;
47398 char * kwnames[] = {
47399 (char *) "self",(char *) "userData", NULL
47400 };
47401
47402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47404 if (!SWIG_IsOK(res1)) {
47405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47406 }
47407 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47408 arg2 = obj1;
47409 {
47410 PyThreadState* __tstate = wxPyBeginAllowThreads();
47411 wxSizerItem_SetUserData(arg1,arg2);
47412 wxPyEndAllowThreads(__tstate);
47413 if (PyErr_Occurred()) SWIG_fail;
47414 }
47415 resultobj = SWIG_Py_Void();
47416 return resultobj;
47417 fail:
47418 return NULL;
47419 }
47420
47421
47422 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47423 PyObject *obj;
47424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47425 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47426 return SWIG_Py_Void();
47427 }
47428
47429 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47430 return SWIG_Python_InitShadowInstance(args);
47431 }
47432
47433 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47434 PyObject *resultobj = 0;
47435 wxSizer *arg1 = (wxSizer *) 0 ;
47436 void *argp1 = 0 ;
47437 int res1 = 0 ;
47438 PyObject *swig_obj[1] ;
47439
47440 if (!args) SWIG_fail;
47441 swig_obj[0] = args;
47442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47443 if (!SWIG_IsOK(res1)) {
47444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47445 }
47446 arg1 = reinterpret_cast< wxSizer * >(argp1);
47447 {
47448 PyThreadState* __tstate = wxPyBeginAllowThreads();
47449 delete arg1;
47450
47451 wxPyEndAllowThreads(__tstate);
47452 if (PyErr_Occurred()) SWIG_fail;
47453 }
47454 resultobj = SWIG_Py_Void();
47455 return resultobj;
47456 fail:
47457 return NULL;
47458 }
47459
47460
47461 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47462 PyObject *resultobj = 0;
47463 wxSizer *arg1 = (wxSizer *) 0 ;
47464 PyObject *arg2 = (PyObject *) 0 ;
47465 void *argp1 = 0 ;
47466 int res1 = 0 ;
47467 PyObject * obj0 = 0 ;
47468 PyObject * obj1 = 0 ;
47469 char * kwnames[] = {
47470 (char *) "self",(char *) "_self", NULL
47471 };
47472
47473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47475 if (!SWIG_IsOK(res1)) {
47476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47477 }
47478 arg1 = reinterpret_cast< wxSizer * >(argp1);
47479 arg2 = obj1;
47480 {
47481 PyThreadState* __tstate = wxPyBeginAllowThreads();
47482 wxSizer__setOORInfo(arg1,arg2);
47483 wxPyEndAllowThreads(__tstate);
47484 if (PyErr_Occurred()) SWIG_fail;
47485 }
47486 resultobj = SWIG_Py_Void();
47487 return resultobj;
47488 fail:
47489 return NULL;
47490 }
47491
47492
47493 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47494 PyObject *resultobj = 0;
47495 wxSizer *arg1 = (wxSizer *) 0 ;
47496 PyObject *arg2 = (PyObject *) 0 ;
47497 int arg3 = (int) 0 ;
47498 int arg4 = (int) 0 ;
47499 int arg5 = (int) 0 ;
47500 PyObject *arg6 = (PyObject *) NULL ;
47501 wxSizerItem *result = 0 ;
47502 void *argp1 = 0 ;
47503 int res1 = 0 ;
47504 int val3 ;
47505 int ecode3 = 0 ;
47506 int val4 ;
47507 int ecode4 = 0 ;
47508 int val5 ;
47509 int ecode5 = 0 ;
47510 PyObject * obj0 = 0 ;
47511 PyObject * obj1 = 0 ;
47512 PyObject * obj2 = 0 ;
47513 PyObject * obj3 = 0 ;
47514 PyObject * obj4 = 0 ;
47515 PyObject * obj5 = 0 ;
47516 char * kwnames[] = {
47517 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47518 };
47519
47520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47522 if (!SWIG_IsOK(res1)) {
47523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47524 }
47525 arg1 = reinterpret_cast< wxSizer * >(argp1);
47526 arg2 = obj1;
47527 if (obj2) {
47528 ecode3 = SWIG_AsVal_int(obj2, &val3);
47529 if (!SWIG_IsOK(ecode3)) {
47530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47531 }
47532 arg3 = static_cast< int >(val3);
47533 }
47534 if (obj3) {
47535 ecode4 = SWIG_AsVal_int(obj3, &val4);
47536 if (!SWIG_IsOK(ecode4)) {
47537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47538 }
47539 arg4 = static_cast< int >(val4);
47540 }
47541 if (obj4) {
47542 ecode5 = SWIG_AsVal_int(obj4, &val5);
47543 if (!SWIG_IsOK(ecode5)) {
47544 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47545 }
47546 arg5 = static_cast< int >(val5);
47547 }
47548 if (obj5) {
47549 arg6 = obj5;
47550 }
47551 {
47552 PyThreadState* __tstate = wxPyBeginAllowThreads();
47553 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47554 wxPyEndAllowThreads(__tstate);
47555 if (PyErr_Occurred()) SWIG_fail;
47556 }
47557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47558 return resultobj;
47559 fail:
47560 return NULL;
47561 }
47562
47563
47564 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47565 PyObject *resultobj = 0;
47566 wxSizer *arg1 = (wxSizer *) 0 ;
47567 int arg2 ;
47568 PyObject *arg3 = (PyObject *) 0 ;
47569 int arg4 = (int) 0 ;
47570 int arg5 = (int) 0 ;
47571 int arg6 = (int) 0 ;
47572 PyObject *arg7 = (PyObject *) NULL ;
47573 wxSizerItem *result = 0 ;
47574 void *argp1 = 0 ;
47575 int res1 = 0 ;
47576 int val2 ;
47577 int ecode2 = 0 ;
47578 int val4 ;
47579 int ecode4 = 0 ;
47580 int val5 ;
47581 int ecode5 = 0 ;
47582 int val6 ;
47583 int ecode6 = 0 ;
47584 PyObject * obj0 = 0 ;
47585 PyObject * obj1 = 0 ;
47586 PyObject * obj2 = 0 ;
47587 PyObject * obj3 = 0 ;
47588 PyObject * obj4 = 0 ;
47589 PyObject * obj5 = 0 ;
47590 PyObject * obj6 = 0 ;
47591 char * kwnames[] = {
47592 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47593 };
47594
47595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47597 if (!SWIG_IsOK(res1)) {
47598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47599 }
47600 arg1 = reinterpret_cast< wxSizer * >(argp1);
47601 ecode2 = SWIG_AsVal_int(obj1, &val2);
47602 if (!SWIG_IsOK(ecode2)) {
47603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47604 }
47605 arg2 = static_cast< int >(val2);
47606 arg3 = obj2;
47607 if (obj3) {
47608 ecode4 = SWIG_AsVal_int(obj3, &val4);
47609 if (!SWIG_IsOK(ecode4)) {
47610 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47611 }
47612 arg4 = static_cast< int >(val4);
47613 }
47614 if (obj4) {
47615 ecode5 = SWIG_AsVal_int(obj4, &val5);
47616 if (!SWIG_IsOK(ecode5)) {
47617 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47618 }
47619 arg5 = static_cast< int >(val5);
47620 }
47621 if (obj5) {
47622 ecode6 = SWIG_AsVal_int(obj5, &val6);
47623 if (!SWIG_IsOK(ecode6)) {
47624 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47625 }
47626 arg6 = static_cast< int >(val6);
47627 }
47628 if (obj6) {
47629 arg7 = obj6;
47630 }
47631 {
47632 PyThreadState* __tstate = wxPyBeginAllowThreads();
47633 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47634 wxPyEndAllowThreads(__tstate);
47635 if (PyErr_Occurred()) SWIG_fail;
47636 }
47637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47638 return resultobj;
47639 fail:
47640 return NULL;
47641 }
47642
47643
47644 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47645 PyObject *resultobj = 0;
47646 wxSizer *arg1 = (wxSizer *) 0 ;
47647 PyObject *arg2 = (PyObject *) 0 ;
47648 int arg3 = (int) 0 ;
47649 int arg4 = (int) 0 ;
47650 int arg5 = (int) 0 ;
47651 PyObject *arg6 = (PyObject *) NULL ;
47652 wxSizerItem *result = 0 ;
47653 void *argp1 = 0 ;
47654 int res1 = 0 ;
47655 int val3 ;
47656 int ecode3 = 0 ;
47657 int val4 ;
47658 int ecode4 = 0 ;
47659 int val5 ;
47660 int ecode5 = 0 ;
47661 PyObject * obj0 = 0 ;
47662 PyObject * obj1 = 0 ;
47663 PyObject * obj2 = 0 ;
47664 PyObject * obj3 = 0 ;
47665 PyObject * obj4 = 0 ;
47666 PyObject * obj5 = 0 ;
47667 char * kwnames[] = {
47668 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47669 };
47670
47671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47673 if (!SWIG_IsOK(res1)) {
47674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47675 }
47676 arg1 = reinterpret_cast< wxSizer * >(argp1);
47677 arg2 = obj1;
47678 if (obj2) {
47679 ecode3 = SWIG_AsVal_int(obj2, &val3);
47680 if (!SWIG_IsOK(ecode3)) {
47681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47682 }
47683 arg3 = static_cast< int >(val3);
47684 }
47685 if (obj3) {
47686 ecode4 = SWIG_AsVal_int(obj3, &val4);
47687 if (!SWIG_IsOK(ecode4)) {
47688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47689 }
47690 arg4 = static_cast< int >(val4);
47691 }
47692 if (obj4) {
47693 ecode5 = SWIG_AsVal_int(obj4, &val5);
47694 if (!SWIG_IsOK(ecode5)) {
47695 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47696 }
47697 arg5 = static_cast< int >(val5);
47698 }
47699 if (obj5) {
47700 arg6 = obj5;
47701 }
47702 {
47703 PyThreadState* __tstate = wxPyBeginAllowThreads();
47704 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47705 wxPyEndAllowThreads(__tstate);
47706 if (PyErr_Occurred()) SWIG_fail;
47707 }
47708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47709 return resultobj;
47710 fail:
47711 return NULL;
47712 }
47713
47714
47715 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47716 PyObject *resultobj = 0;
47717 wxSizer *arg1 = (wxSizer *) 0 ;
47718 PyObject *arg2 = (PyObject *) 0 ;
47719 bool result;
47720 void *argp1 = 0 ;
47721 int res1 = 0 ;
47722 PyObject * obj0 = 0 ;
47723 PyObject * obj1 = 0 ;
47724 char * kwnames[] = {
47725 (char *) "self",(char *) "item", NULL
47726 };
47727
47728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47730 if (!SWIG_IsOK(res1)) {
47731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47732 }
47733 arg1 = reinterpret_cast< wxSizer * >(argp1);
47734 arg2 = obj1;
47735 {
47736 PyThreadState* __tstate = wxPyBeginAllowThreads();
47737 result = (bool)wxSizer_Remove(arg1,arg2);
47738 wxPyEndAllowThreads(__tstate);
47739 if (PyErr_Occurred()) SWIG_fail;
47740 }
47741 {
47742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47743 }
47744 return resultobj;
47745 fail:
47746 return NULL;
47747 }
47748
47749
47750 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47751 PyObject *resultobj = 0;
47752 wxSizer *arg1 = (wxSizer *) 0 ;
47753 PyObject *arg2 = (PyObject *) 0 ;
47754 bool result;
47755 void *argp1 = 0 ;
47756 int res1 = 0 ;
47757 PyObject * obj0 = 0 ;
47758 PyObject * obj1 = 0 ;
47759 char * kwnames[] = {
47760 (char *) "self",(char *) "item", NULL
47761 };
47762
47763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47765 if (!SWIG_IsOK(res1)) {
47766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47767 }
47768 arg1 = reinterpret_cast< wxSizer * >(argp1);
47769 arg2 = obj1;
47770 {
47771 PyThreadState* __tstate = wxPyBeginAllowThreads();
47772 result = (bool)wxSizer_Detach(arg1,arg2);
47773 wxPyEndAllowThreads(__tstate);
47774 if (PyErr_Occurred()) SWIG_fail;
47775 }
47776 {
47777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47778 }
47779 return resultobj;
47780 fail:
47781 return NULL;
47782 }
47783
47784
47785 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47786 PyObject *resultobj = 0;
47787 wxSizer *arg1 = (wxSizer *) 0 ;
47788 PyObject *arg2 = (PyObject *) 0 ;
47789 wxSizerItem *result = 0 ;
47790 void *argp1 = 0 ;
47791 int res1 = 0 ;
47792 PyObject * obj0 = 0 ;
47793 PyObject * obj1 = 0 ;
47794 char * kwnames[] = {
47795 (char *) "self",(char *) "item", NULL
47796 };
47797
47798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47800 if (!SWIG_IsOK(res1)) {
47801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47802 }
47803 arg1 = reinterpret_cast< wxSizer * >(argp1);
47804 arg2 = obj1;
47805 {
47806 PyThreadState* __tstate = wxPyBeginAllowThreads();
47807 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47808 wxPyEndAllowThreads(__tstate);
47809 if (PyErr_Occurred()) SWIG_fail;
47810 }
47811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47812 return resultobj;
47813 fail:
47814 return NULL;
47815 }
47816
47817
47818 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47819 PyObject *resultobj = 0;
47820 wxSizer *arg1 = (wxSizer *) 0 ;
47821 PyObject *arg2 = (PyObject *) 0 ;
47822 wxSize *arg3 = 0 ;
47823 void *argp1 = 0 ;
47824 int res1 = 0 ;
47825 wxSize temp3 ;
47826 PyObject * obj0 = 0 ;
47827 PyObject * obj1 = 0 ;
47828 PyObject * obj2 = 0 ;
47829 char * kwnames[] = {
47830 (char *) "self",(char *) "item",(char *) "size", NULL
47831 };
47832
47833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47835 if (!SWIG_IsOK(res1)) {
47836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47837 }
47838 arg1 = reinterpret_cast< wxSizer * >(argp1);
47839 arg2 = obj1;
47840 {
47841 arg3 = &temp3;
47842 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47843 }
47844 {
47845 PyThreadState* __tstate = wxPyBeginAllowThreads();
47846 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47847 wxPyEndAllowThreads(__tstate);
47848 if (PyErr_Occurred()) SWIG_fail;
47849 }
47850 resultobj = SWIG_Py_Void();
47851 return resultobj;
47852 fail:
47853 return NULL;
47854 }
47855
47856
47857 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47858 PyObject *resultobj = 0;
47859 wxSizer *arg1 = (wxSizer *) 0 ;
47860 wxWindow *arg2 = (wxWindow *) 0 ;
47861 wxWindow *arg3 = (wxWindow *) 0 ;
47862 bool arg4 = (bool) false ;
47863 bool result;
47864 void *argp1 = 0 ;
47865 int res1 = 0 ;
47866 void *argp2 = 0 ;
47867 int res2 = 0 ;
47868 void *argp3 = 0 ;
47869 int res3 = 0 ;
47870 bool val4 ;
47871 int ecode4 = 0 ;
47872 PyObject * obj0 = 0 ;
47873 PyObject * obj1 = 0 ;
47874 PyObject * obj2 = 0 ;
47875 PyObject * obj3 = 0 ;
47876 char * kwnames[] = {
47877 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47878 };
47879
47880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47882 if (!SWIG_IsOK(res1)) {
47883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47884 }
47885 arg1 = reinterpret_cast< wxSizer * >(argp1);
47886 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47887 if (!SWIG_IsOK(res2)) {
47888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47889 }
47890 arg2 = reinterpret_cast< wxWindow * >(argp2);
47891 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47892 if (!SWIG_IsOK(res3)) {
47893 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47894 }
47895 arg3 = reinterpret_cast< wxWindow * >(argp3);
47896 if (obj3) {
47897 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47898 if (!SWIG_IsOK(ecode4)) {
47899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47900 }
47901 arg4 = static_cast< bool >(val4);
47902 }
47903 {
47904 PyThreadState* __tstate = wxPyBeginAllowThreads();
47905 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47906 wxPyEndAllowThreads(__tstate);
47907 if (PyErr_Occurred()) SWIG_fail;
47908 }
47909 {
47910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47911 }
47912 return resultobj;
47913 fail:
47914 return NULL;
47915 }
47916
47917
47918 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47919 PyObject *resultobj = 0;
47920 wxSizer *arg1 = (wxSizer *) 0 ;
47921 wxSizer *arg2 = (wxSizer *) 0 ;
47922 wxSizer *arg3 = (wxSizer *) 0 ;
47923 bool arg4 = (bool) false ;
47924 bool result;
47925 void *argp1 = 0 ;
47926 int res1 = 0 ;
47927 void *argp2 = 0 ;
47928 int res2 = 0 ;
47929 void *argp3 = 0 ;
47930 int res3 = 0 ;
47931 bool val4 ;
47932 int ecode4 = 0 ;
47933 PyObject * obj0 = 0 ;
47934 PyObject * obj1 = 0 ;
47935 PyObject * obj2 = 0 ;
47936 PyObject * obj3 = 0 ;
47937 char * kwnames[] = {
47938 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47939 };
47940
47941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47943 if (!SWIG_IsOK(res1)) {
47944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47945 }
47946 arg1 = reinterpret_cast< wxSizer * >(argp1);
47947 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47948 if (!SWIG_IsOK(res2)) {
47949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47950 }
47951 arg2 = reinterpret_cast< wxSizer * >(argp2);
47952 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47953 if (!SWIG_IsOK(res3)) {
47954 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47955 }
47956 arg3 = reinterpret_cast< wxSizer * >(argp3);
47957 if (obj3) {
47958 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47959 if (!SWIG_IsOK(ecode4)) {
47960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47961 }
47962 arg4 = static_cast< bool >(val4);
47963 }
47964 {
47965 PyThreadState* __tstate = wxPyBeginAllowThreads();
47966 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47967 wxPyEndAllowThreads(__tstate);
47968 if (PyErr_Occurred()) SWIG_fail;
47969 }
47970 {
47971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47972 }
47973 return resultobj;
47974 fail:
47975 return NULL;
47976 }
47977
47978
47979 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47980 PyObject *resultobj = 0;
47981 wxSizer *arg1 = (wxSizer *) 0 ;
47982 size_t arg2 ;
47983 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47984 bool result;
47985 void *argp1 = 0 ;
47986 int res1 = 0 ;
47987 size_t val2 ;
47988 int ecode2 = 0 ;
47989 void *argp3 = 0 ;
47990 int res3 = 0 ;
47991 PyObject * obj0 = 0 ;
47992 PyObject * obj1 = 0 ;
47993 PyObject * obj2 = 0 ;
47994 char * kwnames[] = {
47995 (char *) "self",(char *) "index",(char *) "newitem", NULL
47996 };
47997
47998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48000 if (!SWIG_IsOK(res1)) {
48001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48002 }
48003 arg1 = reinterpret_cast< wxSizer * >(argp1);
48004 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48005 if (!SWIG_IsOK(ecode2)) {
48006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48007 }
48008 arg2 = static_cast< size_t >(val2);
48009 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48010 if (!SWIG_IsOK(res3)) {
48011 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48012 }
48013 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48014 {
48015 PyThreadState* __tstate = wxPyBeginAllowThreads();
48016 result = (bool)(arg1)->Replace(arg2,arg3);
48017 wxPyEndAllowThreads(__tstate);
48018 if (PyErr_Occurred()) SWIG_fail;
48019 }
48020 {
48021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48022 }
48023 return resultobj;
48024 fail:
48025 return NULL;
48026 }
48027
48028
48029 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48030 PyObject *resultobj = 0;
48031 wxSizer *arg1 = (wxSizer *) 0 ;
48032 wxWindow *arg2 = (wxWindow *) 0 ;
48033 void *argp1 = 0 ;
48034 int res1 = 0 ;
48035 void *argp2 = 0 ;
48036 int res2 = 0 ;
48037 PyObject * obj0 = 0 ;
48038 PyObject * obj1 = 0 ;
48039 char * kwnames[] = {
48040 (char *) "self",(char *) "window", NULL
48041 };
48042
48043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48045 if (!SWIG_IsOK(res1)) {
48046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48047 }
48048 arg1 = reinterpret_cast< wxSizer * >(argp1);
48049 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48050 if (!SWIG_IsOK(res2)) {
48051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48052 }
48053 arg2 = reinterpret_cast< wxWindow * >(argp2);
48054 {
48055 PyThreadState* __tstate = wxPyBeginAllowThreads();
48056 (arg1)->SetContainingWindow(arg2);
48057 wxPyEndAllowThreads(__tstate);
48058 if (PyErr_Occurred()) SWIG_fail;
48059 }
48060 resultobj = SWIG_Py_Void();
48061 return resultobj;
48062 fail:
48063 return NULL;
48064 }
48065
48066
48067 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48068 PyObject *resultobj = 0;
48069 wxSizer *arg1 = (wxSizer *) 0 ;
48070 wxWindow *result = 0 ;
48071 void *argp1 = 0 ;
48072 int res1 = 0 ;
48073 PyObject *swig_obj[1] ;
48074
48075 if (!args) SWIG_fail;
48076 swig_obj[0] = args;
48077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48078 if (!SWIG_IsOK(res1)) {
48079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48080 }
48081 arg1 = reinterpret_cast< wxSizer * >(argp1);
48082 {
48083 PyThreadState* __tstate = wxPyBeginAllowThreads();
48084 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48085 wxPyEndAllowThreads(__tstate);
48086 if (PyErr_Occurred()) SWIG_fail;
48087 }
48088 {
48089 resultobj = wxPyMake_wxObject(result, 0);
48090 }
48091 return resultobj;
48092 fail:
48093 return NULL;
48094 }
48095
48096
48097 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48098 PyObject *resultobj = 0;
48099 wxSizer *arg1 = (wxSizer *) 0 ;
48100 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48101 wxSizerItem *result = 0 ;
48102 void *argp1 = 0 ;
48103 int res1 = 0 ;
48104 int res2 = 0 ;
48105 PyObject * obj0 = 0 ;
48106 PyObject * obj1 = 0 ;
48107 char * kwnames[] = {
48108 (char *) "self",(char *) "item", NULL
48109 };
48110
48111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48113 if (!SWIG_IsOK(res1)) {
48114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48115 }
48116 arg1 = reinterpret_cast< wxSizer * >(argp1);
48117 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48118 if (!SWIG_IsOK(res2)) {
48119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48120 }
48121 {
48122 PyThreadState* __tstate = wxPyBeginAllowThreads();
48123 result = (wxSizerItem *)(arg1)->Add(arg2);
48124 wxPyEndAllowThreads(__tstate);
48125 if (PyErr_Occurred()) SWIG_fail;
48126 }
48127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48128 return resultobj;
48129 fail:
48130 return NULL;
48131 }
48132
48133
48134 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48135 PyObject *resultobj = 0;
48136 wxSizer *arg1 = (wxSizer *) 0 ;
48137 size_t arg2 ;
48138 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48139 wxSizerItem *result = 0 ;
48140 void *argp1 = 0 ;
48141 int res1 = 0 ;
48142 size_t val2 ;
48143 int ecode2 = 0 ;
48144 int res3 = 0 ;
48145 PyObject * obj0 = 0 ;
48146 PyObject * obj1 = 0 ;
48147 PyObject * obj2 = 0 ;
48148 char * kwnames[] = {
48149 (char *) "self",(char *) "index",(char *) "item", NULL
48150 };
48151
48152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48154 if (!SWIG_IsOK(res1)) {
48155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48156 }
48157 arg1 = reinterpret_cast< wxSizer * >(argp1);
48158 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48159 if (!SWIG_IsOK(ecode2)) {
48160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48161 }
48162 arg2 = static_cast< size_t >(val2);
48163 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48164 if (!SWIG_IsOK(res3)) {
48165 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48166 }
48167 {
48168 PyThreadState* __tstate = wxPyBeginAllowThreads();
48169 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48170 wxPyEndAllowThreads(__tstate);
48171 if (PyErr_Occurred()) SWIG_fail;
48172 }
48173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48174 return resultobj;
48175 fail:
48176 return NULL;
48177 }
48178
48179
48180 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48181 PyObject *resultobj = 0;
48182 wxSizer *arg1 = (wxSizer *) 0 ;
48183 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48184 wxSizerItem *result = 0 ;
48185 void *argp1 = 0 ;
48186 int res1 = 0 ;
48187 int res2 = 0 ;
48188 PyObject * obj0 = 0 ;
48189 PyObject * obj1 = 0 ;
48190 char * kwnames[] = {
48191 (char *) "self",(char *) "item", NULL
48192 };
48193
48194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48196 if (!SWIG_IsOK(res1)) {
48197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48198 }
48199 arg1 = reinterpret_cast< wxSizer * >(argp1);
48200 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48201 if (!SWIG_IsOK(res2)) {
48202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48203 }
48204 {
48205 PyThreadState* __tstate = wxPyBeginAllowThreads();
48206 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48207 wxPyEndAllowThreads(__tstate);
48208 if (PyErr_Occurred()) SWIG_fail;
48209 }
48210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48211 return resultobj;
48212 fail:
48213 return NULL;
48214 }
48215
48216
48217 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48218 PyObject *resultobj = 0;
48219 wxSizer *arg1 = (wxSizer *) 0 ;
48220 int arg2 ;
48221 int arg3 ;
48222 int arg4 ;
48223 int arg5 ;
48224 void *argp1 = 0 ;
48225 int res1 = 0 ;
48226 int val2 ;
48227 int ecode2 = 0 ;
48228 int val3 ;
48229 int ecode3 = 0 ;
48230 int val4 ;
48231 int ecode4 = 0 ;
48232 int val5 ;
48233 int ecode5 = 0 ;
48234 PyObject * obj0 = 0 ;
48235 PyObject * obj1 = 0 ;
48236 PyObject * obj2 = 0 ;
48237 PyObject * obj3 = 0 ;
48238 PyObject * obj4 = 0 ;
48239 char * kwnames[] = {
48240 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48241 };
48242
48243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48245 if (!SWIG_IsOK(res1)) {
48246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48247 }
48248 arg1 = reinterpret_cast< wxSizer * >(argp1);
48249 ecode2 = SWIG_AsVal_int(obj1, &val2);
48250 if (!SWIG_IsOK(ecode2)) {
48251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48252 }
48253 arg2 = static_cast< int >(val2);
48254 ecode3 = SWIG_AsVal_int(obj2, &val3);
48255 if (!SWIG_IsOK(ecode3)) {
48256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48257 }
48258 arg3 = static_cast< int >(val3);
48259 ecode4 = SWIG_AsVal_int(obj3, &val4);
48260 if (!SWIG_IsOK(ecode4)) {
48261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48262 }
48263 arg4 = static_cast< int >(val4);
48264 ecode5 = SWIG_AsVal_int(obj4, &val5);
48265 if (!SWIG_IsOK(ecode5)) {
48266 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48267 }
48268 arg5 = static_cast< int >(val5);
48269 {
48270 PyThreadState* __tstate = wxPyBeginAllowThreads();
48271 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48272 wxPyEndAllowThreads(__tstate);
48273 if (PyErr_Occurred()) SWIG_fail;
48274 }
48275 resultobj = SWIG_Py_Void();
48276 return resultobj;
48277 fail:
48278 return NULL;
48279 }
48280
48281
48282 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48283 PyObject *resultobj = 0;
48284 wxSizer *arg1 = (wxSizer *) 0 ;
48285 wxSize *arg2 = 0 ;
48286 void *argp1 = 0 ;
48287 int res1 = 0 ;
48288 wxSize temp2 ;
48289 PyObject * obj0 = 0 ;
48290 PyObject * obj1 = 0 ;
48291 char * kwnames[] = {
48292 (char *) "self",(char *) "size", NULL
48293 };
48294
48295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48297 if (!SWIG_IsOK(res1)) {
48298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48299 }
48300 arg1 = reinterpret_cast< wxSizer * >(argp1);
48301 {
48302 arg2 = &temp2;
48303 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48304 }
48305 {
48306 PyThreadState* __tstate = wxPyBeginAllowThreads();
48307 (arg1)->SetMinSize((wxSize const &)*arg2);
48308 wxPyEndAllowThreads(__tstate);
48309 if (PyErr_Occurred()) SWIG_fail;
48310 }
48311 resultobj = SWIG_Py_Void();
48312 return resultobj;
48313 fail:
48314 return NULL;
48315 }
48316
48317
48318 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48319 PyObject *resultobj = 0;
48320 wxSizer *arg1 = (wxSizer *) 0 ;
48321 wxSize result;
48322 void *argp1 = 0 ;
48323 int res1 = 0 ;
48324 PyObject *swig_obj[1] ;
48325
48326 if (!args) SWIG_fail;
48327 swig_obj[0] = args;
48328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48329 if (!SWIG_IsOK(res1)) {
48330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48331 }
48332 arg1 = reinterpret_cast< wxSizer * >(argp1);
48333 {
48334 PyThreadState* __tstate = wxPyBeginAllowThreads();
48335 result = (arg1)->GetSize();
48336 wxPyEndAllowThreads(__tstate);
48337 if (PyErr_Occurred()) SWIG_fail;
48338 }
48339 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48340 return resultobj;
48341 fail:
48342 return NULL;
48343 }
48344
48345
48346 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48347 PyObject *resultobj = 0;
48348 wxSizer *arg1 = (wxSizer *) 0 ;
48349 wxPoint result;
48350 void *argp1 = 0 ;
48351 int res1 = 0 ;
48352 PyObject *swig_obj[1] ;
48353
48354 if (!args) SWIG_fail;
48355 swig_obj[0] = args;
48356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48357 if (!SWIG_IsOK(res1)) {
48358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48359 }
48360 arg1 = reinterpret_cast< wxSizer * >(argp1);
48361 {
48362 PyThreadState* __tstate = wxPyBeginAllowThreads();
48363 result = (arg1)->GetPosition();
48364 wxPyEndAllowThreads(__tstate);
48365 if (PyErr_Occurred()) SWIG_fail;
48366 }
48367 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48368 return resultobj;
48369 fail:
48370 return NULL;
48371 }
48372
48373
48374 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48375 PyObject *resultobj = 0;
48376 wxSizer *arg1 = (wxSizer *) 0 ;
48377 wxSize result;
48378 void *argp1 = 0 ;
48379 int res1 = 0 ;
48380 PyObject *swig_obj[1] ;
48381
48382 if (!args) SWIG_fail;
48383 swig_obj[0] = args;
48384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48385 if (!SWIG_IsOK(res1)) {
48386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48387 }
48388 arg1 = reinterpret_cast< wxSizer * >(argp1);
48389 {
48390 PyThreadState* __tstate = wxPyBeginAllowThreads();
48391 result = (arg1)->GetMinSize();
48392 wxPyEndAllowThreads(__tstate);
48393 if (PyErr_Occurred()) SWIG_fail;
48394 }
48395 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48396 return resultobj;
48397 fail:
48398 return NULL;
48399 }
48400
48401
48402 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48403 PyObject *resultobj = 0;
48404 wxSizer *arg1 = (wxSizer *) 0 ;
48405 void *argp1 = 0 ;
48406 int res1 = 0 ;
48407 PyObject *swig_obj[1] ;
48408
48409 if (!args) SWIG_fail;
48410 swig_obj[0] = args;
48411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48412 if (!SWIG_IsOK(res1)) {
48413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48414 }
48415 arg1 = reinterpret_cast< wxSizer * >(argp1);
48416 {
48417 PyThreadState* __tstate = wxPyBeginAllowThreads();
48418 (arg1)->RecalcSizes();
48419 wxPyEndAllowThreads(__tstate);
48420 if (PyErr_Occurred()) SWIG_fail;
48421 }
48422 resultobj = SWIG_Py_Void();
48423 return resultobj;
48424 fail:
48425 return NULL;
48426 }
48427
48428
48429 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48430 PyObject *resultobj = 0;
48431 wxSizer *arg1 = (wxSizer *) 0 ;
48432 wxSize result;
48433 void *argp1 = 0 ;
48434 int res1 = 0 ;
48435 PyObject *swig_obj[1] ;
48436
48437 if (!args) SWIG_fail;
48438 swig_obj[0] = args;
48439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48440 if (!SWIG_IsOK(res1)) {
48441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48442 }
48443 arg1 = reinterpret_cast< wxSizer * >(argp1);
48444 {
48445 PyThreadState* __tstate = wxPyBeginAllowThreads();
48446 result = (arg1)->CalcMin();
48447 wxPyEndAllowThreads(__tstate);
48448 if (PyErr_Occurred()) SWIG_fail;
48449 }
48450 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48451 return resultobj;
48452 fail:
48453 return NULL;
48454 }
48455
48456
48457 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48458 PyObject *resultobj = 0;
48459 wxSizer *arg1 = (wxSizer *) 0 ;
48460 void *argp1 = 0 ;
48461 int res1 = 0 ;
48462 PyObject *swig_obj[1] ;
48463
48464 if (!args) SWIG_fail;
48465 swig_obj[0] = args;
48466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48467 if (!SWIG_IsOK(res1)) {
48468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48469 }
48470 arg1 = reinterpret_cast< wxSizer * >(argp1);
48471 {
48472 PyThreadState* __tstate = wxPyBeginAllowThreads();
48473 (arg1)->Layout();
48474 wxPyEndAllowThreads(__tstate);
48475 if (PyErr_Occurred()) SWIG_fail;
48476 }
48477 resultobj = SWIG_Py_Void();
48478 return resultobj;
48479 fail:
48480 return NULL;
48481 }
48482
48483
48484 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48485 PyObject *resultobj = 0;
48486 wxSizer *arg1 = (wxSizer *) 0 ;
48487 wxWindow *arg2 = (wxWindow *) 0 ;
48488 wxSize result;
48489 void *argp1 = 0 ;
48490 int res1 = 0 ;
48491 void *argp2 = 0 ;
48492 int res2 = 0 ;
48493 PyObject * obj0 = 0 ;
48494 PyObject * obj1 = 0 ;
48495 char * kwnames[] = {
48496 (char *) "self",(char *) "window", NULL
48497 };
48498
48499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48501 if (!SWIG_IsOK(res1)) {
48502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48503 }
48504 arg1 = reinterpret_cast< wxSizer * >(argp1);
48505 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48506 if (!SWIG_IsOK(res2)) {
48507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48508 }
48509 arg2 = reinterpret_cast< wxWindow * >(argp2);
48510 {
48511 PyThreadState* __tstate = wxPyBeginAllowThreads();
48512 result = (arg1)->Fit(arg2);
48513 wxPyEndAllowThreads(__tstate);
48514 if (PyErr_Occurred()) SWIG_fail;
48515 }
48516 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48517 return resultobj;
48518 fail:
48519 return NULL;
48520 }
48521
48522
48523 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48524 PyObject *resultobj = 0;
48525 wxSizer *arg1 = (wxSizer *) 0 ;
48526 wxWindow *arg2 = (wxWindow *) 0 ;
48527 void *argp1 = 0 ;
48528 int res1 = 0 ;
48529 void *argp2 = 0 ;
48530 int res2 = 0 ;
48531 PyObject * obj0 = 0 ;
48532 PyObject * obj1 = 0 ;
48533 char * kwnames[] = {
48534 (char *) "self",(char *) "window", NULL
48535 };
48536
48537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48539 if (!SWIG_IsOK(res1)) {
48540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48541 }
48542 arg1 = reinterpret_cast< wxSizer * >(argp1);
48543 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48544 if (!SWIG_IsOK(res2)) {
48545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48546 }
48547 arg2 = reinterpret_cast< wxWindow * >(argp2);
48548 {
48549 PyThreadState* __tstate = wxPyBeginAllowThreads();
48550 (arg1)->FitInside(arg2);
48551 wxPyEndAllowThreads(__tstate);
48552 if (PyErr_Occurred()) SWIG_fail;
48553 }
48554 resultobj = SWIG_Py_Void();
48555 return resultobj;
48556 fail:
48557 return NULL;
48558 }
48559
48560
48561 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48562 PyObject *resultobj = 0;
48563 wxSizer *arg1 = (wxSizer *) 0 ;
48564 wxWindow *arg2 = (wxWindow *) 0 ;
48565 void *argp1 = 0 ;
48566 int res1 = 0 ;
48567 void *argp2 = 0 ;
48568 int res2 = 0 ;
48569 PyObject * obj0 = 0 ;
48570 PyObject * obj1 = 0 ;
48571 char * kwnames[] = {
48572 (char *) "self",(char *) "window", NULL
48573 };
48574
48575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48577 if (!SWIG_IsOK(res1)) {
48578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48579 }
48580 arg1 = reinterpret_cast< wxSizer * >(argp1);
48581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48582 if (!SWIG_IsOK(res2)) {
48583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48584 }
48585 arg2 = reinterpret_cast< wxWindow * >(argp2);
48586 {
48587 PyThreadState* __tstate = wxPyBeginAllowThreads();
48588 (arg1)->SetSizeHints(arg2);
48589 wxPyEndAllowThreads(__tstate);
48590 if (PyErr_Occurred()) SWIG_fail;
48591 }
48592 resultobj = SWIG_Py_Void();
48593 return resultobj;
48594 fail:
48595 return NULL;
48596 }
48597
48598
48599 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48600 PyObject *resultobj = 0;
48601 wxSizer *arg1 = (wxSizer *) 0 ;
48602 wxWindow *arg2 = (wxWindow *) 0 ;
48603 void *argp1 = 0 ;
48604 int res1 = 0 ;
48605 void *argp2 = 0 ;
48606 int res2 = 0 ;
48607 PyObject * obj0 = 0 ;
48608 PyObject * obj1 = 0 ;
48609 char * kwnames[] = {
48610 (char *) "self",(char *) "window", NULL
48611 };
48612
48613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48615 if (!SWIG_IsOK(res1)) {
48616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48617 }
48618 arg1 = reinterpret_cast< wxSizer * >(argp1);
48619 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48620 if (!SWIG_IsOK(res2)) {
48621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48622 }
48623 arg2 = reinterpret_cast< wxWindow * >(argp2);
48624 {
48625 PyThreadState* __tstate = wxPyBeginAllowThreads();
48626 (arg1)->SetVirtualSizeHints(arg2);
48627 wxPyEndAllowThreads(__tstate);
48628 if (PyErr_Occurred()) SWIG_fail;
48629 }
48630 resultobj = SWIG_Py_Void();
48631 return resultobj;
48632 fail:
48633 return NULL;
48634 }
48635
48636
48637 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48638 PyObject *resultobj = 0;
48639 wxSizer *arg1 = (wxSizer *) 0 ;
48640 bool arg2 = (bool) false ;
48641 void *argp1 = 0 ;
48642 int res1 = 0 ;
48643 bool val2 ;
48644 int ecode2 = 0 ;
48645 PyObject * obj0 = 0 ;
48646 PyObject * obj1 = 0 ;
48647 char * kwnames[] = {
48648 (char *) "self",(char *) "deleteWindows", NULL
48649 };
48650
48651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48653 if (!SWIG_IsOK(res1)) {
48654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48655 }
48656 arg1 = reinterpret_cast< wxSizer * >(argp1);
48657 if (obj1) {
48658 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48659 if (!SWIG_IsOK(ecode2)) {
48660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48661 }
48662 arg2 = static_cast< bool >(val2);
48663 }
48664 {
48665 PyThreadState* __tstate = wxPyBeginAllowThreads();
48666 (arg1)->Clear(arg2);
48667 wxPyEndAllowThreads(__tstate);
48668 if (PyErr_Occurred()) SWIG_fail;
48669 }
48670 resultobj = SWIG_Py_Void();
48671 return resultobj;
48672 fail:
48673 return NULL;
48674 }
48675
48676
48677 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48678 PyObject *resultobj = 0;
48679 wxSizer *arg1 = (wxSizer *) 0 ;
48680 void *argp1 = 0 ;
48681 int res1 = 0 ;
48682 PyObject *swig_obj[1] ;
48683
48684 if (!args) SWIG_fail;
48685 swig_obj[0] = args;
48686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48687 if (!SWIG_IsOK(res1)) {
48688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48689 }
48690 arg1 = reinterpret_cast< wxSizer * >(argp1);
48691 {
48692 PyThreadState* __tstate = wxPyBeginAllowThreads();
48693 (arg1)->DeleteWindows();
48694 wxPyEndAllowThreads(__tstate);
48695 if (PyErr_Occurred()) SWIG_fail;
48696 }
48697 resultobj = SWIG_Py_Void();
48698 return resultobj;
48699 fail:
48700 return NULL;
48701 }
48702
48703
48704 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48705 PyObject *resultobj = 0;
48706 wxSizer *arg1 = (wxSizer *) 0 ;
48707 PyObject *result = 0 ;
48708 void *argp1 = 0 ;
48709 int res1 = 0 ;
48710 PyObject *swig_obj[1] ;
48711
48712 if (!args) SWIG_fail;
48713 swig_obj[0] = args;
48714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48715 if (!SWIG_IsOK(res1)) {
48716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48717 }
48718 arg1 = reinterpret_cast< wxSizer * >(argp1);
48719 {
48720 PyThreadState* __tstate = wxPyBeginAllowThreads();
48721 result = (PyObject *)wxSizer_GetChildren(arg1);
48722 wxPyEndAllowThreads(__tstate);
48723 if (PyErr_Occurred()) SWIG_fail;
48724 }
48725 resultobj = result;
48726 return resultobj;
48727 fail:
48728 return NULL;
48729 }
48730
48731
48732 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48733 PyObject *resultobj = 0;
48734 wxSizer *arg1 = (wxSizer *) 0 ;
48735 PyObject *arg2 = (PyObject *) 0 ;
48736 bool arg3 = (bool) true ;
48737 bool arg4 = (bool) false ;
48738 bool result;
48739 void *argp1 = 0 ;
48740 int res1 = 0 ;
48741 bool val3 ;
48742 int ecode3 = 0 ;
48743 bool val4 ;
48744 int ecode4 = 0 ;
48745 PyObject * obj0 = 0 ;
48746 PyObject * obj1 = 0 ;
48747 PyObject * obj2 = 0 ;
48748 PyObject * obj3 = 0 ;
48749 char * kwnames[] = {
48750 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48751 };
48752
48753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48755 if (!SWIG_IsOK(res1)) {
48756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48757 }
48758 arg1 = reinterpret_cast< wxSizer * >(argp1);
48759 arg2 = obj1;
48760 if (obj2) {
48761 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48762 if (!SWIG_IsOK(ecode3)) {
48763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48764 }
48765 arg3 = static_cast< bool >(val3);
48766 }
48767 if (obj3) {
48768 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48769 if (!SWIG_IsOK(ecode4)) {
48770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48771 }
48772 arg4 = static_cast< bool >(val4);
48773 }
48774 {
48775 PyThreadState* __tstate = wxPyBeginAllowThreads();
48776 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48777 wxPyEndAllowThreads(__tstate);
48778 if (PyErr_Occurred()) SWIG_fail;
48779 }
48780 {
48781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48782 }
48783 return resultobj;
48784 fail:
48785 return NULL;
48786 }
48787
48788
48789 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48790 PyObject *resultobj = 0;
48791 wxSizer *arg1 = (wxSizer *) 0 ;
48792 PyObject *arg2 = (PyObject *) 0 ;
48793 bool result;
48794 void *argp1 = 0 ;
48795 int res1 = 0 ;
48796 PyObject * obj0 = 0 ;
48797 PyObject * obj1 = 0 ;
48798 char * kwnames[] = {
48799 (char *) "self",(char *) "item", NULL
48800 };
48801
48802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48804 if (!SWIG_IsOK(res1)) {
48805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48806 }
48807 arg1 = reinterpret_cast< wxSizer * >(argp1);
48808 arg2 = obj1;
48809 {
48810 PyThreadState* __tstate = wxPyBeginAllowThreads();
48811 result = (bool)wxSizer_IsShown(arg1,arg2);
48812 wxPyEndAllowThreads(__tstate);
48813 if (PyErr_Occurred()) SWIG_fail;
48814 }
48815 {
48816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48817 }
48818 return resultobj;
48819 fail:
48820 return NULL;
48821 }
48822
48823
48824 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48825 PyObject *resultobj = 0;
48826 wxSizer *arg1 = (wxSizer *) 0 ;
48827 bool arg2 ;
48828 void *argp1 = 0 ;
48829 int res1 = 0 ;
48830 bool val2 ;
48831 int ecode2 = 0 ;
48832 PyObject * obj0 = 0 ;
48833 PyObject * obj1 = 0 ;
48834 char * kwnames[] = {
48835 (char *) "self",(char *) "show", NULL
48836 };
48837
48838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48840 if (!SWIG_IsOK(res1)) {
48841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48842 }
48843 arg1 = reinterpret_cast< wxSizer * >(argp1);
48844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48845 if (!SWIG_IsOK(ecode2)) {
48846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48847 }
48848 arg2 = static_cast< bool >(val2);
48849 {
48850 PyThreadState* __tstate = wxPyBeginAllowThreads();
48851 (arg1)->ShowItems(arg2);
48852 wxPyEndAllowThreads(__tstate);
48853 if (PyErr_Occurred()) SWIG_fail;
48854 }
48855 resultobj = SWIG_Py_Void();
48856 return resultobj;
48857 fail:
48858 return NULL;
48859 }
48860
48861
48862 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48863 PyObject *obj;
48864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48865 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48866 return SWIG_Py_Void();
48867 }
48868
48869 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48870 PyObject *resultobj = 0;
48871 wxPySizer *result = 0 ;
48872
48873 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48874 {
48875 PyThreadState* __tstate = wxPyBeginAllowThreads();
48876 result = (wxPySizer *)new wxPySizer();
48877 wxPyEndAllowThreads(__tstate);
48878 if (PyErr_Occurred()) SWIG_fail;
48879 }
48880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48881 return resultobj;
48882 fail:
48883 return NULL;
48884 }
48885
48886
48887 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48888 PyObject *resultobj = 0;
48889 wxPySizer *arg1 = (wxPySizer *) 0 ;
48890 PyObject *arg2 = (PyObject *) 0 ;
48891 PyObject *arg3 = (PyObject *) 0 ;
48892 void *argp1 = 0 ;
48893 int res1 = 0 ;
48894 PyObject * obj0 = 0 ;
48895 PyObject * obj1 = 0 ;
48896 PyObject * obj2 = 0 ;
48897 char * kwnames[] = {
48898 (char *) "self",(char *) "self",(char *) "_class", NULL
48899 };
48900
48901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48903 if (!SWIG_IsOK(res1)) {
48904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48905 }
48906 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48907 arg2 = obj1;
48908 arg3 = obj2;
48909 {
48910 PyThreadState* __tstate = wxPyBeginAllowThreads();
48911 (arg1)->_setCallbackInfo(arg2,arg3);
48912 wxPyEndAllowThreads(__tstate);
48913 if (PyErr_Occurred()) SWIG_fail;
48914 }
48915 resultobj = SWIG_Py_Void();
48916 return resultobj;
48917 fail:
48918 return NULL;
48919 }
48920
48921
48922 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48923 PyObject *obj;
48924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48925 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48926 return SWIG_Py_Void();
48927 }
48928
48929 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48930 return SWIG_Python_InitShadowInstance(args);
48931 }
48932
48933 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48934 PyObject *resultobj = 0;
48935 int arg1 = (int) wxHORIZONTAL ;
48936 wxBoxSizer *result = 0 ;
48937 int val1 ;
48938 int ecode1 = 0 ;
48939 PyObject * obj0 = 0 ;
48940 char * kwnames[] = {
48941 (char *) "orient", NULL
48942 };
48943
48944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48945 if (obj0) {
48946 ecode1 = SWIG_AsVal_int(obj0, &val1);
48947 if (!SWIG_IsOK(ecode1)) {
48948 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48949 }
48950 arg1 = static_cast< int >(val1);
48951 }
48952 {
48953 PyThreadState* __tstate = wxPyBeginAllowThreads();
48954 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48955 wxPyEndAllowThreads(__tstate);
48956 if (PyErr_Occurred()) SWIG_fail;
48957 }
48958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48959 return resultobj;
48960 fail:
48961 return NULL;
48962 }
48963
48964
48965 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48966 PyObject *resultobj = 0;
48967 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48968 int result;
48969 void *argp1 = 0 ;
48970 int res1 = 0 ;
48971 PyObject *swig_obj[1] ;
48972
48973 if (!args) SWIG_fail;
48974 swig_obj[0] = args;
48975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48976 if (!SWIG_IsOK(res1)) {
48977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48978 }
48979 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48980 {
48981 PyThreadState* __tstate = wxPyBeginAllowThreads();
48982 result = (int)(arg1)->GetOrientation();
48983 wxPyEndAllowThreads(__tstate);
48984 if (PyErr_Occurred()) SWIG_fail;
48985 }
48986 resultobj = SWIG_From_int(static_cast< int >(result));
48987 return resultobj;
48988 fail:
48989 return NULL;
48990 }
48991
48992
48993 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48994 PyObject *resultobj = 0;
48995 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48996 int arg2 ;
48997 void *argp1 = 0 ;
48998 int res1 = 0 ;
48999 int val2 ;
49000 int ecode2 = 0 ;
49001 PyObject * obj0 = 0 ;
49002 PyObject * obj1 = 0 ;
49003 char * kwnames[] = {
49004 (char *) "self",(char *) "orient", NULL
49005 };
49006
49007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49009 if (!SWIG_IsOK(res1)) {
49010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49011 }
49012 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49013 ecode2 = SWIG_AsVal_int(obj1, &val2);
49014 if (!SWIG_IsOK(ecode2)) {
49015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49016 }
49017 arg2 = static_cast< int >(val2);
49018 {
49019 PyThreadState* __tstate = wxPyBeginAllowThreads();
49020 (arg1)->SetOrientation(arg2);
49021 wxPyEndAllowThreads(__tstate);
49022 if (PyErr_Occurred()) SWIG_fail;
49023 }
49024 resultobj = SWIG_Py_Void();
49025 return resultobj;
49026 fail:
49027 return NULL;
49028 }
49029
49030
49031 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49032 PyObject *obj;
49033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49034 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49035 return SWIG_Py_Void();
49036 }
49037
49038 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49039 return SWIG_Python_InitShadowInstance(args);
49040 }
49041
49042 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49043 PyObject *resultobj = 0;
49044 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49045 int arg2 = (int) wxHORIZONTAL ;
49046 wxStaticBoxSizer *result = 0 ;
49047 void *argp1 = 0 ;
49048 int res1 = 0 ;
49049 int val2 ;
49050 int ecode2 = 0 ;
49051 PyObject * obj0 = 0 ;
49052 PyObject * obj1 = 0 ;
49053 char * kwnames[] = {
49054 (char *) "box",(char *) "orient", NULL
49055 };
49056
49057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49059 if (!SWIG_IsOK(res1)) {
49060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49061 }
49062 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49063 if (obj1) {
49064 ecode2 = SWIG_AsVal_int(obj1, &val2);
49065 if (!SWIG_IsOK(ecode2)) {
49066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49067 }
49068 arg2 = static_cast< int >(val2);
49069 }
49070 {
49071 PyThreadState* __tstate = wxPyBeginAllowThreads();
49072 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49073 wxPyEndAllowThreads(__tstate);
49074 if (PyErr_Occurred()) SWIG_fail;
49075 }
49076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49077 return resultobj;
49078 fail:
49079 return NULL;
49080 }
49081
49082
49083 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49084 PyObject *resultobj = 0;
49085 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49086 wxStaticBox *result = 0 ;
49087 void *argp1 = 0 ;
49088 int res1 = 0 ;
49089 PyObject *swig_obj[1] ;
49090
49091 if (!args) SWIG_fail;
49092 swig_obj[0] = args;
49093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49094 if (!SWIG_IsOK(res1)) {
49095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49096 }
49097 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49098 {
49099 PyThreadState* __tstate = wxPyBeginAllowThreads();
49100 result = (wxStaticBox *)(arg1)->GetStaticBox();
49101 wxPyEndAllowThreads(__tstate);
49102 if (PyErr_Occurred()) SWIG_fail;
49103 }
49104 {
49105 resultobj = wxPyMake_wxObject(result, (bool)0);
49106 }
49107 return resultobj;
49108 fail:
49109 return NULL;
49110 }
49111
49112
49113 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49114 PyObject *obj;
49115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49116 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49117 return SWIG_Py_Void();
49118 }
49119
49120 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49121 return SWIG_Python_InitShadowInstance(args);
49122 }
49123
49124 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49125 PyObject *resultobj = 0;
49126 int arg1 = (int) 1 ;
49127 int arg2 = (int) 0 ;
49128 int arg3 = (int) 0 ;
49129 int arg4 = (int) 0 ;
49130 wxGridSizer *result = 0 ;
49131 int val1 ;
49132 int ecode1 = 0 ;
49133 int val2 ;
49134 int ecode2 = 0 ;
49135 int val3 ;
49136 int ecode3 = 0 ;
49137 int val4 ;
49138 int ecode4 = 0 ;
49139 PyObject * obj0 = 0 ;
49140 PyObject * obj1 = 0 ;
49141 PyObject * obj2 = 0 ;
49142 PyObject * obj3 = 0 ;
49143 char * kwnames[] = {
49144 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49145 };
49146
49147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49148 if (obj0) {
49149 ecode1 = SWIG_AsVal_int(obj0, &val1);
49150 if (!SWIG_IsOK(ecode1)) {
49151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49152 }
49153 arg1 = static_cast< int >(val1);
49154 }
49155 if (obj1) {
49156 ecode2 = SWIG_AsVal_int(obj1, &val2);
49157 if (!SWIG_IsOK(ecode2)) {
49158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49159 }
49160 arg2 = static_cast< int >(val2);
49161 }
49162 if (obj2) {
49163 ecode3 = SWIG_AsVal_int(obj2, &val3);
49164 if (!SWIG_IsOK(ecode3)) {
49165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49166 }
49167 arg3 = static_cast< int >(val3);
49168 }
49169 if (obj3) {
49170 ecode4 = SWIG_AsVal_int(obj3, &val4);
49171 if (!SWIG_IsOK(ecode4)) {
49172 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49173 }
49174 arg4 = static_cast< int >(val4);
49175 }
49176 {
49177 PyThreadState* __tstate = wxPyBeginAllowThreads();
49178 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49179 wxPyEndAllowThreads(__tstate);
49180 if (PyErr_Occurred()) SWIG_fail;
49181 }
49182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49183 return resultobj;
49184 fail:
49185 return NULL;
49186 }
49187
49188
49189 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49190 PyObject *resultobj = 0;
49191 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49192 int arg2 ;
49193 void *argp1 = 0 ;
49194 int res1 = 0 ;
49195 int val2 ;
49196 int ecode2 = 0 ;
49197 PyObject * obj0 = 0 ;
49198 PyObject * obj1 = 0 ;
49199 char * kwnames[] = {
49200 (char *) "self",(char *) "cols", NULL
49201 };
49202
49203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49205 if (!SWIG_IsOK(res1)) {
49206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49207 }
49208 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49209 ecode2 = SWIG_AsVal_int(obj1, &val2);
49210 if (!SWIG_IsOK(ecode2)) {
49211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49212 }
49213 arg2 = static_cast< int >(val2);
49214 {
49215 PyThreadState* __tstate = wxPyBeginAllowThreads();
49216 (arg1)->SetCols(arg2);
49217 wxPyEndAllowThreads(__tstate);
49218 if (PyErr_Occurred()) SWIG_fail;
49219 }
49220 resultobj = SWIG_Py_Void();
49221 return resultobj;
49222 fail:
49223 return NULL;
49224 }
49225
49226
49227 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49228 PyObject *resultobj = 0;
49229 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49230 int arg2 ;
49231 void *argp1 = 0 ;
49232 int res1 = 0 ;
49233 int val2 ;
49234 int ecode2 = 0 ;
49235 PyObject * obj0 = 0 ;
49236 PyObject * obj1 = 0 ;
49237 char * kwnames[] = {
49238 (char *) "self",(char *) "rows", NULL
49239 };
49240
49241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49243 if (!SWIG_IsOK(res1)) {
49244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49245 }
49246 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49247 ecode2 = SWIG_AsVal_int(obj1, &val2);
49248 if (!SWIG_IsOK(ecode2)) {
49249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49250 }
49251 arg2 = static_cast< int >(val2);
49252 {
49253 PyThreadState* __tstate = wxPyBeginAllowThreads();
49254 (arg1)->SetRows(arg2);
49255 wxPyEndAllowThreads(__tstate);
49256 if (PyErr_Occurred()) SWIG_fail;
49257 }
49258 resultobj = SWIG_Py_Void();
49259 return resultobj;
49260 fail:
49261 return NULL;
49262 }
49263
49264
49265 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49266 PyObject *resultobj = 0;
49267 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49268 int arg2 ;
49269 void *argp1 = 0 ;
49270 int res1 = 0 ;
49271 int val2 ;
49272 int ecode2 = 0 ;
49273 PyObject * obj0 = 0 ;
49274 PyObject * obj1 = 0 ;
49275 char * kwnames[] = {
49276 (char *) "self",(char *) "gap", NULL
49277 };
49278
49279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49281 if (!SWIG_IsOK(res1)) {
49282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49283 }
49284 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49285 ecode2 = SWIG_AsVal_int(obj1, &val2);
49286 if (!SWIG_IsOK(ecode2)) {
49287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49288 }
49289 arg2 = static_cast< int >(val2);
49290 {
49291 PyThreadState* __tstate = wxPyBeginAllowThreads();
49292 (arg1)->SetVGap(arg2);
49293 wxPyEndAllowThreads(__tstate);
49294 if (PyErr_Occurred()) SWIG_fail;
49295 }
49296 resultobj = SWIG_Py_Void();
49297 return resultobj;
49298 fail:
49299 return NULL;
49300 }
49301
49302
49303 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49304 PyObject *resultobj = 0;
49305 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49306 int arg2 ;
49307 void *argp1 = 0 ;
49308 int res1 = 0 ;
49309 int val2 ;
49310 int ecode2 = 0 ;
49311 PyObject * obj0 = 0 ;
49312 PyObject * obj1 = 0 ;
49313 char * kwnames[] = {
49314 (char *) "self",(char *) "gap", NULL
49315 };
49316
49317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49319 if (!SWIG_IsOK(res1)) {
49320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49321 }
49322 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49323 ecode2 = SWIG_AsVal_int(obj1, &val2);
49324 if (!SWIG_IsOK(ecode2)) {
49325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49326 }
49327 arg2 = static_cast< int >(val2);
49328 {
49329 PyThreadState* __tstate = wxPyBeginAllowThreads();
49330 (arg1)->SetHGap(arg2);
49331 wxPyEndAllowThreads(__tstate);
49332 if (PyErr_Occurred()) SWIG_fail;
49333 }
49334 resultobj = SWIG_Py_Void();
49335 return resultobj;
49336 fail:
49337 return NULL;
49338 }
49339
49340
49341 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49342 PyObject *resultobj = 0;
49343 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49344 int result;
49345 void *argp1 = 0 ;
49346 int res1 = 0 ;
49347 PyObject *swig_obj[1] ;
49348
49349 if (!args) SWIG_fail;
49350 swig_obj[0] = args;
49351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49352 if (!SWIG_IsOK(res1)) {
49353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49354 }
49355 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49356 {
49357 PyThreadState* __tstate = wxPyBeginAllowThreads();
49358 result = (int)(arg1)->GetCols();
49359 wxPyEndAllowThreads(__tstate);
49360 if (PyErr_Occurred()) SWIG_fail;
49361 }
49362 resultobj = SWIG_From_int(static_cast< int >(result));
49363 return resultobj;
49364 fail:
49365 return NULL;
49366 }
49367
49368
49369 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49370 PyObject *resultobj = 0;
49371 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49372 int result;
49373 void *argp1 = 0 ;
49374 int res1 = 0 ;
49375 PyObject *swig_obj[1] ;
49376
49377 if (!args) SWIG_fail;
49378 swig_obj[0] = args;
49379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49380 if (!SWIG_IsOK(res1)) {
49381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49382 }
49383 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49384 {
49385 PyThreadState* __tstate = wxPyBeginAllowThreads();
49386 result = (int)(arg1)->GetRows();
49387 wxPyEndAllowThreads(__tstate);
49388 if (PyErr_Occurred()) SWIG_fail;
49389 }
49390 resultobj = SWIG_From_int(static_cast< int >(result));
49391 return resultobj;
49392 fail:
49393 return NULL;
49394 }
49395
49396
49397 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49398 PyObject *resultobj = 0;
49399 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49400 int result;
49401 void *argp1 = 0 ;
49402 int res1 = 0 ;
49403 PyObject *swig_obj[1] ;
49404
49405 if (!args) SWIG_fail;
49406 swig_obj[0] = args;
49407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49408 if (!SWIG_IsOK(res1)) {
49409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49410 }
49411 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49412 {
49413 PyThreadState* __tstate = wxPyBeginAllowThreads();
49414 result = (int)(arg1)->GetVGap();
49415 wxPyEndAllowThreads(__tstate);
49416 if (PyErr_Occurred()) SWIG_fail;
49417 }
49418 resultobj = SWIG_From_int(static_cast< int >(result));
49419 return resultobj;
49420 fail:
49421 return NULL;
49422 }
49423
49424
49425 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49426 PyObject *resultobj = 0;
49427 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49428 int result;
49429 void *argp1 = 0 ;
49430 int res1 = 0 ;
49431 PyObject *swig_obj[1] ;
49432
49433 if (!args) SWIG_fail;
49434 swig_obj[0] = args;
49435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49436 if (!SWIG_IsOK(res1)) {
49437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49438 }
49439 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49440 {
49441 PyThreadState* __tstate = wxPyBeginAllowThreads();
49442 result = (int)(arg1)->GetHGap();
49443 wxPyEndAllowThreads(__tstate);
49444 if (PyErr_Occurred()) SWIG_fail;
49445 }
49446 resultobj = SWIG_From_int(static_cast< int >(result));
49447 return resultobj;
49448 fail:
49449 return NULL;
49450 }
49451
49452
49453 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49454 PyObject *obj;
49455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49456 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49457 return SWIG_Py_Void();
49458 }
49459
49460 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49461 return SWIG_Python_InitShadowInstance(args);
49462 }
49463
49464 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49465 PyObject *resultobj = 0;
49466 int arg1 = (int) 1 ;
49467 int arg2 = (int) 0 ;
49468 int arg3 = (int) 0 ;
49469 int arg4 = (int) 0 ;
49470 wxFlexGridSizer *result = 0 ;
49471 int val1 ;
49472 int ecode1 = 0 ;
49473 int val2 ;
49474 int ecode2 = 0 ;
49475 int val3 ;
49476 int ecode3 = 0 ;
49477 int val4 ;
49478 int ecode4 = 0 ;
49479 PyObject * obj0 = 0 ;
49480 PyObject * obj1 = 0 ;
49481 PyObject * obj2 = 0 ;
49482 PyObject * obj3 = 0 ;
49483 char * kwnames[] = {
49484 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49485 };
49486
49487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49488 if (obj0) {
49489 ecode1 = SWIG_AsVal_int(obj0, &val1);
49490 if (!SWIG_IsOK(ecode1)) {
49491 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49492 }
49493 arg1 = static_cast< int >(val1);
49494 }
49495 if (obj1) {
49496 ecode2 = SWIG_AsVal_int(obj1, &val2);
49497 if (!SWIG_IsOK(ecode2)) {
49498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49499 }
49500 arg2 = static_cast< int >(val2);
49501 }
49502 if (obj2) {
49503 ecode3 = SWIG_AsVal_int(obj2, &val3);
49504 if (!SWIG_IsOK(ecode3)) {
49505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49506 }
49507 arg3 = static_cast< int >(val3);
49508 }
49509 if (obj3) {
49510 ecode4 = SWIG_AsVal_int(obj3, &val4);
49511 if (!SWIG_IsOK(ecode4)) {
49512 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49513 }
49514 arg4 = static_cast< int >(val4);
49515 }
49516 {
49517 PyThreadState* __tstate = wxPyBeginAllowThreads();
49518 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49519 wxPyEndAllowThreads(__tstate);
49520 if (PyErr_Occurred()) SWIG_fail;
49521 }
49522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49523 return resultobj;
49524 fail:
49525 return NULL;
49526 }
49527
49528
49529 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49530 PyObject *resultobj = 0;
49531 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49532 size_t arg2 ;
49533 int arg3 = (int) 0 ;
49534 void *argp1 = 0 ;
49535 int res1 = 0 ;
49536 size_t val2 ;
49537 int ecode2 = 0 ;
49538 int val3 ;
49539 int ecode3 = 0 ;
49540 PyObject * obj0 = 0 ;
49541 PyObject * obj1 = 0 ;
49542 PyObject * obj2 = 0 ;
49543 char * kwnames[] = {
49544 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49545 };
49546
49547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49549 if (!SWIG_IsOK(res1)) {
49550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49551 }
49552 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49553 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49554 if (!SWIG_IsOK(ecode2)) {
49555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49556 }
49557 arg2 = static_cast< size_t >(val2);
49558 if (obj2) {
49559 ecode3 = SWIG_AsVal_int(obj2, &val3);
49560 if (!SWIG_IsOK(ecode3)) {
49561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49562 }
49563 arg3 = static_cast< int >(val3);
49564 }
49565 {
49566 PyThreadState* __tstate = wxPyBeginAllowThreads();
49567 (arg1)->AddGrowableRow(arg2,arg3);
49568 wxPyEndAllowThreads(__tstate);
49569 if (PyErr_Occurred()) SWIG_fail;
49570 }
49571 resultobj = SWIG_Py_Void();
49572 return resultobj;
49573 fail:
49574 return NULL;
49575 }
49576
49577
49578 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49579 PyObject *resultobj = 0;
49580 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49581 size_t arg2 ;
49582 void *argp1 = 0 ;
49583 int res1 = 0 ;
49584 size_t val2 ;
49585 int ecode2 = 0 ;
49586 PyObject * obj0 = 0 ;
49587 PyObject * obj1 = 0 ;
49588 char * kwnames[] = {
49589 (char *) "self",(char *) "idx", NULL
49590 };
49591
49592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49594 if (!SWIG_IsOK(res1)) {
49595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49596 }
49597 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49598 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49599 if (!SWIG_IsOK(ecode2)) {
49600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49601 }
49602 arg2 = static_cast< size_t >(val2);
49603 {
49604 PyThreadState* __tstate = wxPyBeginAllowThreads();
49605 (arg1)->RemoveGrowableRow(arg2);
49606 wxPyEndAllowThreads(__tstate);
49607 if (PyErr_Occurred()) SWIG_fail;
49608 }
49609 resultobj = SWIG_Py_Void();
49610 return resultobj;
49611 fail:
49612 return NULL;
49613 }
49614
49615
49616 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49617 PyObject *resultobj = 0;
49618 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49619 size_t arg2 ;
49620 int arg3 = (int) 0 ;
49621 void *argp1 = 0 ;
49622 int res1 = 0 ;
49623 size_t val2 ;
49624 int ecode2 = 0 ;
49625 int val3 ;
49626 int ecode3 = 0 ;
49627 PyObject * obj0 = 0 ;
49628 PyObject * obj1 = 0 ;
49629 PyObject * obj2 = 0 ;
49630 char * kwnames[] = {
49631 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49632 };
49633
49634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49636 if (!SWIG_IsOK(res1)) {
49637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49638 }
49639 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49640 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49641 if (!SWIG_IsOK(ecode2)) {
49642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49643 }
49644 arg2 = static_cast< size_t >(val2);
49645 if (obj2) {
49646 ecode3 = SWIG_AsVal_int(obj2, &val3);
49647 if (!SWIG_IsOK(ecode3)) {
49648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49649 }
49650 arg3 = static_cast< int >(val3);
49651 }
49652 {
49653 PyThreadState* __tstate = wxPyBeginAllowThreads();
49654 (arg1)->AddGrowableCol(arg2,arg3);
49655 wxPyEndAllowThreads(__tstate);
49656 if (PyErr_Occurred()) SWIG_fail;
49657 }
49658 resultobj = SWIG_Py_Void();
49659 return resultobj;
49660 fail:
49661 return NULL;
49662 }
49663
49664
49665 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49666 PyObject *resultobj = 0;
49667 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49668 size_t arg2 ;
49669 void *argp1 = 0 ;
49670 int res1 = 0 ;
49671 size_t val2 ;
49672 int ecode2 = 0 ;
49673 PyObject * obj0 = 0 ;
49674 PyObject * obj1 = 0 ;
49675 char * kwnames[] = {
49676 (char *) "self",(char *) "idx", NULL
49677 };
49678
49679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49681 if (!SWIG_IsOK(res1)) {
49682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49683 }
49684 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49685 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49686 if (!SWIG_IsOK(ecode2)) {
49687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49688 }
49689 arg2 = static_cast< size_t >(val2);
49690 {
49691 PyThreadState* __tstate = wxPyBeginAllowThreads();
49692 (arg1)->RemoveGrowableCol(arg2);
49693 wxPyEndAllowThreads(__tstate);
49694 if (PyErr_Occurred()) SWIG_fail;
49695 }
49696 resultobj = SWIG_Py_Void();
49697 return resultobj;
49698 fail:
49699 return NULL;
49700 }
49701
49702
49703 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49704 PyObject *resultobj = 0;
49705 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49706 int arg2 ;
49707 void *argp1 = 0 ;
49708 int res1 = 0 ;
49709 int val2 ;
49710 int ecode2 = 0 ;
49711 PyObject * obj0 = 0 ;
49712 PyObject * obj1 = 0 ;
49713 char * kwnames[] = {
49714 (char *) "self",(char *) "direction", NULL
49715 };
49716
49717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49719 if (!SWIG_IsOK(res1)) {
49720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49721 }
49722 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49723 ecode2 = SWIG_AsVal_int(obj1, &val2);
49724 if (!SWIG_IsOK(ecode2)) {
49725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49726 }
49727 arg2 = static_cast< int >(val2);
49728 {
49729 PyThreadState* __tstate = wxPyBeginAllowThreads();
49730 (arg1)->SetFlexibleDirection(arg2);
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_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49742 PyObject *resultobj = 0;
49743 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49744 int result;
49745 void *argp1 = 0 ;
49746 int res1 = 0 ;
49747 PyObject *swig_obj[1] ;
49748
49749 if (!args) SWIG_fail;
49750 swig_obj[0] = args;
49751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49752 if (!SWIG_IsOK(res1)) {
49753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49754 }
49755 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49756 {
49757 PyThreadState* __tstate = wxPyBeginAllowThreads();
49758 result = (int)(arg1)->GetFlexibleDirection();
49759 wxPyEndAllowThreads(__tstate);
49760 if (PyErr_Occurred()) SWIG_fail;
49761 }
49762 resultobj = SWIG_From_int(static_cast< int >(result));
49763 return resultobj;
49764 fail:
49765 return NULL;
49766 }
49767
49768
49769 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49770 PyObject *resultobj = 0;
49771 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49772 wxFlexSizerGrowMode arg2 ;
49773 void *argp1 = 0 ;
49774 int res1 = 0 ;
49775 int val2 ;
49776 int ecode2 = 0 ;
49777 PyObject * obj0 = 0 ;
49778 PyObject * obj1 = 0 ;
49779 char * kwnames[] = {
49780 (char *) "self",(char *) "mode", NULL
49781 };
49782
49783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49785 if (!SWIG_IsOK(res1)) {
49786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49787 }
49788 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49789 ecode2 = SWIG_AsVal_int(obj1, &val2);
49790 if (!SWIG_IsOK(ecode2)) {
49791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49792 }
49793 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49794 {
49795 PyThreadState* __tstate = wxPyBeginAllowThreads();
49796 (arg1)->SetNonFlexibleGrowMode(arg2);
49797 wxPyEndAllowThreads(__tstate);
49798 if (PyErr_Occurred()) SWIG_fail;
49799 }
49800 resultobj = SWIG_Py_Void();
49801 return resultobj;
49802 fail:
49803 return NULL;
49804 }
49805
49806
49807 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49808 PyObject *resultobj = 0;
49809 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49810 wxFlexSizerGrowMode result;
49811 void *argp1 = 0 ;
49812 int res1 = 0 ;
49813 PyObject *swig_obj[1] ;
49814
49815 if (!args) SWIG_fail;
49816 swig_obj[0] = args;
49817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49818 if (!SWIG_IsOK(res1)) {
49819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49820 }
49821 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49822 {
49823 PyThreadState* __tstate = wxPyBeginAllowThreads();
49824 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49825 wxPyEndAllowThreads(__tstate);
49826 if (PyErr_Occurred()) SWIG_fail;
49827 }
49828 resultobj = SWIG_From_int(static_cast< int >(result));
49829 return resultobj;
49830 fail:
49831 return NULL;
49832 }
49833
49834
49835 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49836 PyObject *resultobj = 0;
49837 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49838 wxArrayInt *result = 0 ;
49839 void *argp1 = 0 ;
49840 int res1 = 0 ;
49841 PyObject *swig_obj[1] ;
49842
49843 if (!args) SWIG_fail;
49844 swig_obj[0] = args;
49845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49846 if (!SWIG_IsOK(res1)) {
49847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49848 }
49849 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49850 {
49851 PyThreadState* __tstate = wxPyBeginAllowThreads();
49852 {
49853 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49854 result = (wxArrayInt *) &_result_ref;
49855 }
49856 wxPyEndAllowThreads(__tstate);
49857 if (PyErr_Occurred()) SWIG_fail;
49858 }
49859 {
49860 resultobj = PyList_New(0);
49861 size_t idx;
49862 for (idx = 0; idx < result->GetCount(); idx += 1) {
49863 PyObject* val = PyInt_FromLong( result->Item(idx) );
49864 PyList_Append(resultobj, val);
49865 Py_DECREF(val);
49866 }
49867 }
49868 return resultobj;
49869 fail:
49870 return NULL;
49871 }
49872
49873
49874 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49875 PyObject *resultobj = 0;
49876 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49877 wxArrayInt *result = 0 ;
49878 void *argp1 = 0 ;
49879 int res1 = 0 ;
49880 PyObject *swig_obj[1] ;
49881
49882 if (!args) SWIG_fail;
49883 swig_obj[0] = args;
49884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49885 if (!SWIG_IsOK(res1)) {
49886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49887 }
49888 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49889 {
49890 PyThreadState* __tstate = wxPyBeginAllowThreads();
49891 {
49892 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49893 result = (wxArrayInt *) &_result_ref;
49894 }
49895 wxPyEndAllowThreads(__tstate);
49896 if (PyErr_Occurred()) SWIG_fail;
49897 }
49898 {
49899 resultobj = PyList_New(0);
49900 size_t idx;
49901 for (idx = 0; idx < result->GetCount(); idx += 1) {
49902 PyObject* val = PyInt_FromLong( result->Item(idx) );
49903 PyList_Append(resultobj, val);
49904 Py_DECREF(val);
49905 }
49906 }
49907 return resultobj;
49908 fail:
49909 return NULL;
49910 }
49911
49912
49913 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49914 PyObject *obj;
49915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49916 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49917 return SWIG_Py_Void();
49918 }
49919
49920 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49921 return SWIG_Python_InitShadowInstance(args);
49922 }
49923
49924 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49925 PyObject *resultobj = 0;
49926 wxStdDialogButtonSizer *result = 0 ;
49927
49928 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49929 {
49930 PyThreadState* __tstate = wxPyBeginAllowThreads();
49931 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49932 wxPyEndAllowThreads(__tstate);
49933 if (PyErr_Occurred()) SWIG_fail;
49934 }
49935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49936 return resultobj;
49937 fail:
49938 return NULL;
49939 }
49940
49941
49942 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49943 PyObject *resultobj = 0;
49944 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49945 wxButton *arg2 = (wxButton *) 0 ;
49946 void *argp1 = 0 ;
49947 int res1 = 0 ;
49948 void *argp2 = 0 ;
49949 int res2 = 0 ;
49950 PyObject * obj0 = 0 ;
49951 PyObject * obj1 = 0 ;
49952 char * kwnames[] = {
49953 (char *) "self",(char *) "button", NULL
49954 };
49955
49956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49958 if (!SWIG_IsOK(res1)) {
49959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49960 }
49961 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49962 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49963 if (!SWIG_IsOK(res2)) {
49964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49965 }
49966 arg2 = reinterpret_cast< wxButton * >(argp2);
49967 {
49968 PyThreadState* __tstate = wxPyBeginAllowThreads();
49969 (arg1)->AddButton(arg2);
49970 wxPyEndAllowThreads(__tstate);
49971 if (PyErr_Occurred()) SWIG_fail;
49972 }
49973 resultobj = SWIG_Py_Void();
49974 return resultobj;
49975 fail:
49976 return NULL;
49977 }
49978
49979
49980 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49981 PyObject *resultobj = 0;
49982 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49983 void *argp1 = 0 ;
49984 int res1 = 0 ;
49985 PyObject *swig_obj[1] ;
49986
49987 if (!args) SWIG_fail;
49988 swig_obj[0] = args;
49989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49990 if (!SWIG_IsOK(res1)) {
49991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49992 }
49993 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49994 {
49995 PyThreadState* __tstate = wxPyBeginAllowThreads();
49996 (arg1)->Realize();
49997 wxPyEndAllowThreads(__tstate);
49998 if (PyErr_Occurred()) SWIG_fail;
49999 }
50000 resultobj = SWIG_Py_Void();
50001 return resultobj;
50002 fail:
50003 return NULL;
50004 }
50005
50006
50007 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50008 PyObject *resultobj = 0;
50009 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50010 wxButton *arg2 = (wxButton *) 0 ;
50011 void *argp1 = 0 ;
50012 int res1 = 0 ;
50013 void *argp2 = 0 ;
50014 int res2 = 0 ;
50015 PyObject * obj0 = 0 ;
50016 PyObject * obj1 = 0 ;
50017 char * kwnames[] = {
50018 (char *) "self",(char *) "button", NULL
50019 };
50020
50021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50023 if (!SWIG_IsOK(res1)) {
50024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50025 }
50026 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50027 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50028 if (!SWIG_IsOK(res2)) {
50029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50030 }
50031 arg2 = reinterpret_cast< wxButton * >(argp2);
50032 {
50033 PyThreadState* __tstate = wxPyBeginAllowThreads();
50034 (arg1)->SetAffirmativeButton(arg2);
50035 wxPyEndAllowThreads(__tstate);
50036 if (PyErr_Occurred()) SWIG_fail;
50037 }
50038 resultobj = SWIG_Py_Void();
50039 return resultobj;
50040 fail:
50041 return NULL;
50042 }
50043
50044
50045 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50046 PyObject *resultobj = 0;
50047 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50048 wxButton *arg2 = (wxButton *) 0 ;
50049 void *argp1 = 0 ;
50050 int res1 = 0 ;
50051 void *argp2 = 0 ;
50052 int res2 = 0 ;
50053 PyObject * obj0 = 0 ;
50054 PyObject * obj1 = 0 ;
50055 char * kwnames[] = {
50056 (char *) "self",(char *) "button", NULL
50057 };
50058
50059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50061 if (!SWIG_IsOK(res1)) {
50062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50063 }
50064 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50065 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50066 if (!SWIG_IsOK(res2)) {
50067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50068 }
50069 arg2 = reinterpret_cast< wxButton * >(argp2);
50070 {
50071 PyThreadState* __tstate = wxPyBeginAllowThreads();
50072 (arg1)->SetNegativeButton(arg2);
50073 wxPyEndAllowThreads(__tstate);
50074 if (PyErr_Occurred()) SWIG_fail;
50075 }
50076 resultobj = SWIG_Py_Void();
50077 return resultobj;
50078 fail:
50079 return NULL;
50080 }
50081
50082
50083 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50084 PyObject *resultobj = 0;
50085 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50086 wxButton *arg2 = (wxButton *) 0 ;
50087 void *argp1 = 0 ;
50088 int res1 = 0 ;
50089 void *argp2 = 0 ;
50090 int res2 = 0 ;
50091 PyObject * obj0 = 0 ;
50092 PyObject * obj1 = 0 ;
50093 char * kwnames[] = {
50094 (char *) "self",(char *) "button", NULL
50095 };
50096
50097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50099 if (!SWIG_IsOK(res1)) {
50100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50101 }
50102 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50103 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50104 if (!SWIG_IsOK(res2)) {
50105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50106 }
50107 arg2 = reinterpret_cast< wxButton * >(argp2);
50108 {
50109 PyThreadState* __tstate = wxPyBeginAllowThreads();
50110 (arg1)->SetCancelButton(arg2);
50111 wxPyEndAllowThreads(__tstate);
50112 if (PyErr_Occurred()) SWIG_fail;
50113 }
50114 resultobj = SWIG_Py_Void();
50115 return resultobj;
50116 fail:
50117 return NULL;
50118 }
50119
50120
50121 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50122 PyObject *resultobj = 0;
50123 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50124 wxButton *result = 0 ;
50125 void *argp1 = 0 ;
50126 int res1 = 0 ;
50127 PyObject *swig_obj[1] ;
50128
50129 if (!args) SWIG_fail;
50130 swig_obj[0] = args;
50131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50132 if (!SWIG_IsOK(res1)) {
50133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50134 }
50135 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50136 {
50137 PyThreadState* __tstate = wxPyBeginAllowThreads();
50138 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50139 wxPyEndAllowThreads(__tstate);
50140 if (PyErr_Occurred()) SWIG_fail;
50141 }
50142 {
50143 resultobj = wxPyMake_wxObject(result, (bool)0);
50144 }
50145 return resultobj;
50146 fail:
50147 return NULL;
50148 }
50149
50150
50151 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50152 PyObject *resultobj = 0;
50153 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50154 wxButton *result = 0 ;
50155 void *argp1 = 0 ;
50156 int res1 = 0 ;
50157 PyObject *swig_obj[1] ;
50158
50159 if (!args) SWIG_fail;
50160 swig_obj[0] = args;
50161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50162 if (!SWIG_IsOK(res1)) {
50163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50164 }
50165 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50166 {
50167 PyThreadState* __tstate = wxPyBeginAllowThreads();
50168 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50169 wxPyEndAllowThreads(__tstate);
50170 if (PyErr_Occurred()) SWIG_fail;
50171 }
50172 {
50173 resultobj = wxPyMake_wxObject(result, (bool)0);
50174 }
50175 return resultobj;
50176 fail:
50177 return NULL;
50178 }
50179
50180
50181 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50182 PyObject *resultobj = 0;
50183 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50184 wxButton *result = 0 ;
50185 void *argp1 = 0 ;
50186 int res1 = 0 ;
50187 PyObject *swig_obj[1] ;
50188
50189 if (!args) SWIG_fail;
50190 swig_obj[0] = args;
50191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50192 if (!SWIG_IsOK(res1)) {
50193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50194 }
50195 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50196 {
50197 PyThreadState* __tstate = wxPyBeginAllowThreads();
50198 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50199 wxPyEndAllowThreads(__tstate);
50200 if (PyErr_Occurred()) SWIG_fail;
50201 }
50202 {
50203 resultobj = wxPyMake_wxObject(result, (bool)0);
50204 }
50205 return resultobj;
50206 fail:
50207 return NULL;
50208 }
50209
50210
50211 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50212 PyObject *resultobj = 0;
50213 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50214 wxButton *result = 0 ;
50215 void *argp1 = 0 ;
50216 int res1 = 0 ;
50217 PyObject *swig_obj[1] ;
50218
50219 if (!args) SWIG_fail;
50220 swig_obj[0] = args;
50221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50222 if (!SWIG_IsOK(res1)) {
50223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50224 }
50225 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50226 {
50227 PyThreadState* __tstate = wxPyBeginAllowThreads();
50228 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50229 wxPyEndAllowThreads(__tstate);
50230 if (PyErr_Occurred()) SWIG_fail;
50231 }
50232 {
50233 resultobj = wxPyMake_wxObject(result, (bool)0);
50234 }
50235 return resultobj;
50236 fail:
50237 return NULL;
50238 }
50239
50240
50241 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50242 PyObject *resultobj = 0;
50243 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50244 wxButton *result = 0 ;
50245 void *argp1 = 0 ;
50246 int res1 = 0 ;
50247 PyObject *swig_obj[1] ;
50248
50249 if (!args) SWIG_fail;
50250 swig_obj[0] = args;
50251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50252 if (!SWIG_IsOK(res1)) {
50253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50254 }
50255 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50256 {
50257 PyThreadState* __tstate = wxPyBeginAllowThreads();
50258 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50259 wxPyEndAllowThreads(__tstate);
50260 if (PyErr_Occurred()) SWIG_fail;
50261 }
50262 {
50263 resultobj = wxPyMake_wxObject(result, (bool)0);
50264 }
50265 return resultobj;
50266 fail:
50267 return NULL;
50268 }
50269
50270
50271 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50272 PyObject *obj;
50273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50274 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50275 return SWIG_Py_Void();
50276 }
50277
50278 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50279 return SWIG_Python_InitShadowInstance(args);
50280 }
50281
50282 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50283 PyObject *resultobj = 0;
50284 int arg1 = (int) 0 ;
50285 int arg2 = (int) 0 ;
50286 wxGBPosition *result = 0 ;
50287 int val1 ;
50288 int ecode1 = 0 ;
50289 int val2 ;
50290 int ecode2 = 0 ;
50291 PyObject * obj0 = 0 ;
50292 PyObject * obj1 = 0 ;
50293 char * kwnames[] = {
50294 (char *) "row",(char *) "col", NULL
50295 };
50296
50297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50298 if (obj0) {
50299 ecode1 = SWIG_AsVal_int(obj0, &val1);
50300 if (!SWIG_IsOK(ecode1)) {
50301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50302 }
50303 arg1 = static_cast< int >(val1);
50304 }
50305 if (obj1) {
50306 ecode2 = SWIG_AsVal_int(obj1, &val2);
50307 if (!SWIG_IsOK(ecode2)) {
50308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50309 }
50310 arg2 = static_cast< int >(val2);
50311 }
50312 {
50313 PyThreadState* __tstate = wxPyBeginAllowThreads();
50314 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50315 wxPyEndAllowThreads(__tstate);
50316 if (PyErr_Occurred()) SWIG_fail;
50317 }
50318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50319 return resultobj;
50320 fail:
50321 return NULL;
50322 }
50323
50324
50325 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50326 PyObject *resultobj = 0;
50327 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50328 void *argp1 = 0 ;
50329 int res1 = 0 ;
50330 PyObject *swig_obj[1] ;
50331
50332 if (!args) SWIG_fail;
50333 swig_obj[0] = args;
50334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50335 if (!SWIG_IsOK(res1)) {
50336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50337 }
50338 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50339 {
50340 PyThreadState* __tstate = wxPyBeginAllowThreads();
50341 delete arg1;
50342
50343 wxPyEndAllowThreads(__tstate);
50344 if (PyErr_Occurred()) SWIG_fail;
50345 }
50346 resultobj = SWIG_Py_Void();
50347 return resultobj;
50348 fail:
50349 return NULL;
50350 }
50351
50352
50353 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50354 PyObject *resultobj = 0;
50355 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50356 int result;
50357 void *argp1 = 0 ;
50358 int res1 = 0 ;
50359 PyObject *swig_obj[1] ;
50360
50361 if (!args) SWIG_fail;
50362 swig_obj[0] = args;
50363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50364 if (!SWIG_IsOK(res1)) {
50365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50366 }
50367 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50368 {
50369 PyThreadState* __tstate = wxPyBeginAllowThreads();
50370 result = (int)((wxGBPosition const *)arg1)->GetRow();
50371 wxPyEndAllowThreads(__tstate);
50372 if (PyErr_Occurred()) SWIG_fail;
50373 }
50374 resultobj = SWIG_From_int(static_cast< int >(result));
50375 return resultobj;
50376 fail:
50377 return NULL;
50378 }
50379
50380
50381 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50382 PyObject *resultobj = 0;
50383 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50384 int result;
50385 void *argp1 = 0 ;
50386 int res1 = 0 ;
50387 PyObject *swig_obj[1] ;
50388
50389 if (!args) SWIG_fail;
50390 swig_obj[0] = args;
50391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50392 if (!SWIG_IsOK(res1)) {
50393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50394 }
50395 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50396 {
50397 PyThreadState* __tstate = wxPyBeginAllowThreads();
50398 result = (int)((wxGBPosition const *)arg1)->GetCol();
50399 wxPyEndAllowThreads(__tstate);
50400 if (PyErr_Occurred()) SWIG_fail;
50401 }
50402 resultobj = SWIG_From_int(static_cast< int >(result));
50403 return resultobj;
50404 fail:
50405 return NULL;
50406 }
50407
50408
50409 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50410 PyObject *resultobj = 0;
50411 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50412 int arg2 ;
50413 void *argp1 = 0 ;
50414 int res1 = 0 ;
50415 int val2 ;
50416 int ecode2 = 0 ;
50417 PyObject * obj0 = 0 ;
50418 PyObject * obj1 = 0 ;
50419 char * kwnames[] = {
50420 (char *) "self",(char *) "row", NULL
50421 };
50422
50423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50425 if (!SWIG_IsOK(res1)) {
50426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50427 }
50428 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50429 ecode2 = SWIG_AsVal_int(obj1, &val2);
50430 if (!SWIG_IsOK(ecode2)) {
50431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50432 }
50433 arg2 = static_cast< int >(val2);
50434 {
50435 PyThreadState* __tstate = wxPyBeginAllowThreads();
50436 (arg1)->SetRow(arg2);
50437 wxPyEndAllowThreads(__tstate);
50438 if (PyErr_Occurred()) SWIG_fail;
50439 }
50440 resultobj = SWIG_Py_Void();
50441 return resultobj;
50442 fail:
50443 return NULL;
50444 }
50445
50446
50447 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50448 PyObject *resultobj = 0;
50449 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50450 int arg2 ;
50451 void *argp1 = 0 ;
50452 int res1 = 0 ;
50453 int val2 ;
50454 int ecode2 = 0 ;
50455 PyObject * obj0 = 0 ;
50456 PyObject * obj1 = 0 ;
50457 char * kwnames[] = {
50458 (char *) "self",(char *) "col", NULL
50459 };
50460
50461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50463 if (!SWIG_IsOK(res1)) {
50464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50465 }
50466 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50467 ecode2 = SWIG_AsVal_int(obj1, &val2);
50468 if (!SWIG_IsOK(ecode2)) {
50469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50470 }
50471 arg2 = static_cast< int >(val2);
50472 {
50473 PyThreadState* __tstate = wxPyBeginAllowThreads();
50474 (arg1)->SetCol(arg2);
50475 wxPyEndAllowThreads(__tstate);
50476 if (PyErr_Occurred()) SWIG_fail;
50477 }
50478 resultobj = SWIG_Py_Void();
50479 return resultobj;
50480 fail:
50481 return NULL;
50482 }
50483
50484
50485 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50486 PyObject *resultobj = 0;
50487 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50488 PyObject *arg2 = (PyObject *) 0 ;
50489 bool result;
50490 void *argp1 = 0 ;
50491 int res1 = 0 ;
50492 PyObject * obj0 = 0 ;
50493 PyObject * obj1 = 0 ;
50494 char * kwnames[] = {
50495 (char *) "self",(char *) "other", NULL
50496 };
50497
50498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50500 if (!SWIG_IsOK(res1)) {
50501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50502 }
50503 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50504 arg2 = obj1;
50505 {
50506 result = (bool)wxGBPosition___eq__(arg1,arg2);
50507 if (PyErr_Occurred()) SWIG_fail;
50508 }
50509 {
50510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50511 }
50512 return resultobj;
50513 fail:
50514 return NULL;
50515 }
50516
50517
50518 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50519 PyObject *resultobj = 0;
50520 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50521 PyObject *arg2 = (PyObject *) 0 ;
50522 bool result;
50523 void *argp1 = 0 ;
50524 int res1 = 0 ;
50525 PyObject * obj0 = 0 ;
50526 PyObject * obj1 = 0 ;
50527 char * kwnames[] = {
50528 (char *) "self",(char *) "other", NULL
50529 };
50530
50531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50533 if (!SWIG_IsOK(res1)) {
50534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50535 }
50536 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50537 arg2 = obj1;
50538 {
50539 result = (bool)wxGBPosition___ne__(arg1,arg2);
50540 if (PyErr_Occurred()) SWIG_fail;
50541 }
50542 {
50543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50544 }
50545 return resultobj;
50546 fail:
50547 return NULL;
50548 }
50549
50550
50551 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50552 PyObject *resultobj = 0;
50553 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50554 int arg2 = (int) 0 ;
50555 int arg3 = (int) 0 ;
50556 void *argp1 = 0 ;
50557 int res1 = 0 ;
50558 int val2 ;
50559 int ecode2 = 0 ;
50560 int val3 ;
50561 int ecode3 = 0 ;
50562 PyObject * obj0 = 0 ;
50563 PyObject * obj1 = 0 ;
50564 PyObject * obj2 = 0 ;
50565 char * kwnames[] = {
50566 (char *) "self",(char *) "row",(char *) "col", NULL
50567 };
50568
50569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50571 if (!SWIG_IsOK(res1)) {
50572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50573 }
50574 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50575 if (obj1) {
50576 ecode2 = SWIG_AsVal_int(obj1, &val2);
50577 if (!SWIG_IsOK(ecode2)) {
50578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50579 }
50580 arg2 = static_cast< int >(val2);
50581 }
50582 if (obj2) {
50583 ecode3 = SWIG_AsVal_int(obj2, &val3);
50584 if (!SWIG_IsOK(ecode3)) {
50585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50586 }
50587 arg3 = static_cast< int >(val3);
50588 }
50589 {
50590 PyThreadState* __tstate = wxPyBeginAllowThreads();
50591 wxGBPosition_Set(arg1,arg2,arg3);
50592 wxPyEndAllowThreads(__tstate);
50593 if (PyErr_Occurred()) SWIG_fail;
50594 }
50595 resultobj = SWIG_Py_Void();
50596 return resultobj;
50597 fail:
50598 return NULL;
50599 }
50600
50601
50602 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50603 PyObject *resultobj = 0;
50604 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50605 PyObject *result = 0 ;
50606 void *argp1 = 0 ;
50607 int res1 = 0 ;
50608 PyObject *swig_obj[1] ;
50609
50610 if (!args) SWIG_fail;
50611 swig_obj[0] = args;
50612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50613 if (!SWIG_IsOK(res1)) {
50614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50615 }
50616 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50617 {
50618 PyThreadState* __tstate = wxPyBeginAllowThreads();
50619 result = (PyObject *)wxGBPosition_Get(arg1);
50620 wxPyEndAllowThreads(__tstate);
50621 if (PyErr_Occurred()) SWIG_fail;
50622 }
50623 resultobj = result;
50624 return resultobj;
50625 fail:
50626 return NULL;
50627 }
50628
50629
50630 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50631 PyObject *obj;
50632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50633 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50634 return SWIG_Py_Void();
50635 }
50636
50637 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50638 return SWIG_Python_InitShadowInstance(args);
50639 }
50640
50641 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50642 PyObject *resultobj = 0;
50643 int arg1 = (int) 1 ;
50644 int arg2 = (int) 1 ;
50645 wxGBSpan *result = 0 ;
50646 int val1 ;
50647 int ecode1 = 0 ;
50648 int val2 ;
50649 int ecode2 = 0 ;
50650 PyObject * obj0 = 0 ;
50651 PyObject * obj1 = 0 ;
50652 char * kwnames[] = {
50653 (char *) "rowspan",(char *) "colspan", NULL
50654 };
50655
50656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50657 if (obj0) {
50658 ecode1 = SWIG_AsVal_int(obj0, &val1);
50659 if (!SWIG_IsOK(ecode1)) {
50660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50661 }
50662 arg1 = static_cast< int >(val1);
50663 }
50664 if (obj1) {
50665 ecode2 = SWIG_AsVal_int(obj1, &val2);
50666 if (!SWIG_IsOK(ecode2)) {
50667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50668 }
50669 arg2 = static_cast< int >(val2);
50670 }
50671 {
50672 PyThreadState* __tstate = wxPyBeginAllowThreads();
50673 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50674 wxPyEndAllowThreads(__tstate);
50675 if (PyErr_Occurred()) SWIG_fail;
50676 }
50677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50678 return resultobj;
50679 fail:
50680 return NULL;
50681 }
50682
50683
50684 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50685 PyObject *resultobj = 0;
50686 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50687 void *argp1 = 0 ;
50688 int res1 = 0 ;
50689 PyObject *swig_obj[1] ;
50690
50691 if (!args) SWIG_fail;
50692 swig_obj[0] = args;
50693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50694 if (!SWIG_IsOK(res1)) {
50695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50696 }
50697 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50698 {
50699 PyThreadState* __tstate = wxPyBeginAllowThreads();
50700 delete arg1;
50701
50702 wxPyEndAllowThreads(__tstate);
50703 if (PyErr_Occurred()) SWIG_fail;
50704 }
50705 resultobj = SWIG_Py_Void();
50706 return resultobj;
50707 fail:
50708 return NULL;
50709 }
50710
50711
50712 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50713 PyObject *resultobj = 0;
50714 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50715 int result;
50716 void *argp1 = 0 ;
50717 int res1 = 0 ;
50718 PyObject *swig_obj[1] ;
50719
50720 if (!args) SWIG_fail;
50721 swig_obj[0] = args;
50722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50723 if (!SWIG_IsOK(res1)) {
50724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50725 }
50726 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50727 {
50728 PyThreadState* __tstate = wxPyBeginAllowThreads();
50729 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50730 wxPyEndAllowThreads(__tstate);
50731 if (PyErr_Occurred()) SWIG_fail;
50732 }
50733 resultobj = SWIG_From_int(static_cast< int >(result));
50734 return resultobj;
50735 fail:
50736 return NULL;
50737 }
50738
50739
50740 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50741 PyObject *resultobj = 0;
50742 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50743 int result;
50744 void *argp1 = 0 ;
50745 int res1 = 0 ;
50746 PyObject *swig_obj[1] ;
50747
50748 if (!args) SWIG_fail;
50749 swig_obj[0] = args;
50750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50751 if (!SWIG_IsOK(res1)) {
50752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50753 }
50754 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50755 {
50756 PyThreadState* __tstate = wxPyBeginAllowThreads();
50757 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50758 wxPyEndAllowThreads(__tstate);
50759 if (PyErr_Occurred()) SWIG_fail;
50760 }
50761 resultobj = SWIG_From_int(static_cast< int >(result));
50762 return resultobj;
50763 fail:
50764 return NULL;
50765 }
50766
50767
50768 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50769 PyObject *resultobj = 0;
50770 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50771 int arg2 ;
50772 void *argp1 = 0 ;
50773 int res1 = 0 ;
50774 int val2 ;
50775 int ecode2 = 0 ;
50776 PyObject * obj0 = 0 ;
50777 PyObject * obj1 = 0 ;
50778 char * kwnames[] = {
50779 (char *) "self",(char *) "rowspan", NULL
50780 };
50781
50782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50784 if (!SWIG_IsOK(res1)) {
50785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50786 }
50787 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50788 ecode2 = SWIG_AsVal_int(obj1, &val2);
50789 if (!SWIG_IsOK(ecode2)) {
50790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50791 }
50792 arg2 = static_cast< int >(val2);
50793 {
50794 PyThreadState* __tstate = wxPyBeginAllowThreads();
50795 (arg1)->SetRowspan(arg2);
50796 wxPyEndAllowThreads(__tstate);
50797 if (PyErr_Occurred()) SWIG_fail;
50798 }
50799 resultobj = SWIG_Py_Void();
50800 return resultobj;
50801 fail:
50802 return NULL;
50803 }
50804
50805
50806 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50807 PyObject *resultobj = 0;
50808 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50809 int arg2 ;
50810 void *argp1 = 0 ;
50811 int res1 = 0 ;
50812 int val2 ;
50813 int ecode2 = 0 ;
50814 PyObject * obj0 = 0 ;
50815 PyObject * obj1 = 0 ;
50816 char * kwnames[] = {
50817 (char *) "self",(char *) "colspan", NULL
50818 };
50819
50820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50822 if (!SWIG_IsOK(res1)) {
50823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50824 }
50825 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50826 ecode2 = SWIG_AsVal_int(obj1, &val2);
50827 if (!SWIG_IsOK(ecode2)) {
50828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50829 }
50830 arg2 = static_cast< int >(val2);
50831 {
50832 PyThreadState* __tstate = wxPyBeginAllowThreads();
50833 (arg1)->SetColspan(arg2);
50834 wxPyEndAllowThreads(__tstate);
50835 if (PyErr_Occurred()) SWIG_fail;
50836 }
50837 resultobj = SWIG_Py_Void();
50838 return resultobj;
50839 fail:
50840 return NULL;
50841 }
50842
50843
50844 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50845 PyObject *resultobj = 0;
50846 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50847 PyObject *arg2 = (PyObject *) 0 ;
50848 bool result;
50849 void *argp1 = 0 ;
50850 int res1 = 0 ;
50851 PyObject * obj0 = 0 ;
50852 PyObject * obj1 = 0 ;
50853 char * kwnames[] = {
50854 (char *) "self",(char *) "other", NULL
50855 };
50856
50857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50859 if (!SWIG_IsOK(res1)) {
50860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50861 }
50862 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50863 arg2 = obj1;
50864 {
50865 result = (bool)wxGBSpan___eq__(arg1,arg2);
50866 if (PyErr_Occurred()) SWIG_fail;
50867 }
50868 {
50869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50870 }
50871 return resultobj;
50872 fail:
50873 return NULL;
50874 }
50875
50876
50877 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50878 PyObject *resultobj = 0;
50879 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50880 PyObject *arg2 = (PyObject *) 0 ;
50881 bool result;
50882 void *argp1 = 0 ;
50883 int res1 = 0 ;
50884 PyObject * obj0 = 0 ;
50885 PyObject * obj1 = 0 ;
50886 char * kwnames[] = {
50887 (char *) "self",(char *) "other", NULL
50888 };
50889
50890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50892 if (!SWIG_IsOK(res1)) {
50893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50894 }
50895 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50896 arg2 = obj1;
50897 {
50898 result = (bool)wxGBSpan___ne__(arg1,arg2);
50899 if (PyErr_Occurred()) SWIG_fail;
50900 }
50901 {
50902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50903 }
50904 return resultobj;
50905 fail:
50906 return NULL;
50907 }
50908
50909
50910 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50911 PyObject *resultobj = 0;
50912 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50913 int arg2 = (int) 1 ;
50914 int arg3 = (int) 1 ;
50915 void *argp1 = 0 ;
50916 int res1 = 0 ;
50917 int val2 ;
50918 int ecode2 = 0 ;
50919 int val3 ;
50920 int ecode3 = 0 ;
50921 PyObject * obj0 = 0 ;
50922 PyObject * obj1 = 0 ;
50923 PyObject * obj2 = 0 ;
50924 char * kwnames[] = {
50925 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50926 };
50927
50928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50930 if (!SWIG_IsOK(res1)) {
50931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50932 }
50933 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50934 if (obj1) {
50935 ecode2 = SWIG_AsVal_int(obj1, &val2);
50936 if (!SWIG_IsOK(ecode2)) {
50937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50938 }
50939 arg2 = static_cast< int >(val2);
50940 }
50941 if (obj2) {
50942 ecode3 = SWIG_AsVal_int(obj2, &val3);
50943 if (!SWIG_IsOK(ecode3)) {
50944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50945 }
50946 arg3 = static_cast< int >(val3);
50947 }
50948 {
50949 PyThreadState* __tstate = wxPyBeginAllowThreads();
50950 wxGBSpan_Set(arg1,arg2,arg3);
50951 wxPyEndAllowThreads(__tstate);
50952 if (PyErr_Occurred()) SWIG_fail;
50953 }
50954 resultobj = SWIG_Py_Void();
50955 return resultobj;
50956 fail:
50957 return NULL;
50958 }
50959
50960
50961 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50962 PyObject *resultobj = 0;
50963 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50964 PyObject *result = 0 ;
50965 void *argp1 = 0 ;
50966 int res1 = 0 ;
50967 PyObject *swig_obj[1] ;
50968
50969 if (!args) SWIG_fail;
50970 swig_obj[0] = args;
50971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50972 if (!SWIG_IsOK(res1)) {
50973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50974 }
50975 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50976 {
50977 PyThreadState* __tstate = wxPyBeginAllowThreads();
50978 result = (PyObject *)wxGBSpan_Get(arg1);
50979 wxPyEndAllowThreads(__tstate);
50980 if (PyErr_Occurred()) SWIG_fail;
50981 }
50982 resultobj = result;
50983 return resultobj;
50984 fail:
50985 return NULL;
50986 }
50987
50988
50989 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50990 PyObject *obj;
50991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50992 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50993 return SWIG_Py_Void();
50994 }
50995
50996 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50997 return SWIG_Python_InitShadowInstance(args);
50998 }
50999
51000 SWIGINTERN int DefaultSpan_set(PyObject *) {
51001 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51002 return 1;
51003 }
51004
51005
51006 SWIGINTERN PyObject *DefaultSpan_get(void) {
51007 PyObject *pyobj = 0;
51008
51009 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51010 return pyobj;
51011 }
51012
51013
51014 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51015 PyObject *resultobj = 0;
51016 wxGBSizerItem *result = 0 ;
51017
51018 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51019 {
51020 PyThreadState* __tstate = wxPyBeginAllowThreads();
51021 result = (wxGBSizerItem *)new wxGBSizerItem();
51022 wxPyEndAllowThreads(__tstate);
51023 if (PyErr_Occurred()) SWIG_fail;
51024 }
51025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51026 return resultobj;
51027 fail:
51028 return NULL;
51029 }
51030
51031
51032 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51033 PyObject *resultobj = 0;
51034 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51035 void *argp1 = 0 ;
51036 int res1 = 0 ;
51037 PyObject *swig_obj[1] ;
51038
51039 if (!args) SWIG_fail;
51040 swig_obj[0] = args;
51041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51042 if (!SWIG_IsOK(res1)) {
51043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51044 }
51045 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51046 {
51047 PyThreadState* __tstate = wxPyBeginAllowThreads();
51048 delete arg1;
51049
51050 wxPyEndAllowThreads(__tstate);
51051 if (PyErr_Occurred()) SWIG_fail;
51052 }
51053 resultobj = SWIG_Py_Void();
51054 return resultobj;
51055 fail:
51056 return NULL;
51057 }
51058
51059
51060 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51061 PyObject *resultobj = 0;
51062 wxWindow *arg1 = (wxWindow *) 0 ;
51063 wxGBPosition *arg2 = 0 ;
51064 wxGBSpan *arg3 = 0 ;
51065 int arg4 ;
51066 int arg5 ;
51067 PyObject *arg6 = (PyObject *) NULL ;
51068 wxGBSizerItem *result = 0 ;
51069 void *argp1 = 0 ;
51070 int res1 = 0 ;
51071 wxGBPosition temp2 ;
51072 wxGBSpan temp3 ;
51073 int val4 ;
51074 int ecode4 = 0 ;
51075 int val5 ;
51076 int ecode5 = 0 ;
51077 PyObject * obj0 = 0 ;
51078 PyObject * obj1 = 0 ;
51079 PyObject * obj2 = 0 ;
51080 PyObject * obj3 = 0 ;
51081 PyObject * obj4 = 0 ;
51082 PyObject * obj5 = 0 ;
51083 char * kwnames[] = {
51084 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51085 };
51086
51087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51089 if (!SWIG_IsOK(res1)) {
51090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51091 }
51092 arg1 = reinterpret_cast< wxWindow * >(argp1);
51093 {
51094 arg2 = &temp2;
51095 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51096 }
51097 {
51098 arg3 = &temp3;
51099 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51100 }
51101 ecode4 = SWIG_AsVal_int(obj3, &val4);
51102 if (!SWIG_IsOK(ecode4)) {
51103 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51104 }
51105 arg4 = static_cast< int >(val4);
51106 ecode5 = SWIG_AsVal_int(obj4, &val5);
51107 if (!SWIG_IsOK(ecode5)) {
51108 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51109 }
51110 arg5 = static_cast< int >(val5);
51111 if (obj5) {
51112 arg6 = obj5;
51113 }
51114 {
51115 PyThreadState* __tstate = wxPyBeginAllowThreads();
51116 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51117 wxPyEndAllowThreads(__tstate);
51118 if (PyErr_Occurred()) SWIG_fail;
51119 }
51120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51121 return resultobj;
51122 fail:
51123 return NULL;
51124 }
51125
51126
51127 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51128 PyObject *resultobj = 0;
51129 wxSizer *arg1 = (wxSizer *) 0 ;
51130 wxGBPosition *arg2 = 0 ;
51131 wxGBSpan *arg3 = 0 ;
51132 int arg4 ;
51133 int arg5 ;
51134 PyObject *arg6 = (PyObject *) NULL ;
51135 wxGBSizerItem *result = 0 ;
51136 int res1 = 0 ;
51137 wxGBPosition temp2 ;
51138 wxGBSpan temp3 ;
51139 int val4 ;
51140 int ecode4 = 0 ;
51141 int val5 ;
51142 int ecode5 = 0 ;
51143 PyObject * obj0 = 0 ;
51144 PyObject * obj1 = 0 ;
51145 PyObject * obj2 = 0 ;
51146 PyObject * obj3 = 0 ;
51147 PyObject * obj4 = 0 ;
51148 PyObject * obj5 = 0 ;
51149 char * kwnames[] = {
51150 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51151 };
51152
51153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51154 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51155 if (!SWIG_IsOK(res1)) {
51156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51157 }
51158 {
51159 arg2 = &temp2;
51160 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51161 }
51162 {
51163 arg3 = &temp3;
51164 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51165 }
51166 ecode4 = SWIG_AsVal_int(obj3, &val4);
51167 if (!SWIG_IsOK(ecode4)) {
51168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51169 }
51170 arg4 = static_cast< int >(val4);
51171 ecode5 = SWIG_AsVal_int(obj4, &val5);
51172 if (!SWIG_IsOK(ecode5)) {
51173 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51174 }
51175 arg5 = static_cast< int >(val5);
51176 if (obj5) {
51177 arg6 = obj5;
51178 }
51179 {
51180 PyThreadState* __tstate = wxPyBeginAllowThreads();
51181 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51182 wxPyEndAllowThreads(__tstate);
51183 if (PyErr_Occurred()) SWIG_fail;
51184 }
51185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51186 return resultobj;
51187 fail:
51188 return NULL;
51189 }
51190
51191
51192 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51193 PyObject *resultobj = 0;
51194 int arg1 ;
51195 int arg2 ;
51196 wxGBPosition *arg3 = 0 ;
51197 wxGBSpan *arg4 = 0 ;
51198 int arg5 ;
51199 int arg6 ;
51200 PyObject *arg7 = (PyObject *) NULL ;
51201 wxGBSizerItem *result = 0 ;
51202 int val1 ;
51203 int ecode1 = 0 ;
51204 int val2 ;
51205 int ecode2 = 0 ;
51206 wxGBPosition temp3 ;
51207 wxGBSpan temp4 ;
51208 int val5 ;
51209 int ecode5 = 0 ;
51210 int val6 ;
51211 int ecode6 = 0 ;
51212 PyObject * obj0 = 0 ;
51213 PyObject * obj1 = 0 ;
51214 PyObject * obj2 = 0 ;
51215 PyObject * obj3 = 0 ;
51216 PyObject * obj4 = 0 ;
51217 PyObject * obj5 = 0 ;
51218 PyObject * obj6 = 0 ;
51219 char * kwnames[] = {
51220 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51221 };
51222
51223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51224 ecode1 = SWIG_AsVal_int(obj0, &val1);
51225 if (!SWIG_IsOK(ecode1)) {
51226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51227 }
51228 arg1 = static_cast< int >(val1);
51229 ecode2 = SWIG_AsVal_int(obj1, &val2);
51230 if (!SWIG_IsOK(ecode2)) {
51231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51232 }
51233 arg2 = static_cast< int >(val2);
51234 {
51235 arg3 = &temp3;
51236 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51237 }
51238 {
51239 arg4 = &temp4;
51240 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51241 }
51242 ecode5 = SWIG_AsVal_int(obj4, &val5);
51243 if (!SWIG_IsOK(ecode5)) {
51244 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51245 }
51246 arg5 = static_cast< int >(val5);
51247 ecode6 = SWIG_AsVal_int(obj5, &val6);
51248 if (!SWIG_IsOK(ecode6)) {
51249 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51250 }
51251 arg6 = static_cast< int >(val6);
51252 if (obj6) {
51253 arg7 = obj6;
51254 }
51255 {
51256 PyThreadState* __tstate = wxPyBeginAllowThreads();
51257 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51258 wxPyEndAllowThreads(__tstate);
51259 if (PyErr_Occurred()) SWIG_fail;
51260 }
51261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51262 return resultobj;
51263 fail:
51264 return NULL;
51265 }
51266
51267
51268 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51269 PyObject *resultobj = 0;
51270 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51271 wxGBPosition result;
51272 void *argp1 = 0 ;
51273 int res1 = 0 ;
51274 PyObject *swig_obj[1] ;
51275
51276 if (!args) SWIG_fail;
51277 swig_obj[0] = args;
51278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51279 if (!SWIG_IsOK(res1)) {
51280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51281 }
51282 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51283 {
51284 PyThreadState* __tstate = wxPyBeginAllowThreads();
51285 result = ((wxGBSizerItem const *)arg1)->GetPos();
51286 wxPyEndAllowThreads(__tstate);
51287 if (PyErr_Occurred()) SWIG_fail;
51288 }
51289 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51290 return resultobj;
51291 fail:
51292 return NULL;
51293 }
51294
51295
51296 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51297 PyObject *resultobj = 0;
51298 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51299 wxGBSpan result;
51300 void *argp1 = 0 ;
51301 int res1 = 0 ;
51302 PyObject *swig_obj[1] ;
51303
51304 if (!args) SWIG_fail;
51305 swig_obj[0] = args;
51306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51307 if (!SWIG_IsOK(res1)) {
51308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51309 }
51310 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51311 {
51312 PyThreadState* __tstate = wxPyBeginAllowThreads();
51313 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51314 wxPyEndAllowThreads(__tstate);
51315 if (PyErr_Occurred()) SWIG_fail;
51316 }
51317 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51318 return resultobj;
51319 fail:
51320 return NULL;
51321 }
51322
51323
51324 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51325 PyObject *resultobj = 0;
51326 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51327 wxGBPosition *arg2 = 0 ;
51328 bool result;
51329 void *argp1 = 0 ;
51330 int res1 = 0 ;
51331 wxGBPosition temp2 ;
51332 PyObject * obj0 = 0 ;
51333 PyObject * obj1 = 0 ;
51334 char * kwnames[] = {
51335 (char *) "self",(char *) "pos", NULL
51336 };
51337
51338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51340 if (!SWIG_IsOK(res1)) {
51341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51342 }
51343 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51344 {
51345 arg2 = &temp2;
51346 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51347 }
51348 {
51349 PyThreadState* __tstate = wxPyBeginAllowThreads();
51350 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51351 wxPyEndAllowThreads(__tstate);
51352 if (PyErr_Occurred()) SWIG_fail;
51353 }
51354 {
51355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51356 }
51357 return resultobj;
51358 fail:
51359 return NULL;
51360 }
51361
51362
51363 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51364 PyObject *resultobj = 0;
51365 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51366 wxGBSpan *arg2 = 0 ;
51367 bool result;
51368 void *argp1 = 0 ;
51369 int res1 = 0 ;
51370 wxGBSpan temp2 ;
51371 PyObject * obj0 = 0 ;
51372 PyObject * obj1 = 0 ;
51373 char * kwnames[] = {
51374 (char *) "self",(char *) "span", NULL
51375 };
51376
51377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51379 if (!SWIG_IsOK(res1)) {
51380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51381 }
51382 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51383 {
51384 arg2 = &temp2;
51385 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51386 }
51387 {
51388 PyThreadState* __tstate = wxPyBeginAllowThreads();
51389 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51390 wxPyEndAllowThreads(__tstate);
51391 if (PyErr_Occurred()) SWIG_fail;
51392 }
51393 {
51394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51395 }
51396 return resultobj;
51397 fail:
51398 return NULL;
51399 }
51400
51401
51402 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51403 PyObject *resultobj = 0;
51404 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51405 wxGBSizerItem *arg2 = 0 ;
51406 bool result;
51407 void *argp1 = 0 ;
51408 int res1 = 0 ;
51409 void *argp2 = 0 ;
51410 int res2 = 0 ;
51411 PyObject * obj0 = 0 ;
51412 PyObject * obj1 = 0 ;
51413 char * kwnames[] = {
51414 (char *) "self",(char *) "other", NULL
51415 };
51416
51417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51419 if (!SWIG_IsOK(res1)) {
51420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51421 }
51422 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51423 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51424 if (!SWIG_IsOK(res2)) {
51425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51426 }
51427 if (!argp2) {
51428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51429 }
51430 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51431 {
51432 PyThreadState* __tstate = wxPyBeginAllowThreads();
51433 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51434 wxPyEndAllowThreads(__tstate);
51435 if (PyErr_Occurred()) SWIG_fail;
51436 }
51437 {
51438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51439 }
51440 return resultobj;
51441 fail:
51442 return NULL;
51443 }
51444
51445
51446 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51447 PyObject *resultobj = 0;
51448 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51449 wxGBPosition *arg2 = 0 ;
51450 wxGBSpan *arg3 = 0 ;
51451 bool result;
51452 void *argp1 = 0 ;
51453 int res1 = 0 ;
51454 wxGBPosition temp2 ;
51455 wxGBSpan temp3 ;
51456 PyObject * obj0 = 0 ;
51457 PyObject * obj1 = 0 ;
51458 PyObject * obj2 = 0 ;
51459 char * kwnames[] = {
51460 (char *) "self",(char *) "pos",(char *) "span", NULL
51461 };
51462
51463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51465 if (!SWIG_IsOK(res1)) {
51466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51467 }
51468 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51469 {
51470 arg2 = &temp2;
51471 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51472 }
51473 {
51474 arg3 = &temp3;
51475 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51476 }
51477 {
51478 PyThreadState* __tstate = wxPyBeginAllowThreads();
51479 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51480 wxPyEndAllowThreads(__tstate);
51481 if (PyErr_Occurred()) SWIG_fail;
51482 }
51483 {
51484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51485 }
51486 return resultobj;
51487 fail:
51488 return NULL;
51489 }
51490
51491
51492 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51493 PyObject *resultobj = 0;
51494 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51495 wxGBPosition result;
51496 void *argp1 = 0 ;
51497 int res1 = 0 ;
51498 PyObject *swig_obj[1] ;
51499
51500 if (!args) SWIG_fail;
51501 swig_obj[0] = args;
51502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51503 if (!SWIG_IsOK(res1)) {
51504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51505 }
51506 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51507 {
51508 PyThreadState* __tstate = wxPyBeginAllowThreads();
51509 result = wxGBSizerItem_GetEndPos(arg1);
51510 wxPyEndAllowThreads(__tstate);
51511 if (PyErr_Occurred()) SWIG_fail;
51512 }
51513 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51514 return resultobj;
51515 fail:
51516 return NULL;
51517 }
51518
51519
51520 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51521 PyObject *resultobj = 0;
51522 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51523 wxGridBagSizer *result = 0 ;
51524 void *argp1 = 0 ;
51525 int res1 = 0 ;
51526 PyObject *swig_obj[1] ;
51527
51528 if (!args) SWIG_fail;
51529 swig_obj[0] = args;
51530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51531 if (!SWIG_IsOK(res1)) {
51532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51533 }
51534 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51535 {
51536 PyThreadState* __tstate = wxPyBeginAllowThreads();
51537 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51538 wxPyEndAllowThreads(__tstate);
51539 if (PyErr_Occurred()) SWIG_fail;
51540 }
51541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51542 return resultobj;
51543 fail:
51544 return NULL;
51545 }
51546
51547
51548 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51549 PyObject *resultobj = 0;
51550 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51551 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51552 void *argp1 = 0 ;
51553 int res1 = 0 ;
51554 void *argp2 = 0 ;
51555 int res2 = 0 ;
51556 PyObject * obj0 = 0 ;
51557 PyObject * obj1 = 0 ;
51558 char * kwnames[] = {
51559 (char *) "self",(char *) "sizer", NULL
51560 };
51561
51562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51564 if (!SWIG_IsOK(res1)) {
51565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51566 }
51567 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51568 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51569 if (!SWIG_IsOK(res2)) {
51570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51571 }
51572 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51573 {
51574 PyThreadState* __tstate = wxPyBeginAllowThreads();
51575 (arg1)->SetGBSizer(arg2);
51576 wxPyEndAllowThreads(__tstate);
51577 if (PyErr_Occurred()) SWIG_fail;
51578 }
51579 resultobj = SWIG_Py_Void();
51580 return resultobj;
51581 fail:
51582 return NULL;
51583 }
51584
51585
51586 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51587 PyObject *obj;
51588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51589 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51590 return SWIG_Py_Void();
51591 }
51592
51593 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51594 return SWIG_Python_InitShadowInstance(args);
51595 }
51596
51597 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51598 PyObject *resultobj = 0;
51599 int arg1 = (int) 0 ;
51600 int arg2 = (int) 0 ;
51601 wxGridBagSizer *result = 0 ;
51602 int val1 ;
51603 int ecode1 = 0 ;
51604 int val2 ;
51605 int ecode2 = 0 ;
51606 PyObject * obj0 = 0 ;
51607 PyObject * obj1 = 0 ;
51608 char * kwnames[] = {
51609 (char *) "vgap",(char *) "hgap", NULL
51610 };
51611
51612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51613 if (obj0) {
51614 ecode1 = SWIG_AsVal_int(obj0, &val1);
51615 if (!SWIG_IsOK(ecode1)) {
51616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51617 }
51618 arg1 = static_cast< int >(val1);
51619 }
51620 if (obj1) {
51621 ecode2 = SWIG_AsVal_int(obj1, &val2);
51622 if (!SWIG_IsOK(ecode2)) {
51623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51624 }
51625 arg2 = static_cast< int >(val2);
51626 }
51627 {
51628 PyThreadState* __tstate = wxPyBeginAllowThreads();
51629 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51630 wxPyEndAllowThreads(__tstate);
51631 if (PyErr_Occurred()) SWIG_fail;
51632 }
51633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51634 return resultobj;
51635 fail:
51636 return NULL;
51637 }
51638
51639
51640 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51641 PyObject *resultobj = 0;
51642 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51643 PyObject *arg2 = (PyObject *) 0 ;
51644 wxGBPosition *arg3 = 0 ;
51645 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51646 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51647 int arg5 = (int) 0 ;
51648 int arg6 = (int) 0 ;
51649 PyObject *arg7 = (PyObject *) NULL ;
51650 wxGBSizerItem *result = 0 ;
51651 void *argp1 = 0 ;
51652 int res1 = 0 ;
51653 wxGBPosition temp3 ;
51654 wxGBSpan temp4 ;
51655 int val5 ;
51656 int ecode5 = 0 ;
51657 int val6 ;
51658 int ecode6 = 0 ;
51659 PyObject * obj0 = 0 ;
51660 PyObject * obj1 = 0 ;
51661 PyObject * obj2 = 0 ;
51662 PyObject * obj3 = 0 ;
51663 PyObject * obj4 = 0 ;
51664 PyObject * obj5 = 0 ;
51665 PyObject * obj6 = 0 ;
51666 char * kwnames[] = {
51667 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51668 };
51669
51670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51672 if (!SWIG_IsOK(res1)) {
51673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51674 }
51675 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51676 arg2 = obj1;
51677 {
51678 arg3 = &temp3;
51679 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51680 }
51681 if (obj3) {
51682 {
51683 arg4 = &temp4;
51684 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51685 }
51686 }
51687 if (obj4) {
51688 ecode5 = SWIG_AsVal_int(obj4, &val5);
51689 if (!SWIG_IsOK(ecode5)) {
51690 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51691 }
51692 arg5 = static_cast< int >(val5);
51693 }
51694 if (obj5) {
51695 ecode6 = SWIG_AsVal_int(obj5, &val6);
51696 if (!SWIG_IsOK(ecode6)) {
51697 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51698 }
51699 arg6 = static_cast< int >(val6);
51700 }
51701 if (obj6) {
51702 arg7 = obj6;
51703 }
51704 {
51705 PyThreadState* __tstate = wxPyBeginAllowThreads();
51706 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51707 wxPyEndAllowThreads(__tstate);
51708 if (PyErr_Occurred()) SWIG_fail;
51709 }
51710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51711 return resultobj;
51712 fail:
51713 return NULL;
51714 }
51715
51716
51717 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51718 PyObject *resultobj = 0;
51719 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51720 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51721 wxGBSizerItem *result = 0 ;
51722 void *argp1 = 0 ;
51723 int res1 = 0 ;
51724 int res2 = 0 ;
51725 PyObject * obj0 = 0 ;
51726 PyObject * obj1 = 0 ;
51727 char * kwnames[] = {
51728 (char *) "self",(char *) "item", NULL
51729 };
51730
51731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51733 if (!SWIG_IsOK(res1)) {
51734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51735 }
51736 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51737 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51738 if (!SWIG_IsOK(res2)) {
51739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51740 }
51741 {
51742 PyThreadState* __tstate = wxPyBeginAllowThreads();
51743 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51744 wxPyEndAllowThreads(__tstate);
51745 if (PyErr_Occurred()) SWIG_fail;
51746 }
51747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51748 return resultobj;
51749 fail:
51750 return NULL;
51751 }
51752
51753
51754 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51755 PyObject *resultobj = 0;
51756 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51757 int arg2 ;
51758 int arg3 ;
51759 wxSize result;
51760 void *argp1 = 0 ;
51761 int res1 = 0 ;
51762 int val2 ;
51763 int ecode2 = 0 ;
51764 int val3 ;
51765 int ecode3 = 0 ;
51766 PyObject * obj0 = 0 ;
51767 PyObject * obj1 = 0 ;
51768 PyObject * obj2 = 0 ;
51769 char * kwnames[] = {
51770 (char *) "self",(char *) "row",(char *) "col", NULL
51771 };
51772
51773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51775 if (!SWIG_IsOK(res1)) {
51776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51777 }
51778 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51779 ecode2 = SWIG_AsVal_int(obj1, &val2);
51780 if (!SWIG_IsOK(ecode2)) {
51781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51782 }
51783 arg2 = static_cast< int >(val2);
51784 ecode3 = SWIG_AsVal_int(obj2, &val3);
51785 if (!SWIG_IsOK(ecode3)) {
51786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51787 }
51788 arg3 = static_cast< int >(val3);
51789 {
51790 PyThreadState* __tstate = wxPyBeginAllowThreads();
51791 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51792 wxPyEndAllowThreads(__tstate);
51793 if (PyErr_Occurred()) SWIG_fail;
51794 }
51795 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51796 return resultobj;
51797 fail:
51798 return NULL;
51799 }
51800
51801
51802 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51803 PyObject *resultobj = 0;
51804 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51805 wxSize result;
51806 void *argp1 = 0 ;
51807 int res1 = 0 ;
51808 PyObject *swig_obj[1] ;
51809
51810 if (!args) SWIG_fail;
51811 swig_obj[0] = args;
51812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51813 if (!SWIG_IsOK(res1)) {
51814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51815 }
51816 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51817 {
51818 PyThreadState* __tstate = wxPyBeginAllowThreads();
51819 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51820 wxPyEndAllowThreads(__tstate);
51821 if (PyErr_Occurred()) SWIG_fail;
51822 }
51823 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51824 return resultobj;
51825 fail:
51826 return NULL;
51827 }
51828
51829
51830 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51831 PyObject *resultobj = 0;
51832 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51833 wxSize *arg2 = 0 ;
51834 void *argp1 = 0 ;
51835 int res1 = 0 ;
51836 wxSize temp2 ;
51837 PyObject * obj0 = 0 ;
51838 PyObject * obj1 = 0 ;
51839 char * kwnames[] = {
51840 (char *) "self",(char *) "sz", NULL
51841 };
51842
51843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51845 if (!SWIG_IsOK(res1)) {
51846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51847 }
51848 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51849 {
51850 arg2 = &temp2;
51851 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51852 }
51853 {
51854 PyThreadState* __tstate = wxPyBeginAllowThreads();
51855 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51856 wxPyEndAllowThreads(__tstate);
51857 if (PyErr_Occurred()) SWIG_fail;
51858 }
51859 resultobj = SWIG_Py_Void();
51860 return resultobj;
51861 fail:
51862 return NULL;
51863 }
51864
51865
51866 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51867 PyObject *resultobj = 0;
51868 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51869 wxWindow *arg2 = (wxWindow *) 0 ;
51870 wxGBPosition result;
51871 void *argp1 = 0 ;
51872 int res1 = 0 ;
51873 void *argp2 = 0 ;
51874 int res2 = 0 ;
51875
51876 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51878 if (!SWIG_IsOK(res1)) {
51879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51880 }
51881 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51882 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51883 if (!SWIG_IsOK(res2)) {
51884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51885 }
51886 arg2 = reinterpret_cast< wxWindow * >(argp2);
51887 {
51888 PyThreadState* __tstate = wxPyBeginAllowThreads();
51889 result = (arg1)->GetItemPosition(arg2);
51890 wxPyEndAllowThreads(__tstate);
51891 if (PyErr_Occurred()) SWIG_fail;
51892 }
51893 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51894 return resultobj;
51895 fail:
51896 return NULL;
51897 }
51898
51899
51900 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51901 PyObject *resultobj = 0;
51902 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51903 wxSizer *arg2 = (wxSizer *) 0 ;
51904 wxGBPosition result;
51905 void *argp1 = 0 ;
51906 int res1 = 0 ;
51907 void *argp2 = 0 ;
51908 int res2 = 0 ;
51909
51910 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51912 if (!SWIG_IsOK(res1)) {
51913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51914 }
51915 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51916 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51917 if (!SWIG_IsOK(res2)) {
51918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51919 }
51920 arg2 = reinterpret_cast< wxSizer * >(argp2);
51921 {
51922 PyThreadState* __tstate = wxPyBeginAllowThreads();
51923 result = (arg1)->GetItemPosition(arg2);
51924 wxPyEndAllowThreads(__tstate);
51925 if (PyErr_Occurred()) SWIG_fail;
51926 }
51927 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51928 return resultobj;
51929 fail:
51930 return NULL;
51931 }
51932
51933
51934 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51935 PyObject *resultobj = 0;
51936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51937 size_t arg2 ;
51938 wxGBPosition result;
51939 void *argp1 = 0 ;
51940 int res1 = 0 ;
51941 size_t val2 ;
51942 int ecode2 = 0 ;
51943
51944 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51946 if (!SWIG_IsOK(res1)) {
51947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51948 }
51949 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51950 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51951 if (!SWIG_IsOK(ecode2)) {
51952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51953 }
51954 arg2 = static_cast< size_t >(val2);
51955 {
51956 PyThreadState* __tstate = wxPyBeginAllowThreads();
51957 result = (arg1)->GetItemPosition(arg2);
51958 wxPyEndAllowThreads(__tstate);
51959 if (PyErr_Occurred()) SWIG_fail;
51960 }
51961 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51962 return resultobj;
51963 fail:
51964 return NULL;
51965 }
51966
51967
51968 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51969 int argc;
51970 PyObject *argv[3];
51971
51972 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51973 --argc;
51974 if (argc == 2) {
51975 int _v = 0;
51976 {
51977 void *vptr = 0;
51978 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51979 _v = SWIG_CheckState(res);
51980 }
51981 if (!_v) goto check_1;
51982 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51983 }
51984 check_1:
51985
51986 if (argc == 2) {
51987 int _v = 0;
51988 {
51989 void *vptr = 0;
51990 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51991 _v = SWIG_CheckState(res);
51992 }
51993 if (!_v) goto check_2;
51994 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51995 }
51996 check_2:
51997
51998 if (argc == 2) {
51999 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52000 }
52001
52002 fail:
52003 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52004 return NULL;
52005 }
52006
52007
52008 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52009 PyObject *resultobj = 0;
52010 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52011 wxWindow *arg2 = (wxWindow *) 0 ;
52012 wxGBPosition *arg3 = 0 ;
52013 bool result;
52014 void *argp1 = 0 ;
52015 int res1 = 0 ;
52016 void *argp2 = 0 ;
52017 int res2 = 0 ;
52018 wxGBPosition temp3 ;
52019
52020 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52022 if (!SWIG_IsOK(res1)) {
52023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52024 }
52025 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52026 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52027 if (!SWIG_IsOK(res2)) {
52028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52029 }
52030 arg2 = reinterpret_cast< wxWindow * >(argp2);
52031 {
52032 arg3 = &temp3;
52033 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52034 }
52035 {
52036 PyThreadState* __tstate = wxPyBeginAllowThreads();
52037 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52038 wxPyEndAllowThreads(__tstate);
52039 if (PyErr_Occurred()) SWIG_fail;
52040 }
52041 {
52042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52043 }
52044 return resultobj;
52045 fail:
52046 return NULL;
52047 }
52048
52049
52050 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52051 PyObject *resultobj = 0;
52052 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52053 wxSizer *arg2 = (wxSizer *) 0 ;
52054 wxGBPosition *arg3 = 0 ;
52055 bool result;
52056 void *argp1 = 0 ;
52057 int res1 = 0 ;
52058 void *argp2 = 0 ;
52059 int res2 = 0 ;
52060 wxGBPosition temp3 ;
52061
52062 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52064 if (!SWIG_IsOK(res1)) {
52065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52066 }
52067 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52068 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52069 if (!SWIG_IsOK(res2)) {
52070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52071 }
52072 arg2 = reinterpret_cast< wxSizer * >(argp2);
52073 {
52074 arg3 = &temp3;
52075 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52076 }
52077 {
52078 PyThreadState* __tstate = wxPyBeginAllowThreads();
52079 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52080 wxPyEndAllowThreads(__tstate);
52081 if (PyErr_Occurred()) SWIG_fail;
52082 }
52083 {
52084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52085 }
52086 return resultobj;
52087 fail:
52088 return NULL;
52089 }
52090
52091
52092 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52093 PyObject *resultobj = 0;
52094 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52095 size_t arg2 ;
52096 wxGBPosition *arg3 = 0 ;
52097 bool result;
52098 void *argp1 = 0 ;
52099 int res1 = 0 ;
52100 size_t val2 ;
52101 int ecode2 = 0 ;
52102 wxGBPosition temp3 ;
52103
52104 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52106 if (!SWIG_IsOK(res1)) {
52107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52108 }
52109 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52110 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52111 if (!SWIG_IsOK(ecode2)) {
52112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52113 }
52114 arg2 = static_cast< size_t >(val2);
52115 {
52116 arg3 = &temp3;
52117 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52118 }
52119 {
52120 PyThreadState* __tstate = wxPyBeginAllowThreads();
52121 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52122 wxPyEndAllowThreads(__tstate);
52123 if (PyErr_Occurred()) SWIG_fail;
52124 }
52125 {
52126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52127 }
52128 return resultobj;
52129 fail:
52130 return NULL;
52131 }
52132
52133
52134 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52135 int argc;
52136 PyObject *argv[4];
52137
52138 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52139 --argc;
52140 if (argc == 3) {
52141 int _v = 0;
52142 {
52143 void *vptr = 0;
52144 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52145 _v = SWIG_CheckState(res);
52146 }
52147 if (!_v) goto check_1;
52148 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52149 }
52150 check_1:
52151
52152 if (argc == 3) {
52153 int _v = 0;
52154 {
52155 void *vptr = 0;
52156 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52157 _v = SWIG_CheckState(res);
52158 }
52159 if (!_v) goto check_2;
52160 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52161 }
52162 check_2:
52163
52164 if (argc == 3) {
52165 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52166 }
52167
52168 fail:
52169 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52170 return NULL;
52171 }
52172
52173
52174 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52175 PyObject *resultobj = 0;
52176 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52177 wxWindow *arg2 = (wxWindow *) 0 ;
52178 wxGBSpan result;
52179 void *argp1 = 0 ;
52180 int res1 = 0 ;
52181 void *argp2 = 0 ;
52182 int res2 = 0 ;
52183
52184 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52186 if (!SWIG_IsOK(res1)) {
52187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52188 }
52189 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52190 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52191 if (!SWIG_IsOK(res2)) {
52192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52193 }
52194 arg2 = reinterpret_cast< wxWindow * >(argp2);
52195 {
52196 PyThreadState* __tstate = wxPyBeginAllowThreads();
52197 result = (arg1)->GetItemSpan(arg2);
52198 wxPyEndAllowThreads(__tstate);
52199 if (PyErr_Occurred()) SWIG_fail;
52200 }
52201 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52202 return resultobj;
52203 fail:
52204 return NULL;
52205 }
52206
52207
52208 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52209 PyObject *resultobj = 0;
52210 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52211 wxSizer *arg2 = (wxSizer *) 0 ;
52212 wxGBSpan result;
52213 void *argp1 = 0 ;
52214 int res1 = 0 ;
52215 void *argp2 = 0 ;
52216 int res2 = 0 ;
52217
52218 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52220 if (!SWIG_IsOK(res1)) {
52221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52222 }
52223 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52224 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52225 if (!SWIG_IsOK(res2)) {
52226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52227 }
52228 arg2 = reinterpret_cast< wxSizer * >(argp2);
52229 {
52230 PyThreadState* __tstate = wxPyBeginAllowThreads();
52231 result = (arg1)->GetItemSpan(arg2);
52232 wxPyEndAllowThreads(__tstate);
52233 if (PyErr_Occurred()) SWIG_fail;
52234 }
52235 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52236 return resultobj;
52237 fail:
52238 return NULL;
52239 }
52240
52241
52242 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52243 PyObject *resultobj = 0;
52244 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52245 size_t arg2 ;
52246 wxGBSpan result;
52247 void *argp1 = 0 ;
52248 int res1 = 0 ;
52249 size_t val2 ;
52250 int ecode2 = 0 ;
52251
52252 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52254 if (!SWIG_IsOK(res1)) {
52255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52256 }
52257 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52258 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52259 if (!SWIG_IsOK(ecode2)) {
52260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52261 }
52262 arg2 = static_cast< size_t >(val2);
52263 {
52264 PyThreadState* __tstate = wxPyBeginAllowThreads();
52265 result = (arg1)->GetItemSpan(arg2);
52266 wxPyEndAllowThreads(__tstate);
52267 if (PyErr_Occurred()) SWIG_fail;
52268 }
52269 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52270 return resultobj;
52271 fail:
52272 return NULL;
52273 }
52274
52275
52276 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52277 int argc;
52278 PyObject *argv[3];
52279
52280 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52281 --argc;
52282 if (argc == 2) {
52283 int _v = 0;
52284 {
52285 void *vptr = 0;
52286 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52287 _v = SWIG_CheckState(res);
52288 }
52289 if (!_v) goto check_1;
52290 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52291 }
52292 check_1:
52293
52294 if (argc == 2) {
52295 int _v = 0;
52296 {
52297 void *vptr = 0;
52298 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52299 _v = SWIG_CheckState(res);
52300 }
52301 if (!_v) goto check_2;
52302 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52303 }
52304 check_2:
52305
52306 if (argc == 2) {
52307 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52308 }
52309
52310 fail:
52311 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52312 return NULL;
52313 }
52314
52315
52316 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52317 PyObject *resultobj = 0;
52318 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52319 wxWindow *arg2 = (wxWindow *) 0 ;
52320 wxGBSpan *arg3 = 0 ;
52321 bool result;
52322 void *argp1 = 0 ;
52323 int res1 = 0 ;
52324 void *argp2 = 0 ;
52325 int res2 = 0 ;
52326 wxGBSpan temp3 ;
52327
52328 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52330 if (!SWIG_IsOK(res1)) {
52331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52332 }
52333 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52334 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52335 if (!SWIG_IsOK(res2)) {
52336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52337 }
52338 arg2 = reinterpret_cast< wxWindow * >(argp2);
52339 {
52340 arg3 = &temp3;
52341 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52342 }
52343 {
52344 PyThreadState* __tstate = wxPyBeginAllowThreads();
52345 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52346 wxPyEndAllowThreads(__tstate);
52347 if (PyErr_Occurred()) SWIG_fail;
52348 }
52349 {
52350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52351 }
52352 return resultobj;
52353 fail:
52354 return NULL;
52355 }
52356
52357
52358 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52359 PyObject *resultobj = 0;
52360 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52361 wxSizer *arg2 = (wxSizer *) 0 ;
52362 wxGBSpan *arg3 = 0 ;
52363 bool result;
52364 void *argp1 = 0 ;
52365 int res1 = 0 ;
52366 void *argp2 = 0 ;
52367 int res2 = 0 ;
52368 wxGBSpan temp3 ;
52369
52370 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52372 if (!SWIG_IsOK(res1)) {
52373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52374 }
52375 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52376 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52377 if (!SWIG_IsOK(res2)) {
52378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52379 }
52380 arg2 = reinterpret_cast< wxSizer * >(argp2);
52381 {
52382 arg3 = &temp3;
52383 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52384 }
52385 {
52386 PyThreadState* __tstate = wxPyBeginAllowThreads();
52387 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52388 wxPyEndAllowThreads(__tstate);
52389 if (PyErr_Occurred()) SWIG_fail;
52390 }
52391 {
52392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52393 }
52394 return resultobj;
52395 fail:
52396 return NULL;
52397 }
52398
52399
52400 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52401 PyObject *resultobj = 0;
52402 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52403 size_t arg2 ;
52404 wxGBSpan *arg3 = 0 ;
52405 bool result;
52406 void *argp1 = 0 ;
52407 int res1 = 0 ;
52408 size_t val2 ;
52409 int ecode2 = 0 ;
52410 wxGBSpan temp3 ;
52411
52412 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52414 if (!SWIG_IsOK(res1)) {
52415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52416 }
52417 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52418 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52419 if (!SWIG_IsOK(ecode2)) {
52420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52421 }
52422 arg2 = static_cast< size_t >(val2);
52423 {
52424 arg3 = &temp3;
52425 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52426 }
52427 {
52428 PyThreadState* __tstate = wxPyBeginAllowThreads();
52429 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*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_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52443 int argc;
52444 PyObject *argv[4];
52445
52446 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52447 --argc;
52448 if (argc == 3) {
52449 int _v = 0;
52450 {
52451 void *vptr = 0;
52452 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52453 _v = SWIG_CheckState(res);
52454 }
52455 if (!_v) goto check_1;
52456 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52457 }
52458 check_1:
52459
52460 if (argc == 3) {
52461 int _v = 0;
52462 {
52463 void *vptr = 0;
52464 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52465 _v = SWIG_CheckState(res);
52466 }
52467 if (!_v) goto check_2;
52468 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52469 }
52470 check_2:
52471
52472 if (argc == 3) {
52473 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52474 }
52475
52476 fail:
52477 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52478 return NULL;
52479 }
52480
52481
52482 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52483 PyObject *resultobj = 0;
52484 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52485 wxWindow *arg2 = (wxWindow *) 0 ;
52486 wxGBSizerItem *result = 0 ;
52487 void *argp1 = 0 ;
52488 int res1 = 0 ;
52489 void *argp2 = 0 ;
52490 int res2 = 0 ;
52491
52492 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52494 if (!SWIG_IsOK(res1)) {
52495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52496 }
52497 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52498 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52499 if (!SWIG_IsOK(res2)) {
52500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52501 }
52502 arg2 = reinterpret_cast< wxWindow * >(argp2);
52503 {
52504 PyThreadState* __tstate = wxPyBeginAllowThreads();
52505 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52506 wxPyEndAllowThreads(__tstate);
52507 if (PyErr_Occurred()) SWIG_fail;
52508 }
52509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52510 return resultobj;
52511 fail:
52512 return NULL;
52513 }
52514
52515
52516 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52517 PyObject *resultobj = 0;
52518 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52519 wxSizer *arg2 = (wxSizer *) 0 ;
52520 wxGBSizerItem *result = 0 ;
52521 void *argp1 = 0 ;
52522 int res1 = 0 ;
52523 void *argp2 = 0 ;
52524 int res2 = 0 ;
52525
52526 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52528 if (!SWIG_IsOK(res1)) {
52529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52530 }
52531 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52532 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52533 if (!SWIG_IsOK(res2)) {
52534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52535 }
52536 arg2 = reinterpret_cast< wxSizer * >(argp2);
52537 {
52538 PyThreadState* __tstate = wxPyBeginAllowThreads();
52539 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52540 wxPyEndAllowThreads(__tstate);
52541 if (PyErr_Occurred()) SWIG_fail;
52542 }
52543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52544 return resultobj;
52545 fail:
52546 return NULL;
52547 }
52548
52549
52550 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52551 int argc;
52552 PyObject *argv[3];
52553
52554 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52555 --argc;
52556 if (argc == 2) {
52557 int _v = 0;
52558 {
52559 void *vptr = 0;
52560 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52561 _v = SWIG_CheckState(res);
52562 }
52563 if (!_v) goto check_1;
52564 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52565 }
52566 check_1:
52567
52568 if (argc == 2) {
52569 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52570 }
52571
52572 fail:
52573 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52574 return NULL;
52575 }
52576
52577
52578 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52579 PyObject *resultobj = 0;
52580 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52581 wxGBPosition *arg2 = 0 ;
52582 wxGBSizerItem *result = 0 ;
52583 void *argp1 = 0 ;
52584 int res1 = 0 ;
52585 wxGBPosition temp2 ;
52586 PyObject * obj0 = 0 ;
52587 PyObject * obj1 = 0 ;
52588 char * kwnames[] = {
52589 (char *) "self",(char *) "pos", NULL
52590 };
52591
52592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52594 if (!SWIG_IsOK(res1)) {
52595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52596 }
52597 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52598 {
52599 arg2 = &temp2;
52600 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52601 }
52602 {
52603 PyThreadState* __tstate = wxPyBeginAllowThreads();
52604 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52605 wxPyEndAllowThreads(__tstate);
52606 if (PyErr_Occurred()) SWIG_fail;
52607 }
52608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52609 return resultobj;
52610 fail:
52611 return NULL;
52612 }
52613
52614
52615 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52616 PyObject *resultobj = 0;
52617 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52618 wxPoint *arg2 = 0 ;
52619 wxGBSizerItem *result = 0 ;
52620 void *argp1 = 0 ;
52621 int res1 = 0 ;
52622 wxPoint temp2 ;
52623 PyObject * obj0 = 0 ;
52624 PyObject * obj1 = 0 ;
52625 char * kwnames[] = {
52626 (char *) "self",(char *) "pt", NULL
52627 };
52628
52629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52631 if (!SWIG_IsOK(res1)) {
52632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52633 }
52634 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52635 {
52636 arg2 = &temp2;
52637 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52638 }
52639 {
52640 PyThreadState* __tstate = wxPyBeginAllowThreads();
52641 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52642 wxPyEndAllowThreads(__tstate);
52643 if (PyErr_Occurred()) SWIG_fail;
52644 }
52645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52646 return resultobj;
52647 fail:
52648 return NULL;
52649 }
52650
52651
52652 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52653 PyObject *resultobj = 0;
52654 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52655 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52656 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52657 bool result;
52658 void *argp1 = 0 ;
52659 int res1 = 0 ;
52660 void *argp2 = 0 ;
52661 int res2 = 0 ;
52662 void *argp3 = 0 ;
52663 int res3 = 0 ;
52664 PyObject * obj0 = 0 ;
52665 PyObject * obj1 = 0 ;
52666 PyObject * obj2 = 0 ;
52667 char * kwnames[] = {
52668 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52669 };
52670
52671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52673 if (!SWIG_IsOK(res1)) {
52674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52675 }
52676 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52678 if (!SWIG_IsOK(res2)) {
52679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52680 }
52681 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52682 if (obj2) {
52683 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52684 if (!SWIG_IsOK(res3)) {
52685 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52686 }
52687 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52688 }
52689 {
52690 PyThreadState* __tstate = wxPyBeginAllowThreads();
52691 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52692 wxPyEndAllowThreads(__tstate);
52693 if (PyErr_Occurred()) SWIG_fail;
52694 }
52695 {
52696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52697 }
52698 return resultobj;
52699 fail:
52700 return NULL;
52701 }
52702
52703
52704 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52705 PyObject *resultobj = 0;
52706 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52707 wxGBPosition *arg2 = 0 ;
52708 wxGBSpan *arg3 = 0 ;
52709 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52710 bool result;
52711 void *argp1 = 0 ;
52712 int res1 = 0 ;
52713 wxGBPosition temp2 ;
52714 wxGBSpan temp3 ;
52715 void *argp4 = 0 ;
52716 int res4 = 0 ;
52717 PyObject * obj0 = 0 ;
52718 PyObject * obj1 = 0 ;
52719 PyObject * obj2 = 0 ;
52720 PyObject * obj3 = 0 ;
52721 char * kwnames[] = {
52722 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52723 };
52724
52725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52727 if (!SWIG_IsOK(res1)) {
52728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52729 }
52730 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52731 {
52732 arg2 = &temp2;
52733 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52734 }
52735 {
52736 arg3 = &temp3;
52737 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52738 }
52739 if (obj3) {
52740 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52741 if (!SWIG_IsOK(res4)) {
52742 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52743 }
52744 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52745 }
52746 {
52747 PyThreadState* __tstate = wxPyBeginAllowThreads();
52748 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52749 wxPyEndAllowThreads(__tstate);
52750 if (PyErr_Occurred()) SWIG_fail;
52751 }
52752 {
52753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52754 }
52755 return resultobj;
52756 fail:
52757 return NULL;
52758 }
52759
52760
52761 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52762 PyObject *obj;
52763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52764 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52765 return SWIG_Py_Void();
52766 }
52767
52768 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52769 return SWIG_Python_InitShadowInstance(args);
52770 }
52771
52772 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52773 PyObject *resultobj = 0;
52774 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52775 wxRelationship arg2 ;
52776 wxWindow *arg3 = (wxWindow *) 0 ;
52777 wxEdge arg4 ;
52778 int arg5 = (int) 0 ;
52779 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52780 void *argp1 = 0 ;
52781 int res1 = 0 ;
52782 int val2 ;
52783 int ecode2 = 0 ;
52784 void *argp3 = 0 ;
52785 int res3 = 0 ;
52786 int val4 ;
52787 int ecode4 = 0 ;
52788 int val5 ;
52789 int ecode5 = 0 ;
52790 int val6 ;
52791 int ecode6 = 0 ;
52792 PyObject * obj0 = 0 ;
52793 PyObject * obj1 = 0 ;
52794 PyObject * obj2 = 0 ;
52795 PyObject * obj3 = 0 ;
52796 PyObject * obj4 = 0 ;
52797 PyObject * obj5 = 0 ;
52798 char * kwnames[] = {
52799 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52800 };
52801
52802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52804 if (!SWIG_IsOK(res1)) {
52805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52806 }
52807 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52808 ecode2 = SWIG_AsVal_int(obj1, &val2);
52809 if (!SWIG_IsOK(ecode2)) {
52810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52811 }
52812 arg2 = static_cast< wxRelationship >(val2);
52813 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52814 if (!SWIG_IsOK(res3)) {
52815 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52816 }
52817 arg3 = reinterpret_cast< wxWindow * >(argp3);
52818 ecode4 = SWIG_AsVal_int(obj3, &val4);
52819 if (!SWIG_IsOK(ecode4)) {
52820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52821 }
52822 arg4 = static_cast< wxEdge >(val4);
52823 if (obj4) {
52824 ecode5 = SWIG_AsVal_int(obj4, &val5);
52825 if (!SWIG_IsOK(ecode5)) {
52826 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52827 }
52828 arg5 = static_cast< int >(val5);
52829 }
52830 if (obj5) {
52831 ecode6 = SWIG_AsVal_int(obj5, &val6);
52832 if (!SWIG_IsOK(ecode6)) {
52833 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52834 }
52835 arg6 = static_cast< int >(val6);
52836 }
52837 {
52838 PyThreadState* __tstate = wxPyBeginAllowThreads();
52839 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52840 wxPyEndAllowThreads(__tstate);
52841 if (PyErr_Occurred()) SWIG_fail;
52842 }
52843 resultobj = SWIG_Py_Void();
52844 return resultobj;
52845 fail:
52846 return NULL;
52847 }
52848
52849
52850 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52851 PyObject *resultobj = 0;
52852 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52853 wxWindow *arg2 = (wxWindow *) 0 ;
52854 int arg3 = (int) 0 ;
52855 void *argp1 = 0 ;
52856 int res1 = 0 ;
52857 void *argp2 = 0 ;
52858 int res2 = 0 ;
52859 int val3 ;
52860 int ecode3 = 0 ;
52861 PyObject * obj0 = 0 ;
52862 PyObject * obj1 = 0 ;
52863 PyObject * obj2 = 0 ;
52864 char * kwnames[] = {
52865 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52866 };
52867
52868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52870 if (!SWIG_IsOK(res1)) {
52871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52872 }
52873 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52874 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52875 if (!SWIG_IsOK(res2)) {
52876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52877 }
52878 arg2 = reinterpret_cast< wxWindow * >(argp2);
52879 if (obj2) {
52880 ecode3 = SWIG_AsVal_int(obj2, &val3);
52881 if (!SWIG_IsOK(ecode3)) {
52882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52883 }
52884 arg3 = static_cast< int >(val3);
52885 }
52886 {
52887 PyThreadState* __tstate = wxPyBeginAllowThreads();
52888 (arg1)->LeftOf(arg2,arg3);
52889 wxPyEndAllowThreads(__tstate);
52890 if (PyErr_Occurred()) SWIG_fail;
52891 }
52892 resultobj = SWIG_Py_Void();
52893 return resultobj;
52894 fail:
52895 return NULL;
52896 }
52897
52898
52899 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52900 PyObject *resultobj = 0;
52901 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52902 wxWindow *arg2 = (wxWindow *) 0 ;
52903 int arg3 = (int) 0 ;
52904 void *argp1 = 0 ;
52905 int res1 = 0 ;
52906 void *argp2 = 0 ;
52907 int res2 = 0 ;
52908 int val3 ;
52909 int ecode3 = 0 ;
52910 PyObject * obj0 = 0 ;
52911 PyObject * obj1 = 0 ;
52912 PyObject * obj2 = 0 ;
52913 char * kwnames[] = {
52914 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52915 };
52916
52917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52919 if (!SWIG_IsOK(res1)) {
52920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52921 }
52922 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52923 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52924 if (!SWIG_IsOK(res2)) {
52925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52926 }
52927 arg2 = reinterpret_cast< wxWindow * >(argp2);
52928 if (obj2) {
52929 ecode3 = SWIG_AsVal_int(obj2, &val3);
52930 if (!SWIG_IsOK(ecode3)) {
52931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52932 }
52933 arg3 = static_cast< int >(val3);
52934 }
52935 {
52936 PyThreadState* __tstate = wxPyBeginAllowThreads();
52937 (arg1)->RightOf(arg2,arg3);
52938 wxPyEndAllowThreads(__tstate);
52939 if (PyErr_Occurred()) SWIG_fail;
52940 }
52941 resultobj = SWIG_Py_Void();
52942 return resultobj;
52943 fail:
52944 return NULL;
52945 }
52946
52947
52948 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52949 PyObject *resultobj = 0;
52950 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52951 wxWindow *arg2 = (wxWindow *) 0 ;
52952 int arg3 = (int) 0 ;
52953 void *argp1 = 0 ;
52954 int res1 = 0 ;
52955 void *argp2 = 0 ;
52956 int res2 = 0 ;
52957 int val3 ;
52958 int ecode3 = 0 ;
52959 PyObject * obj0 = 0 ;
52960 PyObject * obj1 = 0 ;
52961 PyObject * obj2 = 0 ;
52962 char * kwnames[] = {
52963 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52964 };
52965
52966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52968 if (!SWIG_IsOK(res1)) {
52969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52970 }
52971 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52973 if (!SWIG_IsOK(res2)) {
52974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52975 }
52976 arg2 = reinterpret_cast< wxWindow * >(argp2);
52977 if (obj2) {
52978 ecode3 = SWIG_AsVal_int(obj2, &val3);
52979 if (!SWIG_IsOK(ecode3)) {
52980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52981 }
52982 arg3 = static_cast< int >(val3);
52983 }
52984 {
52985 PyThreadState* __tstate = wxPyBeginAllowThreads();
52986 (arg1)->Above(arg2,arg3);
52987 wxPyEndAllowThreads(__tstate);
52988 if (PyErr_Occurred()) SWIG_fail;
52989 }
52990 resultobj = SWIG_Py_Void();
52991 return resultobj;
52992 fail:
52993 return NULL;
52994 }
52995
52996
52997 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52998 PyObject *resultobj = 0;
52999 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53000 wxWindow *arg2 = (wxWindow *) 0 ;
53001 int arg3 = (int) 0 ;
53002 void *argp1 = 0 ;
53003 int res1 = 0 ;
53004 void *argp2 = 0 ;
53005 int res2 = 0 ;
53006 int val3 ;
53007 int ecode3 = 0 ;
53008 PyObject * obj0 = 0 ;
53009 PyObject * obj1 = 0 ;
53010 PyObject * obj2 = 0 ;
53011 char * kwnames[] = {
53012 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53013 };
53014
53015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53017 if (!SWIG_IsOK(res1)) {
53018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53019 }
53020 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53021 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53022 if (!SWIG_IsOK(res2)) {
53023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53024 }
53025 arg2 = reinterpret_cast< wxWindow * >(argp2);
53026 if (obj2) {
53027 ecode3 = SWIG_AsVal_int(obj2, &val3);
53028 if (!SWIG_IsOK(ecode3)) {
53029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53030 }
53031 arg3 = static_cast< int >(val3);
53032 }
53033 {
53034 PyThreadState* __tstate = wxPyBeginAllowThreads();
53035 (arg1)->Below(arg2,arg3);
53036 wxPyEndAllowThreads(__tstate);
53037 if (PyErr_Occurred()) SWIG_fail;
53038 }
53039 resultobj = SWIG_Py_Void();
53040 return resultobj;
53041 fail:
53042 return NULL;
53043 }
53044
53045
53046 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53047 PyObject *resultobj = 0;
53048 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53049 wxWindow *arg2 = (wxWindow *) 0 ;
53050 wxEdge arg3 ;
53051 int arg4 = (int) 0 ;
53052 void *argp1 = 0 ;
53053 int res1 = 0 ;
53054 void *argp2 = 0 ;
53055 int res2 = 0 ;
53056 int val3 ;
53057 int ecode3 = 0 ;
53058 int val4 ;
53059 int ecode4 = 0 ;
53060 PyObject * obj0 = 0 ;
53061 PyObject * obj1 = 0 ;
53062 PyObject * obj2 = 0 ;
53063 PyObject * obj3 = 0 ;
53064 char * kwnames[] = {
53065 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53066 };
53067
53068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53070 if (!SWIG_IsOK(res1)) {
53071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53072 }
53073 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53074 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53075 if (!SWIG_IsOK(res2)) {
53076 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53077 }
53078 arg2 = reinterpret_cast< wxWindow * >(argp2);
53079 ecode3 = SWIG_AsVal_int(obj2, &val3);
53080 if (!SWIG_IsOK(ecode3)) {
53081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53082 }
53083 arg3 = static_cast< wxEdge >(val3);
53084 if (obj3) {
53085 ecode4 = SWIG_AsVal_int(obj3, &val4);
53086 if (!SWIG_IsOK(ecode4)) {
53087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53088 }
53089 arg4 = static_cast< int >(val4);
53090 }
53091 {
53092 PyThreadState* __tstate = wxPyBeginAllowThreads();
53093 (arg1)->SameAs(arg2,arg3,arg4);
53094 wxPyEndAllowThreads(__tstate);
53095 if (PyErr_Occurred()) SWIG_fail;
53096 }
53097 resultobj = SWIG_Py_Void();
53098 return resultobj;
53099 fail:
53100 return NULL;
53101 }
53102
53103
53104 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53105 PyObject *resultobj = 0;
53106 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53107 wxWindow *arg2 = (wxWindow *) 0 ;
53108 wxEdge arg3 ;
53109 int arg4 ;
53110 void *argp1 = 0 ;
53111 int res1 = 0 ;
53112 void *argp2 = 0 ;
53113 int res2 = 0 ;
53114 int val3 ;
53115 int ecode3 = 0 ;
53116 int val4 ;
53117 int ecode4 = 0 ;
53118 PyObject * obj0 = 0 ;
53119 PyObject * obj1 = 0 ;
53120 PyObject * obj2 = 0 ;
53121 PyObject * obj3 = 0 ;
53122 char * kwnames[] = {
53123 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53124 };
53125
53126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53128 if (!SWIG_IsOK(res1)) {
53129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53130 }
53131 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53132 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53133 if (!SWIG_IsOK(res2)) {
53134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53135 }
53136 arg2 = reinterpret_cast< wxWindow * >(argp2);
53137 ecode3 = SWIG_AsVal_int(obj2, &val3);
53138 if (!SWIG_IsOK(ecode3)) {
53139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53140 }
53141 arg3 = static_cast< wxEdge >(val3);
53142 ecode4 = SWIG_AsVal_int(obj3, &val4);
53143 if (!SWIG_IsOK(ecode4)) {
53144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53145 }
53146 arg4 = static_cast< int >(val4);
53147 {
53148 PyThreadState* __tstate = wxPyBeginAllowThreads();
53149 (arg1)->PercentOf(arg2,arg3,arg4);
53150 wxPyEndAllowThreads(__tstate);
53151 if (PyErr_Occurred()) SWIG_fail;
53152 }
53153 resultobj = SWIG_Py_Void();
53154 return resultobj;
53155 fail:
53156 return NULL;
53157 }
53158
53159
53160 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53161 PyObject *resultobj = 0;
53162 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53163 int arg2 ;
53164 void *argp1 = 0 ;
53165 int res1 = 0 ;
53166 int val2 ;
53167 int ecode2 = 0 ;
53168 PyObject * obj0 = 0 ;
53169 PyObject * obj1 = 0 ;
53170 char * kwnames[] = {
53171 (char *) "self",(char *) "val", NULL
53172 };
53173
53174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53176 if (!SWIG_IsOK(res1)) {
53177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53178 }
53179 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53180 ecode2 = SWIG_AsVal_int(obj1, &val2);
53181 if (!SWIG_IsOK(ecode2)) {
53182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53183 }
53184 arg2 = static_cast< int >(val2);
53185 {
53186 PyThreadState* __tstate = wxPyBeginAllowThreads();
53187 (arg1)->Absolute(arg2);
53188 wxPyEndAllowThreads(__tstate);
53189 if (PyErr_Occurred()) SWIG_fail;
53190 }
53191 resultobj = SWIG_Py_Void();
53192 return resultobj;
53193 fail:
53194 return NULL;
53195 }
53196
53197
53198 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53199 PyObject *resultobj = 0;
53200 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53201 void *argp1 = 0 ;
53202 int res1 = 0 ;
53203 PyObject *swig_obj[1] ;
53204
53205 if (!args) SWIG_fail;
53206 swig_obj[0] = args;
53207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53208 if (!SWIG_IsOK(res1)) {
53209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53210 }
53211 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53212 {
53213 PyThreadState* __tstate = wxPyBeginAllowThreads();
53214 (arg1)->Unconstrained();
53215 wxPyEndAllowThreads(__tstate);
53216 if (PyErr_Occurred()) SWIG_fail;
53217 }
53218 resultobj = SWIG_Py_Void();
53219 return resultobj;
53220 fail:
53221 return NULL;
53222 }
53223
53224
53225 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53226 PyObject *resultobj = 0;
53227 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53228 void *argp1 = 0 ;
53229 int res1 = 0 ;
53230 PyObject *swig_obj[1] ;
53231
53232 if (!args) SWIG_fail;
53233 swig_obj[0] = args;
53234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53235 if (!SWIG_IsOK(res1)) {
53236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53237 }
53238 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53239 {
53240 PyThreadState* __tstate = wxPyBeginAllowThreads();
53241 (arg1)->AsIs();
53242 wxPyEndAllowThreads(__tstate);
53243 if (PyErr_Occurred()) SWIG_fail;
53244 }
53245 resultobj = SWIG_Py_Void();
53246 return resultobj;
53247 fail:
53248 return NULL;
53249 }
53250
53251
53252 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53253 PyObject *resultobj = 0;
53254 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53255 wxWindow *result = 0 ;
53256 void *argp1 = 0 ;
53257 int res1 = 0 ;
53258 PyObject *swig_obj[1] ;
53259
53260 if (!args) SWIG_fail;
53261 swig_obj[0] = args;
53262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53263 if (!SWIG_IsOK(res1)) {
53264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53265 }
53266 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53267 {
53268 PyThreadState* __tstate = wxPyBeginAllowThreads();
53269 result = (wxWindow *)(arg1)->GetOtherWindow();
53270 wxPyEndAllowThreads(__tstate);
53271 if (PyErr_Occurred()) SWIG_fail;
53272 }
53273 {
53274 resultobj = wxPyMake_wxObject(result, 0);
53275 }
53276 return resultobj;
53277 fail:
53278 return NULL;
53279 }
53280
53281
53282 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53283 PyObject *resultobj = 0;
53284 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53285 wxEdge result;
53286 void *argp1 = 0 ;
53287 int res1 = 0 ;
53288 PyObject *swig_obj[1] ;
53289
53290 if (!args) SWIG_fail;
53291 swig_obj[0] = args;
53292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53293 if (!SWIG_IsOK(res1)) {
53294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53295 }
53296 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53297 {
53298 PyThreadState* __tstate = wxPyBeginAllowThreads();
53299 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53300 wxPyEndAllowThreads(__tstate);
53301 if (PyErr_Occurred()) SWIG_fail;
53302 }
53303 resultobj = SWIG_From_int(static_cast< int >(result));
53304 return resultobj;
53305 fail:
53306 return NULL;
53307 }
53308
53309
53310 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53311 PyObject *resultobj = 0;
53312 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53313 wxEdge arg2 ;
53314 void *argp1 = 0 ;
53315 int res1 = 0 ;
53316 int val2 ;
53317 int ecode2 = 0 ;
53318 PyObject * obj0 = 0 ;
53319 PyObject * obj1 = 0 ;
53320 char * kwnames[] = {
53321 (char *) "self",(char *) "which", NULL
53322 };
53323
53324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53326 if (!SWIG_IsOK(res1)) {
53327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53328 }
53329 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53330 ecode2 = SWIG_AsVal_int(obj1, &val2);
53331 if (!SWIG_IsOK(ecode2)) {
53332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53333 }
53334 arg2 = static_cast< wxEdge >(val2);
53335 {
53336 PyThreadState* __tstate = wxPyBeginAllowThreads();
53337 (arg1)->SetEdge(arg2);
53338 wxPyEndAllowThreads(__tstate);
53339 if (PyErr_Occurred()) SWIG_fail;
53340 }
53341 resultobj = SWIG_Py_Void();
53342 return resultobj;
53343 fail:
53344 return NULL;
53345 }
53346
53347
53348 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53349 PyObject *resultobj = 0;
53350 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53351 int arg2 ;
53352 void *argp1 = 0 ;
53353 int res1 = 0 ;
53354 int val2 ;
53355 int ecode2 = 0 ;
53356 PyObject * obj0 = 0 ;
53357 PyObject * obj1 = 0 ;
53358 char * kwnames[] = {
53359 (char *) "self",(char *) "v", NULL
53360 };
53361
53362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53364 if (!SWIG_IsOK(res1)) {
53365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53366 }
53367 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53368 ecode2 = SWIG_AsVal_int(obj1, &val2);
53369 if (!SWIG_IsOK(ecode2)) {
53370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53371 }
53372 arg2 = static_cast< int >(val2);
53373 {
53374 PyThreadState* __tstate = wxPyBeginAllowThreads();
53375 (arg1)->SetValue(arg2);
53376 wxPyEndAllowThreads(__tstate);
53377 if (PyErr_Occurred()) SWIG_fail;
53378 }
53379 resultobj = SWIG_Py_Void();
53380 return resultobj;
53381 fail:
53382 return NULL;
53383 }
53384
53385
53386 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53387 PyObject *resultobj = 0;
53388 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53389 int result;
53390 void *argp1 = 0 ;
53391 int res1 = 0 ;
53392 PyObject *swig_obj[1] ;
53393
53394 if (!args) SWIG_fail;
53395 swig_obj[0] = args;
53396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53397 if (!SWIG_IsOK(res1)) {
53398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53399 }
53400 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53401 {
53402 PyThreadState* __tstate = wxPyBeginAllowThreads();
53403 result = (int)(arg1)->GetMargin();
53404 wxPyEndAllowThreads(__tstate);
53405 if (PyErr_Occurred()) SWIG_fail;
53406 }
53407 resultobj = SWIG_From_int(static_cast< int >(result));
53408 return resultobj;
53409 fail:
53410 return NULL;
53411 }
53412
53413
53414 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53415 PyObject *resultobj = 0;
53416 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53417 int arg2 ;
53418 void *argp1 = 0 ;
53419 int res1 = 0 ;
53420 int val2 ;
53421 int ecode2 = 0 ;
53422 PyObject * obj0 = 0 ;
53423 PyObject * obj1 = 0 ;
53424 char * kwnames[] = {
53425 (char *) "self",(char *) "m", NULL
53426 };
53427
53428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53430 if (!SWIG_IsOK(res1)) {
53431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53432 }
53433 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53434 ecode2 = SWIG_AsVal_int(obj1, &val2);
53435 if (!SWIG_IsOK(ecode2)) {
53436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53437 }
53438 arg2 = static_cast< int >(val2);
53439 {
53440 PyThreadState* __tstate = wxPyBeginAllowThreads();
53441 (arg1)->SetMargin(arg2);
53442 wxPyEndAllowThreads(__tstate);
53443 if (PyErr_Occurred()) SWIG_fail;
53444 }
53445 resultobj = SWIG_Py_Void();
53446 return resultobj;
53447 fail:
53448 return NULL;
53449 }
53450
53451
53452 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53453 PyObject *resultobj = 0;
53454 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53455 int result;
53456 void *argp1 = 0 ;
53457 int res1 = 0 ;
53458 PyObject *swig_obj[1] ;
53459
53460 if (!args) SWIG_fail;
53461 swig_obj[0] = args;
53462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53463 if (!SWIG_IsOK(res1)) {
53464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53465 }
53466 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53467 {
53468 PyThreadState* __tstate = wxPyBeginAllowThreads();
53469 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53470 wxPyEndAllowThreads(__tstate);
53471 if (PyErr_Occurred()) SWIG_fail;
53472 }
53473 resultobj = SWIG_From_int(static_cast< int >(result));
53474 return resultobj;
53475 fail:
53476 return NULL;
53477 }
53478
53479
53480 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53481 PyObject *resultobj = 0;
53482 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53483 int result;
53484 void *argp1 = 0 ;
53485 int res1 = 0 ;
53486 PyObject *swig_obj[1] ;
53487
53488 if (!args) SWIG_fail;
53489 swig_obj[0] = args;
53490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53491 if (!SWIG_IsOK(res1)) {
53492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53493 }
53494 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53495 {
53496 PyThreadState* __tstate = wxPyBeginAllowThreads();
53497 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53498 wxPyEndAllowThreads(__tstate);
53499 if (PyErr_Occurred()) SWIG_fail;
53500 }
53501 resultobj = SWIG_From_int(static_cast< int >(result));
53502 return resultobj;
53503 fail:
53504 return NULL;
53505 }
53506
53507
53508 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53509 PyObject *resultobj = 0;
53510 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53511 int result;
53512 void *argp1 = 0 ;
53513 int res1 = 0 ;
53514 PyObject *swig_obj[1] ;
53515
53516 if (!args) SWIG_fail;
53517 swig_obj[0] = args;
53518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53519 if (!SWIG_IsOK(res1)) {
53520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53521 }
53522 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53523 {
53524 PyThreadState* __tstate = wxPyBeginAllowThreads();
53525 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53526 wxPyEndAllowThreads(__tstate);
53527 if (PyErr_Occurred()) SWIG_fail;
53528 }
53529 resultobj = SWIG_From_int(static_cast< int >(result));
53530 return resultobj;
53531 fail:
53532 return NULL;
53533 }
53534
53535
53536 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53537 PyObject *resultobj = 0;
53538 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53539 bool result;
53540 void *argp1 = 0 ;
53541 int res1 = 0 ;
53542 PyObject *swig_obj[1] ;
53543
53544 if (!args) SWIG_fail;
53545 swig_obj[0] = args;
53546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53547 if (!SWIG_IsOK(res1)) {
53548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53549 }
53550 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53551 {
53552 PyThreadState* __tstate = wxPyBeginAllowThreads();
53553 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53554 wxPyEndAllowThreads(__tstate);
53555 if (PyErr_Occurred()) SWIG_fail;
53556 }
53557 {
53558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53559 }
53560 return resultobj;
53561 fail:
53562 return NULL;
53563 }
53564
53565
53566 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53567 PyObject *resultobj = 0;
53568 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53569 bool arg2 ;
53570 void *argp1 = 0 ;
53571 int res1 = 0 ;
53572 bool val2 ;
53573 int ecode2 = 0 ;
53574 PyObject * obj0 = 0 ;
53575 PyObject * obj1 = 0 ;
53576 char * kwnames[] = {
53577 (char *) "self",(char *) "d", NULL
53578 };
53579
53580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53582 if (!SWIG_IsOK(res1)) {
53583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53584 }
53585 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53586 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53587 if (!SWIG_IsOK(ecode2)) {
53588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53589 }
53590 arg2 = static_cast< bool >(val2);
53591 {
53592 PyThreadState* __tstate = wxPyBeginAllowThreads();
53593 (arg1)->SetDone(arg2);
53594 wxPyEndAllowThreads(__tstate);
53595 if (PyErr_Occurred()) SWIG_fail;
53596 }
53597 resultobj = SWIG_Py_Void();
53598 return resultobj;
53599 fail:
53600 return NULL;
53601 }
53602
53603
53604 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53605 PyObject *resultobj = 0;
53606 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53607 wxRelationship result;
53608 void *argp1 = 0 ;
53609 int res1 = 0 ;
53610 PyObject *swig_obj[1] ;
53611
53612 if (!args) SWIG_fail;
53613 swig_obj[0] = args;
53614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53615 if (!SWIG_IsOK(res1)) {
53616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53617 }
53618 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53619 {
53620 PyThreadState* __tstate = wxPyBeginAllowThreads();
53621 result = (wxRelationship)(arg1)->GetRelationship();
53622 wxPyEndAllowThreads(__tstate);
53623 if (PyErr_Occurred()) SWIG_fail;
53624 }
53625 resultobj = SWIG_From_int(static_cast< int >(result));
53626 return resultobj;
53627 fail:
53628 return NULL;
53629 }
53630
53631
53632 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53633 PyObject *resultobj = 0;
53634 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53635 wxRelationship arg2 ;
53636 void *argp1 = 0 ;
53637 int res1 = 0 ;
53638 int val2 ;
53639 int ecode2 = 0 ;
53640 PyObject * obj0 = 0 ;
53641 PyObject * obj1 = 0 ;
53642 char * kwnames[] = {
53643 (char *) "self",(char *) "r", NULL
53644 };
53645
53646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53648 if (!SWIG_IsOK(res1)) {
53649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53650 }
53651 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53652 ecode2 = SWIG_AsVal_int(obj1, &val2);
53653 if (!SWIG_IsOK(ecode2)) {
53654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53655 }
53656 arg2 = static_cast< wxRelationship >(val2);
53657 {
53658 PyThreadState* __tstate = wxPyBeginAllowThreads();
53659 (arg1)->SetRelationship(arg2);
53660 wxPyEndAllowThreads(__tstate);
53661 if (PyErr_Occurred()) SWIG_fail;
53662 }
53663 resultobj = SWIG_Py_Void();
53664 return resultobj;
53665 fail:
53666 return NULL;
53667 }
53668
53669
53670 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53671 PyObject *resultobj = 0;
53672 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53673 wxWindow *arg2 = (wxWindow *) 0 ;
53674 bool result;
53675 void *argp1 = 0 ;
53676 int res1 = 0 ;
53677 void *argp2 = 0 ;
53678 int res2 = 0 ;
53679 PyObject * obj0 = 0 ;
53680 PyObject * obj1 = 0 ;
53681 char * kwnames[] = {
53682 (char *) "self",(char *) "otherW", NULL
53683 };
53684
53685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53687 if (!SWIG_IsOK(res1)) {
53688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53689 }
53690 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53692 if (!SWIG_IsOK(res2)) {
53693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53694 }
53695 arg2 = reinterpret_cast< wxWindow * >(argp2);
53696 {
53697 PyThreadState* __tstate = wxPyBeginAllowThreads();
53698 result = (bool)(arg1)->ResetIfWin(arg2);
53699 wxPyEndAllowThreads(__tstate);
53700 if (PyErr_Occurred()) SWIG_fail;
53701 }
53702 {
53703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53704 }
53705 return resultobj;
53706 fail:
53707 return NULL;
53708 }
53709
53710
53711 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53712 PyObject *resultobj = 0;
53713 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53714 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53715 wxWindow *arg3 = (wxWindow *) 0 ;
53716 bool result;
53717 void *argp1 = 0 ;
53718 int res1 = 0 ;
53719 void *argp2 = 0 ;
53720 int res2 = 0 ;
53721 void *argp3 = 0 ;
53722 int res3 = 0 ;
53723 PyObject * obj0 = 0 ;
53724 PyObject * obj1 = 0 ;
53725 PyObject * obj2 = 0 ;
53726 char * kwnames[] = {
53727 (char *) "self",(char *) "constraints",(char *) "win", NULL
53728 };
53729
53730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53732 if (!SWIG_IsOK(res1)) {
53733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53734 }
53735 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53737 if (!SWIG_IsOK(res2)) {
53738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53739 }
53740 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53741 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53742 if (!SWIG_IsOK(res3)) {
53743 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53744 }
53745 arg3 = reinterpret_cast< wxWindow * >(argp3);
53746 {
53747 PyThreadState* __tstate = wxPyBeginAllowThreads();
53748 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53749 wxPyEndAllowThreads(__tstate);
53750 if (PyErr_Occurred()) SWIG_fail;
53751 }
53752 {
53753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53754 }
53755 return resultobj;
53756 fail:
53757 return NULL;
53758 }
53759
53760
53761 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53762 PyObject *resultobj = 0;
53763 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53764 wxEdge arg2 ;
53765 wxWindow *arg3 = (wxWindow *) 0 ;
53766 wxWindow *arg4 = (wxWindow *) 0 ;
53767 int result;
53768 void *argp1 = 0 ;
53769 int res1 = 0 ;
53770 int val2 ;
53771 int ecode2 = 0 ;
53772 void *argp3 = 0 ;
53773 int res3 = 0 ;
53774 void *argp4 = 0 ;
53775 int res4 = 0 ;
53776 PyObject * obj0 = 0 ;
53777 PyObject * obj1 = 0 ;
53778 PyObject * obj2 = 0 ;
53779 PyObject * obj3 = 0 ;
53780 char * kwnames[] = {
53781 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53782 };
53783
53784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53786 if (!SWIG_IsOK(res1)) {
53787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53788 }
53789 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53790 ecode2 = SWIG_AsVal_int(obj1, &val2);
53791 if (!SWIG_IsOK(ecode2)) {
53792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53793 }
53794 arg2 = static_cast< wxEdge >(val2);
53795 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53796 if (!SWIG_IsOK(res3)) {
53797 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53798 }
53799 arg3 = reinterpret_cast< wxWindow * >(argp3);
53800 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53801 if (!SWIG_IsOK(res4)) {
53802 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53803 }
53804 arg4 = reinterpret_cast< wxWindow * >(argp4);
53805 {
53806 PyThreadState* __tstate = wxPyBeginAllowThreads();
53807 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53808 wxPyEndAllowThreads(__tstate);
53809 if (PyErr_Occurred()) SWIG_fail;
53810 }
53811 resultobj = SWIG_From_int(static_cast< int >(result));
53812 return resultobj;
53813 fail:
53814 return NULL;
53815 }
53816
53817
53818 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53819 PyObject *obj;
53820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53821 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53822 return SWIG_Py_Void();
53823 }
53824
53825 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53826 PyObject *resultobj = 0;
53827 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53828 wxIndividualLayoutConstraint *result = 0 ;
53829 void *argp1 = 0 ;
53830 int res1 = 0 ;
53831 PyObject *swig_obj[1] ;
53832
53833 if (!args) SWIG_fail;
53834 swig_obj[0] = args;
53835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53836 if (!SWIG_IsOK(res1)) {
53837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53838 }
53839 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53840 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53842 return resultobj;
53843 fail:
53844 return NULL;
53845 }
53846
53847
53848 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53849 PyObject *resultobj = 0;
53850 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53851 wxIndividualLayoutConstraint *result = 0 ;
53852 void *argp1 = 0 ;
53853 int res1 = 0 ;
53854 PyObject *swig_obj[1] ;
53855
53856 if (!args) SWIG_fail;
53857 swig_obj[0] = args;
53858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53859 if (!SWIG_IsOK(res1)) {
53860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53861 }
53862 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53863 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53865 return resultobj;
53866 fail:
53867 return NULL;
53868 }
53869
53870
53871 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53872 PyObject *resultobj = 0;
53873 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53874 wxIndividualLayoutConstraint *result = 0 ;
53875 void *argp1 = 0 ;
53876 int res1 = 0 ;
53877 PyObject *swig_obj[1] ;
53878
53879 if (!args) SWIG_fail;
53880 swig_obj[0] = args;
53881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53882 if (!SWIG_IsOK(res1)) {
53883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53884 }
53885 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53886 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53888 return resultobj;
53889 fail:
53890 return NULL;
53891 }
53892
53893
53894 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53895 PyObject *resultobj = 0;
53896 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53897 wxIndividualLayoutConstraint *result = 0 ;
53898 void *argp1 = 0 ;
53899 int res1 = 0 ;
53900 PyObject *swig_obj[1] ;
53901
53902 if (!args) SWIG_fail;
53903 swig_obj[0] = args;
53904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53905 if (!SWIG_IsOK(res1)) {
53906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53907 }
53908 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53909 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53911 return resultobj;
53912 fail:
53913 return NULL;
53914 }
53915
53916
53917 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53918 PyObject *resultobj = 0;
53919 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53920 wxIndividualLayoutConstraint *result = 0 ;
53921 void *argp1 = 0 ;
53922 int res1 = 0 ;
53923 PyObject *swig_obj[1] ;
53924
53925 if (!args) SWIG_fail;
53926 swig_obj[0] = args;
53927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53928 if (!SWIG_IsOK(res1)) {
53929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53930 }
53931 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53932 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53934 return resultobj;
53935 fail:
53936 return NULL;
53937 }
53938
53939
53940 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53941 PyObject *resultobj = 0;
53942 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53943 wxIndividualLayoutConstraint *result = 0 ;
53944 void *argp1 = 0 ;
53945 int res1 = 0 ;
53946 PyObject *swig_obj[1] ;
53947
53948 if (!args) SWIG_fail;
53949 swig_obj[0] = args;
53950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53951 if (!SWIG_IsOK(res1)) {
53952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53953 }
53954 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53955 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53957 return resultobj;
53958 fail:
53959 return NULL;
53960 }
53961
53962
53963 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53964 PyObject *resultobj = 0;
53965 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53966 wxIndividualLayoutConstraint *result = 0 ;
53967 void *argp1 = 0 ;
53968 int res1 = 0 ;
53969 PyObject *swig_obj[1] ;
53970
53971 if (!args) SWIG_fail;
53972 swig_obj[0] = args;
53973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53974 if (!SWIG_IsOK(res1)) {
53975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53976 }
53977 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53978 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53980 return resultobj;
53981 fail:
53982 return NULL;
53983 }
53984
53985
53986 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53987 PyObject *resultobj = 0;
53988 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53989 wxIndividualLayoutConstraint *result = 0 ;
53990 void *argp1 = 0 ;
53991 int res1 = 0 ;
53992 PyObject *swig_obj[1] ;
53993
53994 if (!args) SWIG_fail;
53995 swig_obj[0] = args;
53996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53997 if (!SWIG_IsOK(res1)) {
53998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53999 }
54000 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54001 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54003 return resultobj;
54004 fail:
54005 return NULL;
54006 }
54007
54008
54009 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54010 PyObject *resultobj = 0;
54011 wxLayoutConstraints *result = 0 ;
54012
54013 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54014 {
54015 PyThreadState* __tstate = wxPyBeginAllowThreads();
54016 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54017 wxPyEndAllowThreads(__tstate);
54018 if (PyErr_Occurred()) SWIG_fail;
54019 }
54020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54021 return resultobj;
54022 fail:
54023 return NULL;
54024 }
54025
54026
54027 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54028 PyObject *resultobj = 0;
54029 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54030 void *argp1 = 0 ;
54031 int res1 = 0 ;
54032 PyObject *swig_obj[1] ;
54033
54034 if (!args) SWIG_fail;
54035 swig_obj[0] = args;
54036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54037 if (!SWIG_IsOK(res1)) {
54038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54039 }
54040 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54041 {
54042 PyThreadState* __tstate = wxPyBeginAllowThreads();
54043 delete arg1;
54044
54045 wxPyEndAllowThreads(__tstate);
54046 if (PyErr_Occurred()) SWIG_fail;
54047 }
54048 resultobj = SWIG_Py_Void();
54049 return resultobj;
54050 fail:
54051 return NULL;
54052 }
54053
54054
54055 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54056 PyObject *resultobj = 0;
54057 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54058 wxWindow *arg2 = (wxWindow *) 0 ;
54059 int *arg3 = (int *) 0 ;
54060 bool result;
54061 void *argp1 = 0 ;
54062 int res1 = 0 ;
54063 void *argp2 = 0 ;
54064 int res2 = 0 ;
54065 int temp3 ;
54066 int res3 = SWIG_TMPOBJ ;
54067 PyObject * obj0 = 0 ;
54068 PyObject * obj1 = 0 ;
54069 char * kwnames[] = {
54070 (char *) "self",(char *) "win", NULL
54071 };
54072
54073 arg3 = &temp3;
54074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54076 if (!SWIG_IsOK(res1)) {
54077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54078 }
54079 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54080 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54081 if (!SWIG_IsOK(res2)) {
54082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54083 }
54084 arg2 = reinterpret_cast< wxWindow * >(argp2);
54085 {
54086 PyThreadState* __tstate = wxPyBeginAllowThreads();
54087 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54088 wxPyEndAllowThreads(__tstate);
54089 if (PyErr_Occurred()) SWIG_fail;
54090 }
54091 {
54092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54093 }
54094 if (SWIG_IsTmpObj(res3)) {
54095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54096 } else {
54097 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54099 }
54100 return resultobj;
54101 fail:
54102 return NULL;
54103 }
54104
54105
54106 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54107 PyObject *resultobj = 0;
54108 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54109 bool result;
54110 void *argp1 = 0 ;
54111 int res1 = 0 ;
54112 PyObject *swig_obj[1] ;
54113
54114 if (!args) SWIG_fail;
54115 swig_obj[0] = args;
54116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54117 if (!SWIG_IsOK(res1)) {
54118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54119 }
54120 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54121 {
54122 PyThreadState* __tstate = wxPyBeginAllowThreads();
54123 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54124 wxPyEndAllowThreads(__tstate);
54125 if (PyErr_Occurred()) SWIG_fail;
54126 }
54127 {
54128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54129 }
54130 return resultobj;
54131 fail:
54132 return NULL;
54133 }
54134
54135
54136 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54137 PyObject *obj;
54138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54139 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54140 return SWIG_Py_Void();
54141 }
54142
54143 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54144 return SWIG_Python_InitShadowInstance(args);
54145 }
54146
54147 static PyMethodDef SwigMethods[] = {
54148 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54149 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54150 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54151 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54152 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54153 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54154 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54155 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54156 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54158 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54171 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54172 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54173 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54175 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54176 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54177 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54178 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54179 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54180 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54181 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54183 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54189 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54190 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54191 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54192 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54193 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54194 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54195 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54197 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54205 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54206 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54207 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54212 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54213 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54215 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54217 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54219 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54221 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54223 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54225 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54226 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54228 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54229 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54230 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54232 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54234 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54235 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54236 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54237 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54246 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54257 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54258 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54259 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54260 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54261 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54262 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54263 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54264 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54265 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54266 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54267 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54268 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54273 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54274 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54275 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54276 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54283 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54284 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54287 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54288 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54290 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54291 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54292 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54293 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54294 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54295 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54296 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54297 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54299 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54300 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54301 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54302 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54307 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54308 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54309 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54310 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54311 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54312 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54315 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54316 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54317 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54319 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54320 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54321 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54322 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54323 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54324 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54325 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54326 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54327 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54328 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54329 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54330 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54331 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54332 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54333 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54338 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54344 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54345 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54346 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54347 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54349 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54351 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54352 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54355 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54358 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54359 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54360 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54363 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54364 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54365 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54369 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54370 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54371 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54375 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54380 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54381 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54382 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54383 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54384 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54385 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54386 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54393 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54394 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54396 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54397 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54398 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54404 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54405 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54407 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54408 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54409 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54410 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54411 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54412 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54413 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54414 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54416 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54417 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54418 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54419 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54420 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54421 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54422 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54423 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54425 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54434 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54437 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54446 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54451 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54452 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54467 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54468 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54469 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54470 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54473 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54474 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54475 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54477 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54479 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54481 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54484 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54485 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54486 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54487 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54489 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54504 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54506 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54507 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54509 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54510 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54513 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54514 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54516 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54517 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54518 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54519 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54520 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54521 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54522 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54523 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54524 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54525 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54526 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54527 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54528 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54529 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54530 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54531 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54532 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54533 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54534 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54535 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54536 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54537 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54538 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54539 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54540 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54541 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54542 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54543 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54544 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54545 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54546 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54547 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54548 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54550 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54551 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54552 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54553 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54554 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54555 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54556 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54557 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54558 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54559 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54560 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54562 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54563 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54564 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54565 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54566 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54567 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54568 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54569 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54570 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54572 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54573 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54574 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54576 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54578 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54579 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54580 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54582 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54583 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54585 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54586 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54587 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54589 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54590 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54591 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54593 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54595 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54596 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54597 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54599 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54601 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54602 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54604 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54605 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54606 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54608 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54609 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54610 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54611 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54612 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54614 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54615 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54618 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54619 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54620 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54621 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54622 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54625 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54626 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54628 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54634 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54635 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54636 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54637 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54638 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54639 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54640 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54641 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54642 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54643 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54644 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54645 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54646 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54647 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54648 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54649 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54650 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54651 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54652 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54653 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54654 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54655 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54656 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54657 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54659 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54660 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54661 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54662 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54663 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54664 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54665 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54666 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54667 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54668 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54669 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54670 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54671 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54672 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54673 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54674 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54675 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54676 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54677 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54678 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54679 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54680 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54681 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54682 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54683 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54684 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54685 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54686 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54687 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54688 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54689 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54690 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54691 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54692 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54693 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54695 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54696 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54697 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54698 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54699 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54700 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54701 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54702 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54703 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54704 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54705 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54706 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54707 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54708 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54710 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54711 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54712 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54713 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54714 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54715 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54716 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54717 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54718 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54719 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54720 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54721 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54722 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54723 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54724 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54725 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54726 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54727 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54728 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54729 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54730 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54731 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54732 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54733 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54734 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54735 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54736 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54737 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54738 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54739 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54740 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54742 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54743 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54744 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54745 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54746 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54747 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54748 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54750 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54751 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54753 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54754 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54755 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54757 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54758 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54760 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54761 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54763 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54764 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54765 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54767 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54768 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54769 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54770 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54772 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54773 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54774 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54776 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54777 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54778 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54780 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54781 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54783 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54784 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54785 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54786 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54787 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54790 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54792 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54793 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54794 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54795 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54796 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54798 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54799 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54800 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54801 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54802 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54803 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54804 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54805 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54807 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54808 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54809 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54810 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54811 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54812 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54813 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54814 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54815 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54816 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54817 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54818 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54819 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54820 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54821 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54822 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54823 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54824 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54825 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54826 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54827 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54829 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54830 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54831 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54832 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54833 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54834 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54835 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54836 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54838 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54839 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54840 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54842 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54843 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54844 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54845 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54846 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54847 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54848 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54849 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54850 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54851 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54852 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54854 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54855 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54856 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54857 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54858 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54860 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54862 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54864 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54865 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54867 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54868 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54869 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54870 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54871 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54872 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54873 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54874 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54875 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54876 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54878 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54879 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54880 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54881 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54882 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54884 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54886 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54887 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54888 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54889 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54891 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54892 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54894 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54896 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54897 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54898 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54899 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54900 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54901 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54902 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54903 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54904 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54906 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54907 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54908 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54909 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54910 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54911 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54912 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54913 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54915 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54917 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54919 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54920 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54921 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54922 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54923 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54924 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54925 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54926 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54927 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54928 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54929 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54930 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54932 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54934 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54935 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54936 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54937 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54938 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54939 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54940 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54942 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54943 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54944 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54945 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54946 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54947 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54948 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54950 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54952 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54953 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54954 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54955 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54956 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54957 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54958 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54959 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54960 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54961 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54962 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54963 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54964 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54965 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54967 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54968 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54969 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54970 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54972 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54973 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54974 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54975 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54977 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54978 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54979 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54980 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54981 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54982 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54983 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54984 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54987 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54988 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54989 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54990 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54991 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54992 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54993 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54994 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54996 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54997 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54998 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54999 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55001 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55002 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55003 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55004 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55005 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55006 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55007 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55008 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55009 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55010 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55012 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55015 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55016 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55017 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55018 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55019 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55021 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55023 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55025 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55026 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55028 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55029 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55039 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55040 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55044 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55045 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55046 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55047 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55048 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55049 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55050 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55051 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55052 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55053 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55054 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55055 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55056 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55057 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55058 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55060 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55061 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55064 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55065 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55066 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55069 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55070 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55071 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55074 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55075 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55076 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55077 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55078 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55079 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55080 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55081 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55082 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55084 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55085 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55086 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55087 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55088 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55089 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55090 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55091 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55093 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55095 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55097 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55098 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55099 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55100 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55101 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55102 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55103 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55104 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55105 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55106 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55107 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55108 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55109 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55110 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55111 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55112 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55117 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55120 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55121 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55122 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55123 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55124 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55125 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55126 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55127 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55129 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55130 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55131 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55132 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55133 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55138 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55139 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55140 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55141 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55142 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55145 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55146 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55147 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55148 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55149 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55150 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55151 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55152 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55154 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55155 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55156 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55157 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55158 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55162 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55163 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55164 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55165 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55167 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55168 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55170 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55173 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55174 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55175 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55176 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55177 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55186 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55190 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55191 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55192 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55193 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55194 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55198 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55200 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55201 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55202 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55203 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55204 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55205 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55206 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55209 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55210 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55212 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55213 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55215 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55217 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55218 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55219 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55220 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55221 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55222 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55223 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55224 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55225 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55226 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55227 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55228 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55229 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55230 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55231 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55232 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55233 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55234 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55235 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55236 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55237 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55238 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55239 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55240 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55241 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55242 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55243 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55244 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55245 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55247 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55248 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55249 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55250 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55251 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55252 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55253 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55254 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55255 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55256 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55257 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55258 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55259 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55261 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55262 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55263 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55264 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55265 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55266 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55267 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55268 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55269 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55270 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55271 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55272 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55275 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55276 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55277 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55278 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55281 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55282 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55284 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55287 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55288 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55289 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55290 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55291 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55294 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55295 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55296 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55297 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55299 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55300 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55301 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55302 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55303 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55304 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55305 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55306 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55307 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55308 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55309 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55311 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55312 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55313 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55314 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55315 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55316 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55317 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55318 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55319 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55320 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55321 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55323 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55325 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55326 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55328 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55329 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55330 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55331 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55332 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55333 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55334 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55335 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55336 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55337 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55338 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55339 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55340 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55341 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55342 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55343 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55345 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55346 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55347 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55348 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55349 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55350 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55351 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55352 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55353 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55354 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55355 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55356 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55357 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55358 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55359 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55360 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55361 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55362 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55363 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55364 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55365 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55366 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55367 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55368 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55369 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55370 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55371 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55372 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55373 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55374 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55375 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55376 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55377 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55378 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55379 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55380 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55381 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55382 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55383 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55384 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55385 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55386 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55387 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55388 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55389 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55390 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55391 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55392 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55393 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55394 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55395 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55396 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55397 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55398 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55399 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55400 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55401 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55402 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55403 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55404 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55405 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55406 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55407 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55408 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55409 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55410 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55411 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55412 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55413 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55414 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55415 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55416 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55417 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55418 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55419 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55420 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55421 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55422 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55423 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55424 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55425 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55426 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55427 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55428 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55430 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55431 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55432 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55433 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55434 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55435 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55436 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55438 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55439 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55440 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55441 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55442 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55443 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55444 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55445 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55446 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55447 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55448 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55449 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55450 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55451 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55452 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55453 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55454 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55455 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55456 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55457 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55458 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55459 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55460 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55461 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55462 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55466 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55468 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55469 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55471 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55473 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55474 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55475 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55476 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55477 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55478 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55479 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55480 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55481 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55482 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55483 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55484 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55485 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55486 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55487 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55488 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55489 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55490 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55491 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55492 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55493 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55494 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55495 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55496 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55497 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55498 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55499 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55500 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55501 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55502 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55503 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55504 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55505 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55506 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55507 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55508 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55509 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55510 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55511 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55512 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55513 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55514 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55515 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55516 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55517 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55518 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55519 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55520 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55521 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55522 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55523 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55524 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55525 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55526 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55527 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55528 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55529 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55530 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55531 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55532 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55533 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55534 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55535 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55536 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55537 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55538 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55539 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55540 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55541 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55542 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55543 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55544 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55545 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55547 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55548 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55549 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55550 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55551 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55552 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55553 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55554 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55555 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55556 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55557 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55558 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55559 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55560 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55561 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55562 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55563 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55564 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55565 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55566 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55567 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55568 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55569 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55570 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55571 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55572 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55573 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55574 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55575 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55576 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55577 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55578 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55579 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55580 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55581 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55582 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55583 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55584 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55585 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55586 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55587 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55588 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55589 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55590 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55591 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55592 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55593 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55594 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55595 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55596 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55597 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55598 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55599 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55600 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55601 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55602 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55603 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55604 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55605 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55606 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55607 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55608 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55609 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55610 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55611 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55612 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55613 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55614 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55615 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55616 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55617 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55618 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55619 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55620 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55621 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55622 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55623 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55624 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55625 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55626 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55627 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55628 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55629 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55630 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55631 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55632 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55633 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55634 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55635 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55636 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55637 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55638 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55639 { NULL, NULL, 0, NULL }
55640 };
55641
55642
55643 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55644
55645 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55646 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55647 }
55648 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55649 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55650 }
55651 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55652 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55653 }
55654 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55655 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55656 }
55657 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55658 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55659 }
55660 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55661 return (void *)((wxSizer *) ((wxGridSizer *) x));
55662 }
55663 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55664 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55665 }
55666 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55667 return (void *)((wxSizer *) ((wxPySizer *) x));
55668 }
55669 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55670 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55671 }
55672 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55673 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55674 }
55675 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55676 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55677 }
55678 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55679 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55680 }
55681 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55682 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55683 }
55684 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55685 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55686 }
55687 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55688 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55689 }
55690 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55691 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55692 }
55693 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55694 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55695 }
55696 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55697 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55698 }
55699 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55700 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55701 }
55702 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55703 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55704 }
55705 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55706 return (void *)((wxEvent *) ((wxPyEvent *) x));
55707 }
55708 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55709 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55710 }
55711 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55712 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55713 }
55714 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55715 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55716 }
55717 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55718 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55719 }
55720 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55721 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55722 }
55723 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55724 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55725 }
55726 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55727 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55728 }
55729 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55730 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55731 }
55732 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55733 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55734 }
55735 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55736 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55737 }
55738 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55739 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55740 }
55741 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55742 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55743 }
55744 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55745 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55746 }
55747 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55748 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55749 }
55750 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55751 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55752 }
55753 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55754 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55755 }
55756 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55757 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55758 }
55759 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55760 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55761 }
55762 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55763 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55764 }
55765 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55766 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55767 }
55768 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55769 return (void *)((wxEvent *) ((wxShowEvent *) x));
55770 }
55771 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55772 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55773 }
55774 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55775 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55776 }
55777 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55778 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55779 }
55780 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55781 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55782 }
55783 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55784 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55785 }
55786 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55787 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55788 }
55789 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55790 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55791 }
55792 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55793 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55794 }
55795 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55796 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55797 }
55798 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55799 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55800 }
55801 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55802 return (void *)((wxControl *) ((wxControlWithItems *) x));
55803 }
55804 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55805 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55806 }
55807 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55808 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55809 }
55810 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55811 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55812 }
55813 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55814 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55815 }
55816 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55817 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55818 }
55819 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55820 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55821 }
55822 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55823 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55824 }
55825 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55826 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55827 }
55828 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55829 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55830 }
55831 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55832 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55833 }
55834 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55835 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55836 }
55837 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55838 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55839 }
55840 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55841 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55842 }
55843 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55844 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55845 }
55846 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55847 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55848 }
55849 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55850 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55851 }
55852 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55853 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55854 }
55855 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55856 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55857 }
55858 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55859 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55860 }
55861 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55862 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55863 }
55864 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55865 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55866 }
55867 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55868 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55869 }
55870 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55871 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55872 }
55873 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55874 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55875 }
55876 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55877 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55878 }
55879 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55880 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55881 }
55882 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55883 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55884 }
55885 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55886 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55887 }
55888 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55889 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55890 }
55891 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55892 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55893 }
55894 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55895 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55896 }
55897 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55898 return (void *)((wxObject *) ((wxSizerItem *) x));
55899 }
55900 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55901 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55902 }
55903 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55904 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55905 }
55906 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55907 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55908 }
55909 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55910 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55911 }
55912 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55913 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55914 }
55915 static void *_p_wxSizerTo_p_wxObject(void *x) {
55916 return (void *)((wxObject *) ((wxSizer *) x));
55917 }
55918 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55919 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55920 }
55921 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55922 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55923 }
55924 static void *_p_wxEventTo_p_wxObject(void *x) {
55925 return (void *)((wxObject *) ((wxEvent *) x));
55926 }
55927 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55928 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55929 }
55930 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55931 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55932 }
55933 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55934 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55935 }
55936 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55937 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55938 }
55939 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55940 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55941 }
55942 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55943 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55944 }
55945 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55946 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55947 }
55948 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55949 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55950 }
55951 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55952 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55953 }
55954 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55955 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55956 }
55957 static void *_p_wxControlTo_p_wxObject(void *x) {
55958 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55959 }
55960 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55961 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55962 }
55963 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55964 return (void *)((wxObject *) ((wxFSFile *) x));
55965 }
55966 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55967 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55968 }
55969 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55970 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55971 }
55972 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55973 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55974 }
55975 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55976 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55977 }
55978 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55979 return (void *)((wxObject *) ((wxMenuItem *) x));
55980 }
55981 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55982 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55983 }
55984 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55985 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55986 }
55987 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55988 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55989 }
55990 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55991 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55992 }
55993 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55994 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55995 }
55996 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55997 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55998 }
55999 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56000 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56001 }
56002 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56003 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56004 }
56005 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56006 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56007 }
56008 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56009 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56010 }
56011 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56012 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56013 }
56014 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56015 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56016 }
56017 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56018 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56019 }
56020 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56021 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56022 }
56023 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56024 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56025 }
56026 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56027 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56028 }
56029 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56030 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56031 }
56032 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56033 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56034 }
56035 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56036 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56037 }
56038 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56039 return (void *)((wxObject *) ((wxImageHandler *) x));
56040 }
56041 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56042 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56043 }
56044 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56045 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56046 }
56047 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56048 return (void *)((wxObject *) ((wxEvtHandler *) x));
56049 }
56050 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56051 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56052 }
56053 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56054 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56055 }
56056 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56057 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56058 }
56059 static void *_p_wxImageTo_p_wxObject(void *x) {
56060 return (void *)((wxObject *) ((wxImage *) x));
56061 }
56062 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56063 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56064 }
56065 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56066 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56067 }
56068 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56069 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56070 }
56071 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56072 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56073 }
56074 static void *_p_wxWindowTo_p_wxObject(void *x) {
56075 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56076 }
56077 static void *_p_wxMenuTo_p_wxObject(void *x) {
56078 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56079 }
56080 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56081 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56082 }
56083 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56084 return (void *)((wxObject *) ((wxFileSystem *) x));
56085 }
56086 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56087 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56088 }
56089 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56090 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56091 }
56092 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56093 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56094 }
56095 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56096 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56097 }
56098 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56099 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56100 }
56101 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56102 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56103 }
56104 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56105 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56106 }
56107 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56108 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56109 }
56110 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56111 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56112 }
56113 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56114 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56115 }
56116 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56117 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56118 }
56119 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56120 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56121 }
56122 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56123 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56124 }
56125 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56126 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56127 }
56128 static void *_p_wxControlTo_p_wxWindow(void *x) {
56129 return (void *)((wxWindow *) ((wxControl *) x));
56130 }
56131 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56132 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56133 }
56134 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56135 return (void *)((wxWindow *) ((wxMenuBar *) x));
56136 }
56137 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56138 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56139 }
56140 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56141 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56142 }
56143 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56144 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56145 }
56146 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56147 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56148 }
56149 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56150 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56151 }
56152 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56153 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56154 }
56155 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56156 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56157 }
56158 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56159 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56160 }
56161 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56162 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56163 }
56164 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56165 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56166 }
56167 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56168 return (void *)((wxValidator *) ((wxPyValidator *) x));
56169 }
56170 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56171 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56172 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};
56173 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56174 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56175 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56176 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56177 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56178 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56179 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56180 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56181 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56182 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56183 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56184 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56185 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56186 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56187 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56188 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56189 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56190 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56191 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56192 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56193 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56194 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56195 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56196 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56197 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56198 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56199 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56200 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56201 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56202 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56203 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56204 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56205 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56206 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56207 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56208 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56209 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56210 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56211 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56212 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56213 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56214 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56215 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56216 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56217 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56218 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56219 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56220 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56221 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56222 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56223 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56224 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56225 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56226 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56227 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56228 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56229 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56230 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56231 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56232 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56233 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56234 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56235 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56236 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56237 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56238 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56239 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56240 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56241 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56242 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56243 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56244 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56245 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56246 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56247 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56248 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56249 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56250 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56251 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56252 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56253 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56254 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56255 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56256 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56257 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56258 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56259 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56260 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56261 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56262 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56263 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56264 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56265 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56266 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56267 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56268 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56269 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56270 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56271 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56272 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56273 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56274 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56275 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56276 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56277 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56278 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56279 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56280 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56281 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56282 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56283 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56284 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56285 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56286 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56287 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56288 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56289 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56290 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56291 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56292 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56293 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56294 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56295 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56296 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56297 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56298 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56299 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56300 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56301 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56302
56303 static swig_type_info *swig_type_initial[] = {
56304 &_swigt__p_buffer,
56305 &_swigt__p_char,
56306 &_swigt__p_form_ops_t,
56307 &_swigt__p_int,
56308 &_swigt__p_long,
56309 &_swigt__p_unsigned_char,
56310 &_swigt__p_unsigned_int,
56311 &_swigt__p_unsigned_long,
56312 &_swigt__p_wxANIHandler,
56313 &_swigt__p_wxAcceleratorEntry,
56314 &_swigt__p_wxAcceleratorTable,
56315 &_swigt__p_wxActivateEvent,
56316 &_swigt__p_wxAppTraits,
56317 &_swigt__p_wxArrayString,
56318 &_swigt__p_wxBMPHandler,
56319 &_swigt__p_wxBitmap,
56320 &_swigt__p_wxBoxSizer,
56321 &_swigt__p_wxButton,
56322 &_swigt__p_wxCURHandler,
56323 &_swigt__p_wxCaret,
56324 &_swigt__p_wxChildFocusEvent,
56325 &_swigt__p_wxClipboardTextEvent,
56326 &_swigt__p_wxCloseEvent,
56327 &_swigt__p_wxColour,
56328 &_swigt__p_wxCommandEvent,
56329 &_swigt__p_wxContextMenuEvent,
56330 &_swigt__p_wxControl,
56331 &_swigt__p_wxControlWithItems,
56332 &_swigt__p_wxCursor,
56333 &_swigt__p_wxDC,
56334 &_swigt__p_wxDateEvent,
56335 &_swigt__p_wxDateTime,
56336 &_swigt__p_wxDisplayChangedEvent,
56337 &_swigt__p_wxDropFilesEvent,
56338 &_swigt__p_wxDuplexMode,
56339 &_swigt__p_wxEraseEvent,
56340 &_swigt__p_wxEvent,
56341 &_swigt__p_wxEventLoop,
56342 &_swigt__p_wxEventLoopActivator,
56343 &_swigt__p_wxEvtHandler,
56344 &_swigt__p_wxFSFile,
56345 &_swigt__p_wxFileSystem,
56346 &_swigt__p_wxFileSystemHandler,
56347 &_swigt__p_wxFlexGridSizer,
56348 &_swigt__p_wxFocusEvent,
56349 &_swigt__p_wxFont,
56350 &_swigt__p_wxFrame,
56351 &_swigt__p_wxGBPosition,
56352 &_swigt__p_wxGBSizerItem,
56353 &_swigt__p_wxGBSpan,
56354 &_swigt__p_wxGIFHandler,
56355 &_swigt__p_wxGridBagSizer,
56356 &_swigt__p_wxGridSizer,
56357 &_swigt__p_wxHelpEvent__Origin,
56358 &_swigt__p_wxICOHandler,
56359 &_swigt__p_wxIconizeEvent,
56360 &_swigt__p_wxIdleEvent,
56361 &_swigt__p_wxImage,
56362 &_swigt__p_wxImageHandler,
56363 &_swigt__p_wxImageHistogram,
56364 &_swigt__p_wxImage_HSVValue,
56365 &_swigt__p_wxImage_RGBValue,
56366 &_swigt__p_wxIndividualLayoutConstraint,
56367 &_swigt__p_wxInitDialogEvent,
56368 &_swigt__p_wxInputStream,
56369 &_swigt__p_wxInternetFSHandler,
56370 &_swigt__p_wxItemContainer,
56371 &_swigt__p_wxJPEGHandler,
56372 &_swigt__p_wxKeyEvent,
56373 &_swigt__p_wxLayoutConstraints,
56374 &_swigt__p_wxMaximizeEvent,
56375 &_swigt__p_wxMemoryFSHandler,
56376 &_swigt__p_wxMenu,
56377 &_swigt__p_wxMenuBar,
56378 &_swigt__p_wxMenuBarBase,
56379 &_swigt__p_wxMenuEvent,
56380 &_swigt__p_wxMenuItem,
56381 &_swigt__p_wxMouseCaptureChangedEvent,
56382 &_swigt__p_wxMouseCaptureLostEvent,
56383 &_swigt__p_wxMouseEvent,
56384 &_swigt__p_wxMoveEvent,
56385 &_swigt__p_wxNavigationKeyEvent,
56386 &_swigt__p_wxNcPaintEvent,
56387 &_swigt__p_wxNotifyEvent,
56388 &_swigt__p_wxObject,
56389 &_swigt__p_wxOutputStream,
56390 &_swigt__p_wxPCXHandler,
56391 &_swigt__p_wxPNGHandler,
56392 &_swigt__p_wxPNMHandler,
56393 &_swigt__p_wxPaintEvent,
56394 &_swigt__p_wxPaletteChangedEvent,
56395 &_swigt__p_wxPaperSize,
56396 &_swigt__p_wxPoint,
56397 &_swigt__p_wxPoint2D,
56398 &_swigt__p_wxPropagateOnce,
56399 &_swigt__p_wxPropagationDisabler,
56400 &_swigt__p_wxPyApp,
56401 &_swigt__p_wxPyCommandEvent,
56402 &_swigt__p_wxPyDropTarget,
56403 &_swigt__p_wxPyEvent,
56404 &_swigt__p_wxPyFileSystemHandler,
56405 &_swigt__p_wxPyImageHandler,
56406 &_swigt__p_wxPyInputStream,
56407 &_swigt__p_wxPySizer,
56408 &_swigt__p_wxPyValidator,
56409 &_swigt__p_wxQuantize,
56410 &_swigt__p_wxQueryNewPaletteEvent,
56411 &_swigt__p_wxRealPoint,
56412 &_swigt__p_wxRect,
56413 &_swigt__p_wxRegion,
56414 &_swigt__p_wxScrollEvent,
56415 &_swigt__p_wxScrollWinEvent,
56416 &_swigt__p_wxSetCursorEvent,
56417 &_swigt__p_wxShowEvent,
56418 &_swigt__p_wxSize,
56419 &_swigt__p_wxSizeEvent,
56420 &_swigt__p_wxSizer,
56421 &_swigt__p_wxSizerItem,
56422 &_swigt__p_wxStaticBox,
56423 &_swigt__p_wxStaticBoxSizer,
56424 &_swigt__p_wxStdDialogButtonSizer,
56425 &_swigt__p_wxSysColourChangedEvent,
56426 &_swigt__p_wxTIFFHandler,
56427 &_swigt__p_wxToolTip,
56428 &_swigt__p_wxUpdateUIEvent,
56429 &_swigt__p_wxValidator,
56430 &_swigt__p_wxVisualAttributes,
56431 &_swigt__p_wxWindow,
56432 &_swigt__p_wxWindowCreateEvent,
56433 &_swigt__p_wxWindowDestroyEvent,
56434 &_swigt__p_wxXPMHandler,
56435 &_swigt__p_wxZipFSHandler,
56436 };
56437
56438 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56439 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56440 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56441 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56442 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56443 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56444 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56445 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56446 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56447 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56448 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56449 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56450 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56451 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56452 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}};
56453 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56454 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}};
56455 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56456 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}};
56457 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56458 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56459 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56460 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56461 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56462 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}};
56463 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56464 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}};
56465 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56466 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56467 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56468 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56469 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56470 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56471 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56472 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56473 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56474 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}};
56475 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56476 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56477 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}};
56478 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56479 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56480 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}};
56481 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}};
56482 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56483 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56484 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56485 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56486 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56487 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56488 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56489 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56490 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}};
56491 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56492 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}};
56493 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56494 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56495 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56496 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}};
56497 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56498 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56499 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56500 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56501 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56502 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56503 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56504 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}};
56505 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56506 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56507 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56508 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56509 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56510 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56511 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56512 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56513 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56514 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56515 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56516 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56517 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56518 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56519 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56520 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56521 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56522 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}};
56523 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56524 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56525 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56526 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56527 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56528 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56529 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56530 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56531 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56532 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56533 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56534 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56535 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56536 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56537 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56538 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56539 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56540 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56541 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56542 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56543 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56544 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56545 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56546 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56547 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56548 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56549 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56550 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56551 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56552 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56553 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56554 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}};
56555 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}};
56556 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56557 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56558 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56559 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56560 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56561 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56562 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56563 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}};
56564 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56565 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}};
56566 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56567 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56568 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56569 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56570
56571 static swig_cast_info *swig_cast_initial[] = {
56572 _swigc__p_buffer,
56573 _swigc__p_char,
56574 _swigc__p_form_ops_t,
56575 _swigc__p_int,
56576 _swigc__p_long,
56577 _swigc__p_unsigned_char,
56578 _swigc__p_unsigned_int,
56579 _swigc__p_unsigned_long,
56580 _swigc__p_wxANIHandler,
56581 _swigc__p_wxAcceleratorEntry,
56582 _swigc__p_wxAcceleratorTable,
56583 _swigc__p_wxActivateEvent,
56584 _swigc__p_wxAppTraits,
56585 _swigc__p_wxArrayString,
56586 _swigc__p_wxBMPHandler,
56587 _swigc__p_wxBitmap,
56588 _swigc__p_wxBoxSizer,
56589 _swigc__p_wxButton,
56590 _swigc__p_wxCURHandler,
56591 _swigc__p_wxCaret,
56592 _swigc__p_wxChildFocusEvent,
56593 _swigc__p_wxClipboardTextEvent,
56594 _swigc__p_wxCloseEvent,
56595 _swigc__p_wxColour,
56596 _swigc__p_wxCommandEvent,
56597 _swigc__p_wxContextMenuEvent,
56598 _swigc__p_wxControl,
56599 _swigc__p_wxControlWithItems,
56600 _swigc__p_wxCursor,
56601 _swigc__p_wxDC,
56602 _swigc__p_wxDateEvent,
56603 _swigc__p_wxDateTime,
56604 _swigc__p_wxDisplayChangedEvent,
56605 _swigc__p_wxDropFilesEvent,
56606 _swigc__p_wxDuplexMode,
56607 _swigc__p_wxEraseEvent,
56608 _swigc__p_wxEvent,
56609 _swigc__p_wxEventLoop,
56610 _swigc__p_wxEventLoopActivator,
56611 _swigc__p_wxEvtHandler,
56612 _swigc__p_wxFSFile,
56613 _swigc__p_wxFileSystem,
56614 _swigc__p_wxFileSystemHandler,
56615 _swigc__p_wxFlexGridSizer,
56616 _swigc__p_wxFocusEvent,
56617 _swigc__p_wxFont,
56618 _swigc__p_wxFrame,
56619 _swigc__p_wxGBPosition,
56620 _swigc__p_wxGBSizerItem,
56621 _swigc__p_wxGBSpan,
56622 _swigc__p_wxGIFHandler,
56623 _swigc__p_wxGridBagSizer,
56624 _swigc__p_wxGridSizer,
56625 _swigc__p_wxHelpEvent__Origin,
56626 _swigc__p_wxICOHandler,
56627 _swigc__p_wxIconizeEvent,
56628 _swigc__p_wxIdleEvent,
56629 _swigc__p_wxImage,
56630 _swigc__p_wxImageHandler,
56631 _swigc__p_wxImageHistogram,
56632 _swigc__p_wxImage_HSVValue,
56633 _swigc__p_wxImage_RGBValue,
56634 _swigc__p_wxIndividualLayoutConstraint,
56635 _swigc__p_wxInitDialogEvent,
56636 _swigc__p_wxInputStream,
56637 _swigc__p_wxInternetFSHandler,
56638 _swigc__p_wxItemContainer,
56639 _swigc__p_wxJPEGHandler,
56640 _swigc__p_wxKeyEvent,
56641 _swigc__p_wxLayoutConstraints,
56642 _swigc__p_wxMaximizeEvent,
56643 _swigc__p_wxMemoryFSHandler,
56644 _swigc__p_wxMenu,
56645 _swigc__p_wxMenuBar,
56646 _swigc__p_wxMenuBarBase,
56647 _swigc__p_wxMenuEvent,
56648 _swigc__p_wxMenuItem,
56649 _swigc__p_wxMouseCaptureChangedEvent,
56650 _swigc__p_wxMouseCaptureLostEvent,
56651 _swigc__p_wxMouseEvent,
56652 _swigc__p_wxMoveEvent,
56653 _swigc__p_wxNavigationKeyEvent,
56654 _swigc__p_wxNcPaintEvent,
56655 _swigc__p_wxNotifyEvent,
56656 _swigc__p_wxObject,
56657 _swigc__p_wxOutputStream,
56658 _swigc__p_wxPCXHandler,
56659 _swigc__p_wxPNGHandler,
56660 _swigc__p_wxPNMHandler,
56661 _swigc__p_wxPaintEvent,
56662 _swigc__p_wxPaletteChangedEvent,
56663 _swigc__p_wxPaperSize,
56664 _swigc__p_wxPoint,
56665 _swigc__p_wxPoint2D,
56666 _swigc__p_wxPropagateOnce,
56667 _swigc__p_wxPropagationDisabler,
56668 _swigc__p_wxPyApp,
56669 _swigc__p_wxPyCommandEvent,
56670 _swigc__p_wxPyDropTarget,
56671 _swigc__p_wxPyEvent,
56672 _swigc__p_wxPyFileSystemHandler,
56673 _swigc__p_wxPyImageHandler,
56674 _swigc__p_wxPyInputStream,
56675 _swigc__p_wxPySizer,
56676 _swigc__p_wxPyValidator,
56677 _swigc__p_wxQuantize,
56678 _swigc__p_wxQueryNewPaletteEvent,
56679 _swigc__p_wxRealPoint,
56680 _swigc__p_wxRect,
56681 _swigc__p_wxRegion,
56682 _swigc__p_wxScrollEvent,
56683 _swigc__p_wxScrollWinEvent,
56684 _swigc__p_wxSetCursorEvent,
56685 _swigc__p_wxShowEvent,
56686 _swigc__p_wxSize,
56687 _swigc__p_wxSizeEvent,
56688 _swigc__p_wxSizer,
56689 _swigc__p_wxSizerItem,
56690 _swigc__p_wxStaticBox,
56691 _swigc__p_wxStaticBoxSizer,
56692 _swigc__p_wxStdDialogButtonSizer,
56693 _swigc__p_wxSysColourChangedEvent,
56694 _swigc__p_wxTIFFHandler,
56695 _swigc__p_wxToolTip,
56696 _swigc__p_wxUpdateUIEvent,
56697 _swigc__p_wxValidator,
56698 _swigc__p_wxVisualAttributes,
56699 _swigc__p_wxWindow,
56700 _swigc__p_wxWindowCreateEvent,
56701 _swigc__p_wxWindowDestroyEvent,
56702 _swigc__p_wxXPMHandler,
56703 _swigc__p_wxZipFSHandler,
56704 };
56705
56706
56707 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56708
56709 static swig_const_info swig_const_table[] = {
56710 {0, 0, 0, 0.0, 0, 0}};
56711
56712 #ifdef __cplusplus
56713 }
56714 #endif
56715 /* -----------------------------------------------------------------------------
56716 * Type initialization:
56717 * This problem is tough by the requirement that no dynamic
56718 * memory is used. Also, since swig_type_info structures store pointers to
56719 * swig_cast_info structures and swig_cast_info structures store pointers back
56720 * to swig_type_info structures, we need some lookup code at initialization.
56721 * The idea is that swig generates all the structures that are needed.
56722 * The runtime then collects these partially filled structures.
56723 * The SWIG_InitializeModule function takes these initial arrays out of
56724 * swig_module, and does all the lookup, filling in the swig_module.types
56725 * array with the correct data and linking the correct swig_cast_info
56726 * structures together.
56727 *
56728 * The generated swig_type_info structures are assigned staticly to an initial
56729 * array. We just loop though that array, and handle each type individually.
56730 * First we lookup if this type has been already loaded, and if so, use the
56731 * loaded structure instead of the generated one. Then we have to fill in the
56732 * cast linked list. The cast data is initially stored in something like a
56733 * two-dimensional array. Each row corresponds to a type (there are the same
56734 * number of rows as there are in the swig_type_initial array). Each entry in
56735 * a column is one of the swig_cast_info structures for that type.
56736 * The cast_initial array is actually an array of arrays, because each row has
56737 * a variable number of columns. So to actually build the cast linked list,
56738 * we find the array of casts associated with the type, and loop through it
56739 * adding the casts to the list. The one last trick we need to do is making
56740 * sure the type pointer in the swig_cast_info struct is correct.
56741 *
56742 * First off, we lookup the cast->type name to see if it is already loaded.
56743 * There are three cases to handle:
56744 * 1) If the cast->type has already been loaded AND the type we are adding
56745 * casting info to has not been loaded (it is in this module), THEN we
56746 * replace the cast->type pointer with the type pointer that has already
56747 * been loaded.
56748 * 2) If BOTH types (the one we are adding casting info to, and the
56749 * cast->type) are loaded, THEN the cast info has already been loaded by
56750 * the previous module so we just ignore it.
56751 * 3) Finally, if cast->type has not already been loaded, then we add that
56752 * swig_cast_info to the linked list (because the cast->type) pointer will
56753 * be correct.
56754 * ----------------------------------------------------------------------------- */
56755
56756 #ifdef __cplusplus
56757 extern "C" {
56758 #if 0
56759 } /* c-mode */
56760 #endif
56761 #endif
56762
56763 #if 0
56764 #define SWIGRUNTIME_DEBUG
56765 #endif
56766
56767 SWIGRUNTIME void
56768 SWIG_InitializeModule(void *clientdata) {
56769 size_t i;
56770 swig_module_info *module_head;
56771 static int init_run = 0;
56772
56773 clientdata = clientdata;
56774
56775 if (init_run) return;
56776 init_run = 1;
56777
56778 /* Initialize the swig_module */
56779 swig_module.type_initial = swig_type_initial;
56780 swig_module.cast_initial = swig_cast_initial;
56781
56782 /* Try and load any already created modules */
56783 module_head = SWIG_GetModule(clientdata);
56784 if (module_head) {
56785 swig_module.next = module_head->next;
56786 module_head->next = &swig_module;
56787 } else {
56788 /* This is the first module loaded */
56789 swig_module.next = &swig_module;
56790 SWIG_SetModule(clientdata, &swig_module);
56791 }
56792
56793 /* Now work on filling in swig_module.types */
56794 #ifdef SWIGRUNTIME_DEBUG
56795 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56796 #endif
56797 for (i = 0; i < swig_module.size; ++i) {
56798 swig_type_info *type = 0;
56799 swig_type_info *ret;
56800 swig_cast_info *cast;
56801
56802 #ifdef SWIGRUNTIME_DEBUG
56803 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56804 #endif
56805
56806 /* if there is another module already loaded */
56807 if (swig_module.next != &swig_module) {
56808 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56809 }
56810 if (type) {
56811 /* Overwrite clientdata field */
56812 #ifdef SWIGRUNTIME_DEBUG
56813 printf("SWIG_InitializeModule: found type %s\n", type->name);
56814 #endif
56815 if (swig_module.type_initial[i]->clientdata) {
56816 type->clientdata = swig_module.type_initial[i]->clientdata;
56817 #ifdef SWIGRUNTIME_DEBUG
56818 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56819 #endif
56820 }
56821 } else {
56822 type = swig_module.type_initial[i];
56823 }
56824
56825 /* Insert casting types */
56826 cast = swig_module.cast_initial[i];
56827 while (cast->type) {
56828 /* Don't need to add information already in the list */
56829 ret = 0;
56830 #ifdef SWIGRUNTIME_DEBUG
56831 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56832 #endif
56833 if (swig_module.next != &swig_module) {
56834 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56835 #ifdef SWIGRUNTIME_DEBUG
56836 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56837 #endif
56838 }
56839 if (ret) {
56840 if (type == swig_module.type_initial[i]) {
56841 #ifdef SWIGRUNTIME_DEBUG
56842 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56843 #endif
56844 cast->type = ret;
56845 ret = 0;
56846 } else {
56847 /* Check for casting already in the list */
56848 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56849 #ifdef SWIGRUNTIME_DEBUG
56850 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56851 #endif
56852 if (!ocast) ret = 0;
56853 }
56854 }
56855
56856 if (!ret) {
56857 #ifdef SWIGRUNTIME_DEBUG
56858 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56859 #endif
56860 if (type->cast) {
56861 type->cast->prev = cast;
56862 cast->next = type->cast;
56863 }
56864 type->cast = cast;
56865 }
56866 cast++;
56867 }
56868 /* Set entry in modules->types array equal to the type */
56869 swig_module.types[i] = type;
56870 }
56871 swig_module.types[i] = 0;
56872
56873 #ifdef SWIGRUNTIME_DEBUG
56874 printf("**** SWIG_InitializeModule: Cast List ******\n");
56875 for (i = 0; i < swig_module.size; ++i) {
56876 int j = 0;
56877 swig_cast_info *cast = swig_module.cast_initial[i];
56878 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56879 while (cast->type) {
56880 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56881 cast++;
56882 ++j;
56883 }
56884 printf("---- Total casts: %d\n",j);
56885 }
56886 printf("**** SWIG_InitializeModule: Cast List ******\n");
56887 #endif
56888 }
56889
56890 /* This function will propagate the clientdata field of type to
56891 * any new swig_type_info structures that have been added into the list
56892 * of equivalent types. It is like calling
56893 * SWIG_TypeClientData(type, clientdata) a second time.
56894 */
56895 SWIGRUNTIME void
56896 SWIG_PropagateClientData(void) {
56897 size_t i;
56898 swig_cast_info *equiv;
56899 static int init_run = 0;
56900
56901 if (init_run) return;
56902 init_run = 1;
56903
56904 for (i = 0; i < swig_module.size; i++) {
56905 if (swig_module.types[i]->clientdata) {
56906 equiv = swig_module.types[i]->cast;
56907 while (equiv) {
56908 if (!equiv->converter) {
56909 if (equiv->type && !equiv->type->clientdata)
56910 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56911 }
56912 equiv = equiv->next;
56913 }
56914 }
56915 }
56916 }
56917
56918 #ifdef __cplusplus
56919 #if 0
56920 {
56921 /* c-mode */
56922 #endif
56923 }
56924 #endif
56925
56926
56927
56928 #ifdef __cplusplus
56929 extern "C" {
56930 #endif
56931
56932 /* Python-specific SWIG API */
56933 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56934 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56935 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56936
56937 /* -----------------------------------------------------------------------------
56938 * global variable support code.
56939 * ----------------------------------------------------------------------------- */
56940
56941 typedef struct swig_globalvar {
56942 char *name; /* Name of global variable */
56943 PyObject *(*get_attr)(void); /* Return the current value */
56944 int (*set_attr)(PyObject *); /* Set the value */
56945 struct swig_globalvar *next;
56946 } swig_globalvar;
56947
56948 typedef struct swig_varlinkobject {
56949 PyObject_HEAD
56950 swig_globalvar *vars;
56951 } swig_varlinkobject;
56952
56953 SWIGINTERN PyObject *
56954 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56955 return PyString_FromString("<Swig global variables>");
56956 }
56957
56958 SWIGINTERN PyObject *
56959 swig_varlink_str(swig_varlinkobject *v) {
56960 PyObject *str = PyString_FromString("(");
56961 swig_globalvar *var;
56962 for (var = v->vars; var; var=var->next) {
56963 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56964 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56965 }
56966 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56967 return str;
56968 }
56969
56970 SWIGINTERN int
56971 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56972 PyObject *str = swig_varlink_str(v);
56973 fprintf(fp,"Swig global variables ");
56974 fprintf(fp,"%s\n", PyString_AsString(str));
56975 Py_DECREF(str);
56976 return 0;
56977 }
56978
56979 SWIGINTERN void
56980 swig_varlink_dealloc(swig_varlinkobject *v) {
56981 swig_globalvar *var = v->vars;
56982 while (var) {
56983 swig_globalvar *n = var->next;
56984 free(var->name);
56985 free(var);
56986 var = n;
56987 }
56988 }
56989
56990 SWIGINTERN PyObject *
56991 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56992 PyObject *res = NULL;
56993 swig_globalvar *var = v->vars;
56994 while (var) {
56995 if (strcmp(var->name,n) == 0) {
56996 res = (*var->get_attr)();
56997 break;
56998 }
56999 var = var->next;
57000 }
57001 if (res == NULL && !PyErr_Occurred()) {
57002 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57003 }
57004 return res;
57005 }
57006
57007 SWIGINTERN int
57008 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57009 int res = 1;
57010 swig_globalvar *var = v->vars;
57011 while (var) {
57012 if (strcmp(var->name,n) == 0) {
57013 res = (*var->set_attr)(p);
57014 break;
57015 }
57016 var = var->next;
57017 }
57018 if (res == 1 && !PyErr_Occurred()) {
57019 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57020 }
57021 return res;
57022 }
57023
57024 SWIGINTERN PyTypeObject*
57025 swig_varlink_type(void) {
57026 static char varlink__doc__[] = "Swig var link object";
57027 static PyTypeObject varlink_type;
57028 static int type_init = 0;
57029 if (!type_init) {
57030 const PyTypeObject tmp
57031 = {
57032 PyObject_HEAD_INIT(NULL)
57033 0, /* Number of items in variable part (ob_size) */
57034 (char *)"swigvarlink", /* Type name (tp_name) */
57035 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57036 0, /* Itemsize (tp_itemsize) */
57037 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57038 (printfunc) swig_varlink_print, /* Print (tp_print) */
57039 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57040 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57041 0, /* tp_compare */
57042 (reprfunc) swig_varlink_repr, /* tp_repr */
57043 0, /* tp_as_number */
57044 0, /* tp_as_sequence */
57045 0, /* tp_as_mapping */
57046 0, /* tp_hash */
57047 0, /* tp_call */
57048 (reprfunc)swig_varlink_str, /* tp_str */
57049 0, /* tp_getattro */
57050 0, /* tp_setattro */
57051 0, /* tp_as_buffer */
57052 0, /* tp_flags */
57053 varlink__doc__, /* tp_doc */
57054 0, /* tp_traverse */
57055 0, /* tp_clear */
57056 0, /* tp_richcompare */
57057 0, /* tp_weaklistoffset */
57058 #if PY_VERSION_HEX >= 0x02020000
57059 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57060 #endif
57061 #if PY_VERSION_HEX >= 0x02030000
57062 0, /* tp_del */
57063 #endif
57064 #ifdef COUNT_ALLOCS
57065 0,0,0,0 /* tp_alloc -> tp_next */
57066 #endif
57067 };
57068 varlink_type = tmp;
57069 varlink_type.ob_type = &PyType_Type;
57070 type_init = 1;
57071 }
57072 return &varlink_type;
57073 }
57074
57075 /* Create a variable linking object for use later */
57076 SWIGINTERN PyObject *
57077 SWIG_Python_newvarlink(void) {
57078 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57079 if (result) {
57080 result->vars = 0;
57081 }
57082 return ((PyObject*) result);
57083 }
57084
57085 SWIGINTERN void
57086 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57087 swig_varlinkobject *v = (swig_varlinkobject *) p;
57088 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57089 if (gv) {
57090 size_t size = strlen(name)+1;
57091 gv->name = (char *)malloc(size);
57092 if (gv->name) {
57093 strncpy(gv->name,name,size);
57094 gv->get_attr = get_attr;
57095 gv->set_attr = set_attr;
57096 gv->next = v->vars;
57097 }
57098 }
57099 v->vars = gv;
57100 }
57101
57102 SWIGINTERN PyObject *
57103 SWIG_globals() {
57104 static PyObject *_SWIG_globals = 0;
57105 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57106 return _SWIG_globals;
57107 }
57108
57109 /* -----------------------------------------------------------------------------
57110 * constants/methods manipulation
57111 * ----------------------------------------------------------------------------- */
57112
57113 /* Install Constants */
57114 SWIGINTERN void
57115 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57116 PyObject *obj = 0;
57117 size_t i;
57118 for (i = 0; constants[i].type; ++i) {
57119 switch(constants[i].type) {
57120 case SWIG_PY_POINTER:
57121 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57122 break;
57123 case SWIG_PY_BINARY:
57124 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57125 break;
57126 default:
57127 obj = 0;
57128 break;
57129 }
57130 if (obj) {
57131 PyDict_SetItemString(d, constants[i].name, obj);
57132 Py_DECREF(obj);
57133 }
57134 }
57135 }
57136
57137 /* -----------------------------------------------------------------------------*/
57138 /* Fix SwigMethods to carry the callback ptrs when needed */
57139 /* -----------------------------------------------------------------------------*/
57140
57141 SWIGINTERN void
57142 SWIG_Python_FixMethods(PyMethodDef *methods,
57143 swig_const_info *const_table,
57144 swig_type_info **types,
57145 swig_type_info **types_initial) {
57146 size_t i;
57147 for (i = 0; methods[i].ml_name; ++i) {
57148 const char *c = methods[i].ml_doc;
57149 if (c && (c = strstr(c, "swig_ptr: "))) {
57150 int j;
57151 swig_const_info *ci = 0;
57152 const char *name = c + 10;
57153 for (j = 0; const_table[j].type; ++j) {
57154 if (strncmp(const_table[j].name, name,
57155 strlen(const_table[j].name)) == 0) {
57156 ci = &(const_table[j]);
57157 break;
57158 }
57159 }
57160 if (ci) {
57161 size_t shift = (ci->ptype) - types;
57162 swig_type_info *ty = types_initial[shift];
57163 size_t ldoc = (c - methods[i].ml_doc);
57164 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57165 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57166 if (ndoc) {
57167 char *buff = ndoc;
57168 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57169 if (ptr) {
57170 strncpy(buff, methods[i].ml_doc, ldoc);
57171 buff += ldoc;
57172 strncpy(buff, "swig_ptr: ", 10);
57173 buff += 10;
57174 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57175 methods[i].ml_doc = ndoc;
57176 }
57177 }
57178 }
57179 }
57180 }
57181 }
57182
57183 #ifdef __cplusplus
57184 }
57185 #endif
57186
57187 /* -----------------------------------------------------------------------------*
57188 * Partial Init method
57189 * -----------------------------------------------------------------------------*/
57190
57191 #ifdef __cplusplus
57192 extern "C"
57193 #endif
57194 SWIGEXPORT void SWIG_init(void) {
57195 PyObject *m, *d;
57196
57197 /* Fix SwigMethods to carry the callback ptrs when needed */
57198 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57199
57200 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57201 d = PyModule_GetDict(m);
57202
57203 SWIG_InitializeModule(0);
57204 SWIG_InstallConstants(d,swig_const_table);
57205
57206
57207
57208 #ifndef wxPyUSE_EXPORT
57209 // Make our API structure a CObject so other modules can import it
57210 // from this module.
57211 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57212 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57213 Py_XDECREF(cobj);
57214 #endif
57215
57216 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57217 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57218 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57219 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57220 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57221 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57222 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57223 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57224 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57225 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57226 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57227 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57228 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57229 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57230 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57231 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57232 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57233 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57234 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57235 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57236 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57237 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57238 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57239 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57240 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57241 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57242 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57243 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57244 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57245 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57246 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57247 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57248 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57249 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57250 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57251 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57252 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57253 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57254 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57255 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57256 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57257 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57258 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57259 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57260 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57261 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57262 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57263 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57264 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57265 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57266 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57267 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57268 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57269 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57270 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57271 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57272 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57273 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57274 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57275 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57276 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57277 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57278 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57279 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57280 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57281 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57282 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57283 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57284 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57285 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57286 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57287 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57288 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57289 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57290 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57291 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57292 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57293 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57294 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57295 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57296 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57297 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57298 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57299 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57300 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57301 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57302 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57303 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57304 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57305 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57306 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57307 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57308 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57309 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57310 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57311 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57312 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57313 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57314 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57315 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57316 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57317 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57318 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57319 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57320 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57321 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57322 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57323 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57324 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57325 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57326 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57327 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57328 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57329 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57330 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57331 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57332 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57333 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57334 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57335 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57336 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57337 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57338 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57339 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57340 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57341 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57342 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57343 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57344 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57345 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57346 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57347 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57348 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57349 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57350 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57351 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57352 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57353 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57354 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57355 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57356 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57357 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57358 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57359 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57360 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57361 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57362 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57363 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57364 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57365 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57366 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57367 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57368 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57369 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57370 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57371 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57372 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57373 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57374 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57375 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57376 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57377 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57378 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57379 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57380 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57381 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57382 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57383 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57384 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57385 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57386 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57387 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57388 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57389 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57390 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57391 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57392 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57393 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57394 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57395 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57396 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57397 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57398 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57399 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57400 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57401 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57402 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57403 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57404 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57405 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57406 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57407 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57408 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57409 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57410 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57411 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57412 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57413 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57414 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57415 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57416 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57417 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57418 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57419 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57420 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57421 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57422 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57423 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57424 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57425 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57426 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57427 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57428 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57429 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57430 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57431 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57432 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57433 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57434 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57435 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57436 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57437 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57438 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57439 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57440 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57441 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57442 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57443 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57444 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57445 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57446 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57447 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57448 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57449 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57450 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57451 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57452 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57453 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57454 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57455 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57456 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57457 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57458 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57459 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57460 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57461 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57462 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57463 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57464 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57465 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57466 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57467 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57468 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57469 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57470 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57471 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57472 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57473 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57474 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57475 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57476 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57477 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57478 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57479 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57480 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57481 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57482 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57483 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57484 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57485 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57486 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57487 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57488 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57489 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57490 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57491 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57492 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57493 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57494 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57495 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57496 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57497 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57498 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57499 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57500 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57501 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57502 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57503 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57504 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57505 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57506 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57507 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57508 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57509 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57510 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57511 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57512 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57513 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57514 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57515 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57516 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57517 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57518 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57519 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57520 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57521 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57522 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57523 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57524 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57525 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57526 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57527 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57528 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57529 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57530 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57531 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57532 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57533 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57534 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57535 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57536 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57537 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57538 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57539 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57540 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57541 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57542 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57543 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57544 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57545 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57546 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57547 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57548 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57549 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57550 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57551 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57552 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57553 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57554 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57555 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57556 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57557 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57558 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57559 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57560 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57561 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57562 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57563 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57564 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57565 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57566 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57567 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57568 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57569 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57570 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57571 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57572 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57573 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57574 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57575 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57576 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57577 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57578 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57579 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57580 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57581 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57582 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57583 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57584 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57585 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57586 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57587 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57588 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57589 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57590 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57591 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57592 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57593 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57594 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57595 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57596 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57597 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57598 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57599 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57600 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57601 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57602 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57603 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57604 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57605 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57606 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57607 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57608 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57609 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57610 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57611 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57612 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57613 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57614 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57615 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57616 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57617 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57618 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57619 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57620 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57621 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57622 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57623 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57624 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57625 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57626 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57627 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57628 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57629 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57630 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57631 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57632 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57633 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57634 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57635 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57636 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57637 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57638 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57639 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57640 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57641 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57642 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57643 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57644 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57645 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57646 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57647 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57648 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57649 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57650 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57651 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57652 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57653 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57654 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57655 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57656 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57657 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57658 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57659 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57660 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57661 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57662 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57663 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57664 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57665 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57666 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57667 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57668 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57669 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57670 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57671 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57672 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57673 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57674 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57675 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57676 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57677 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57678 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57679 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57680 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57681 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57682 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57683 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57684 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57685 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57686 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57687 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57688 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57689 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57690 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57691 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57692 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57693 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57694 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57695 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57696 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57697 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57698 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57699 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57700 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57701 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57702 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57703 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57704 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57705 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57706 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57707 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57708 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57709 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57710 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57711 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57712 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57713 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57714 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57715 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57716 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57717 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57718 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57719 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57720 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57721 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57722 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57723 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57724 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57725 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57726 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57727 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57728 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57729 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57730 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57731 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57732 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57733 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57734 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57735 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57736 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57737 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57738 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57739 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57740 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57741 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57742 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57743 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57744 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57745 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57746 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57747 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57748 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57749 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57750 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57751 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57752 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57753 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57754 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57755 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57756 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57757 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57758 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57759 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57760 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57761 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57762 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57763 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57764 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57765 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57766 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57767 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57768 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57769 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57770 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57771 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57772 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57773 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57774 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57775 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57776 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57777 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57778 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57779 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57780 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57781 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57782 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57783 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57784 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57785 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57786 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57787 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57788 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57789 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57790 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57791 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57792 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57793 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57794 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57795 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57796 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57797 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57798 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57799 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57800 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57801 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57802 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57803 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57804 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57805 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57806 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57807 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57808 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57809 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57810 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57811 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57812 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57813 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57814 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57815 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57816 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57817 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57818 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57819 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57820 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57821 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57822 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57823 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57824 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57825 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57826 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57827 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57828 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57829 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57830 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57831 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57832 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57833 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57834 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57835 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57836 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57837 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57838 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57839 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57840 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57841 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57842 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57843 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57844 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57845 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57846 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57847 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57848 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57849 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57850 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57851 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57852 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57853 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57854 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57855 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57856 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57857 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57858 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57859 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57860 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57861 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57862 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57863 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57864 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57865 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57866 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57867 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57868 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57869 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57870 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57871 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57872 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57873 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57874 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57875
57876 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57877
57878
57879 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57880
57881 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57882 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57883 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57884 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
57885 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
57886 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57887 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57888 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57889 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57890 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57891 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57892 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57893 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57894 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57895 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57896 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57897 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57898 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57899 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57900 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57901 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57902 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57903 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57904 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57905 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57906 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57907 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57908 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57909 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57910 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57911 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57912 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57913 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57914 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57915 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57916 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57917 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57918 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57919 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57920 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57921 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57922 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57923 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57924 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57925 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57926 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57927 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57928 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57929 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57930 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57931 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57932 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57933 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57934 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57935 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57936 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57937 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57938 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57939 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57940 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57941 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57942 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57943 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57944 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57945 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57946 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57947 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57948 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57949 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57950 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57951 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57952 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57953 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57954 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57955 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57956 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57957 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57958 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57959 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57960 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57961 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57962 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57963 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57964 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57965 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57966 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57967 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57968 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57969 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57970 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57971 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57972 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57973 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57974 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57975 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57976 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57977 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57978 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57979 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57980 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57981 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57982 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57983 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57984 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57985 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57986 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57987 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57988 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57989 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57990 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57991 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57992 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57993 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57994 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57995 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57996 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57997 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57998 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57999 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58000 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58001 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58002 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58003 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58004 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58005 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58006 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58007 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58008 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58009 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58010 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58011 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58012 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58013 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58014 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58015 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58016 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58017 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58018 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58019 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58020 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58021 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58022 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58023 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58024 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58025 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58026 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58027 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58028 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58029 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58030 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58031 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58032 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58033 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58034 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58035 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58036 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58037 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58038 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58039 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58040 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58041 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58042 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58043 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58044 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58045 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58046 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58047 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58048 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58049 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58050 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58051 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58052 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58053 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58054 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58055 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58056 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58057 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58058 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58059 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58060 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58061 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58062 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58063 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58064 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58065 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58066 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58067 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58068 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58069 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58070 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58071 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58072 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58073 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58074 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58075 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58076 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58077 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58078 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58079 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58080 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58081 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58082 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58083 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58084 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58085 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58086 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58087 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58088 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58089 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58090 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58091 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58092 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58093 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58094 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58095
58096 // Initialize threading, some globals and such
58097 __wxPyPreStart(d);
58098
58099
58100 // Although these are defined in __version__ they need to be here too so
58101 // that an assert can be done to ensure that the wxPython and the wxWindows
58102 // versions match.
58103 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58104 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58105 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58106
58107 }
58108
wxWidgets (Impactor)